winutf8.h

Go to the documentation of this file.

/*
  Copyright (c) Mircea Neacsu (2014-2024) Licensed under MIT License.
  This is part of UTF8 project. See LICENSE file for full license terms.
*/
 
#pragma once
 
#include <Windows.h>
#include <string>
#include <ostream>
 
#undef MessageBox
#undef CopyFile
#undef LoadString
#undef ShellExecute
#undef GetTempPath
#undef GetTempFileName
#undef GetFullPathName
#undef GetModuleFileName
#undef RegCreateKey
#undef RegDeleteKey
#undef RegOpenKey
#undef RegSetValue
#undef RegQueryValue
#undef RegGetValue
#undef RegDeleteTree
#undef RegEnumKey
#undef RegDeleteValue
#undef RegEnumValue
 
namespace utf8 {
 
std::vector<std::string> get_argv ();
char** get_argv (int* argc);
void free_argv (int argc, char** argv);
 
bool chmod (const char* filename, int mode);
bool chmod (const std::string& filename, int mode);
 
bool access (const char* filename, int mode);
bool access (const std::string& filename, int mode);
 
bool splitpath (const std::string& path, char* drive, char* dir, char* fname, char* ext);
bool splitpath (const std::string& path, std::string& drive, std::string& dir,
                std::string& fname, std::string& ext);
bool makepath (std::string& path, const std::string& drive, const std::string& dir,
                const std::string& fname, const std::string& ext);
std::string fullpath (const std::string& relpath);
 
std::string getenv (const std::string& var);
bool putenv (const std::string& str);
bool putenv (const std::string& var, const std::string& val);
 
bool symlink (const char* path, const char* link, bool directory);
bool symlink (const std::string& path, const std::string& target, bool directory);
 
int system (const std::string& cmd);
 
int MessageBox (HWND hWnd, const std::string& text, const std::string& caption,
  unsigned int type);
bool CopyFile (const std::string& from, const std::string& to, bool fail_exist);
std::string LoadString (UINT id, HINSTANCE hInst = NULL);
 
//registry functions
LSTATUS RegCreateKey (HKEY key, const std::string& subkey, HKEY& result,
  DWORD options = REG_OPTION_NON_VOLATILE, REGSAM sam = KEY_ALL_ACCESS,
  const SECURITY_ATTRIBUTES* psa = nullptr, DWORD* disp = nullptr);
LSTATUS RegOpenKey (HKEY key, const std::string& subkey, HKEY& result,
  REGSAM sam = KEY_ALL_ACCESS, bool link = false);
LSTATUS RegDeleteKey (HKEY key, const std::string& subkey, REGSAM sam = 0);
LSTATUS RegDeleteValue (HKEY key, const std::string& value);
LSTATUS RegDeleteTree (HKEY key, const std::string& subkey = std::string ());
LSTATUS RegRenameKey (HKEY key, const std::string& subkey, const std::string& new_name);
LSTATUS RegSetValue (HKEY key, const std::string& value, DWORD type, const void* data, DWORD size);
LSTATUS RegSetValue (HKEY key, const std::string& value, const std::string& data);
LSTATUS RegSetValue (HKEY key, const std::string& value, const std::vector<std::string>& data);
LSTATUS RegQueryValue (HKEY key, const std::string& value, DWORD* type, void* data, DWORD* size);
LSTATUS RegGetValue (HKEY key, const std::string& subkey, const std::string& value,
  DWORD flags, void* data, DWORD* size, DWORD* type = NULL);
LSTATUS RegGetValue (HKEY key, const std::string& subkey, const std::string& value,
  std::string& data, bool expand = false);
LSTATUS RegGetValue (HKEY key, const std::string& subkey, const std::string& value,
  std::vector<std::string>& data);
LSTATUS RegEnumKey (HKEY key, DWORD index, std::string& name, DWORD maxlen = 0, FILETIME* last_write_time = NULL);
LSTATUS RegEnumKey (HKEY key, std::vector<std::string>& names);
LSTATUS RegEnumValue (HKEY key, DWORD index, std::string& value, DWORD maxlen = 0, DWORD* type = 0, void* data = 0, DWORD* data_len = 0);
LSTATUS RegEnumValue (HKEY key, std::vector<std::string>& values);
 
HINSTANCE ShellExecute (const std::string& file, const std::string& verb = std::string (),
                        const std::string& parameters = std::string (),
                        const std::string& directory = std::string ("."),
                        HWND hWnd = NULL, int show = SW_SHOW);
std::string GetTempPath ();
std::string GetTempFileName (const std::string& path, const std::string& prefix, UINT unique=0);
std::string GetFullPathName (const std::string& rel_path);
bool GetModuleFileName (HMODULE hModule, std::string& filename);
std::string GetModuleFileName (HMODULE hModule = NULL);
 
struct find_data {
  find_data ()                        
    : handle{ INVALID_HANDLE_VALUE }
    , attributes{ 0 }
    , creation_time{ 0, 0 }
    , access_time{ 0,0 }
    , write_time{ 0,0 }
    , size{ 0 }
  {}
  HANDLE   handle;                    
  DWORD    attributes;                
  FILETIME creation_time;             
  FILETIME access_time;               
  FILETIME write_time;                
  __int64  size;                      
  std::string  filename;              
  std::string  short_name;            
};
 
bool find_first (const std::string& name, find_data& fdat);
bool find_next (find_data& fdat);
void find_close (find_data& fdat);
 
class file_enumerator : protected find_data
{
public:
  explicit file_enumerator (const std::string& name);
  ~file_enumerator ();
  bool ok () const;
  bool next ();
 
  operator bool () const;
 
  find_data::attributes;
  find_data::creation_time;
  find_data::access_time;
  find_data::write_time;
  find_data::size;
  find_data::filename;
  find_data::short_name;
};
 
class buffer {
public:
  explicit buffer (size_t size_);
  ~buffer ();
  buffer (const buffer& other);
  buffer& operator = (const buffer& rhs);
  buffer& operator = (const std::string& rhs);
  operator wchar_t* ();
  operator std::string () const;
  DWORD size () const;
 
private:
  wchar_t *ptr;
  size_t sz;
};
 
inline std::ostream&
operator << (std::ostream& s, const buffer& b)
{
  s << (std::string)b;
  return s;
}
 
 
//--------------------- INLINE FUNCTIONS --------------------------------------
 
inline
bool chmod (const char* filename, int mode)
{
  return (_wchmod (widen (filename).c_str (), mode) == 0);
}
 
inline
bool chmod (const std::string& filename, int mode)
{
  return (_wchmod (widen (filename).c_str (), mode) == 0);
}
 
 
inline
bool access (const char* filename, int mode)
{
  return (_waccess (widen (filename).c_str (), mode) == 0);
}
 
inline
bool access (const std::string& filename, int mode)
{
  return (_waccess (widen (filename).c_str (), mode) == 0);
}
 
 
inline
bool putenv (const std::string& str)
{
  return (_wputenv (utf8::widen (str).c_str ()) == 0);
}
 
inline
bool putenv (const std::string& var, const std::string& val)
{
  return (_wputenv_s (widen (var).c_str (),
    widen (val).c_str ()) == 0);
}
 
inline
int system (const std::string& cmd)
{
  std::wstring wcmd = utf8::widen (cmd);
  return _wsystem (wcmd.c_str ());
}
 
// -------------------- file_enumerator ------------------------------------
 
inline
file_enumerator::file_enumerator (const std::string& name)
{
  find_first (name, *this);
}
 
inline
file_enumerator::~file_enumerator ()
{
  if (handle != INVALID_HANDLE_VALUE)
    find_close (*this);
}
 
inline
bool file_enumerator::ok () const
{
  return (handle != INVALID_HANDLE_VALUE);
}
 
inline
file_enumerator::operator bool () const
{
  return ok ();
}
 
inline
bool file_enumerator::next ()
{
  return find_next (*this);
}
 
//---------------------------- buffer ----------------------------------------
 
inline
  buffer::operator wchar_t* ()
{
  return ptr;
}
 
inline
  buffer::operator std::string () const
{
  return utf8::narrow (ptr);
}
 
inline DWORD
  buffer::size () const
{
  return (DWORD)sz;
}
 
} //end namespace