Common.h
/*
SPDX-License-Identifier: MIT
Copyright © 1991-2022 Amebis
Copyright © 2016 GÉANT
*/
#pragma once
#define _WINSOCKAPI_ // Prevent inclusion of winsock.h in windows.h.
#include <Windows.h>
#include <assert.h>
#include <stdarg.h>
#include <tchar.h>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#ifndef __L
#define __L(x) L ## x
#endif
#ifndef _L
#define _L(x) __L(x)
#endif
#define WINSTD_STRING_IMPL(x) #x
#define WINSTD_STRING(x) WINSTD_STRING_IMPL(x)
#define WINSTD_NONCOPYABLE(C) \
private: \
C (_In_ const C &h) noexcept; \
C& operator=(_In_ const C &h) noexcept;
#define WINSTD_NONMOVABLE(C) \
private: \
C (_Inout_ C &&h) noexcept; \
C& operator=(_Inout_ C &&h) noexcept;
#ifndef WINSTD_STACK_BUFFER_BYTES
#define WINSTD_STACK_BUFFER_BYTES 1024
#endif
#ifdef UNICODE
#define PRINTF_LPTSTR "ls"
#else
#define PRINTF_LPTSTR "s"
#endif
#ifdef OLE2ANSI
#define PRINTF_LPOLESTR "hs"
#else
#define PRINTF_LPOLESTR "ls"
#endif
#ifdef _UNICODE
#define _tcin (std::wcin )
#else
#define _tcin (std::cin )
#endif
#ifdef _UNICODE
#define _tcout (std::wcout)
#else
#define _tcout (std::cout)
#endif
#ifdef _UNICODE
#define _tcerr (std::wcerr)
#else
#define _tcerr (std::cerr)
#endif
#ifdef _UNICODE
#define _tclog (std::wclog)
#else
#define _tclog (std::clog)
#endif
#define WINSTD_HANDLE_IMPL(C, INVAL) \
public: \
C ( ) noexcept { } \
C (_In_opt_ handle_type h) noexcept : handle<handle_type, INVAL>( h ) { } \
C (_Inout_ C &&h) noexcept : handle<handle_type, INVAL>(std::move(h)) { } \
C& operator=(_In_opt_ handle_type h) noexcept { handle<handle_type, INVAL>::operator=( h ); return *this; } \
C& operator=(_Inout_ C &&h) noexcept { handle<handle_type, INVAL>::operator=(std::move(h)); return *this; } \
WINSTD_NONCOPYABLE(C)
#define WINSTD_DPLHANDLE_IMPL(C, INVAL) \
public: \
C ( ) noexcept { } \
C (_In_opt_ handle_type h) noexcept : dplhandle<handle_type, INVAL>( h ) { } \
C (_In_ const C &h) noexcept : dplhandle<handle_type, INVAL>(duplicate_internal(h.m_h)) { } \
C (_Inout_ C &&h) noexcept : dplhandle<handle_type, INVAL>(std::move (h )) { } \
C& operator=(_In_opt_ handle_type h) noexcept { dplhandle<handle_type, INVAL>::operator=( h ); return *this; } \
C& operator=(_In_ const C &h) noexcept { dplhandle<handle_type, INVAL>::operator=( h ); return *this; } \
C& operator=(_Inout_ C &&h) noexcept { dplhandle<handle_type, INVAL>::operator=(std::move(h)); return *this; } \
private:
#ifndef _FormatMessage_format_string_
#define _FormatMessage_format_string_ _In_z_
#endif
#ifndef _LPCBYTE_DEFINED
#define _LPCBYTE_DEFINED
typedef const BYTE *LPCBYTE;
#endif
#pragma warning(push)
// Do not use _vsnprintf_s/_vsnwprintf_s(), since it terminates string by force even when we explicitly want to write unterminated string.
// Threfore turn off compiler warning instead. ;)
#pragma warning(disable: 4995)
#pragma warning(disable: 4996)
#pragma warning(disable: 4505) // Don't warn on unused code
#if _MSC_VER <= 1600
static int vsnprintf(_Out_z_cap_(capacity) char *str, _In_ size_t capacity, _In_z_ _Printf_format_string_ const char *format, _In_ va_list arg)
{
return _vsnprintf(str, capacity, format, arg);
}
#endif
static int vsnprintf(_Out_z_cap_(capacity) wchar_t *str, _In_ size_t capacity, _In_z_ _Printf_format_string_ const wchar_t *format, _In_ va_list arg) noexcept
{
return _vsnwprintf(str, capacity, format, arg);
}
template<class _Elem, class _Traits, class _Ax>
static int vsprintf(_Inout_ std::basic_string<_Elem, _Traits, _Ax> &str, _In_z_ _Printf_format_string_ const _Elem *format, _In_ va_list arg)
{
_Elem buf[WINSTD_STACK_BUFFER_BYTES/sizeof(_Elem)];
// Try with stack buffer first.
int count = vsnprintf(buf, _countof(buf) - 1, format, arg);
if (count >= 0) {
// Copy from stack.
str.assign(buf, count);
} else {
for (size_t capacity = 2*WINSTD_STACK_BUFFER_BYTES/sizeof(_Elem);; capacity *= 2) {
// Allocate on heap and retry.
auto buf_dyn = std::make_unique<_Elem[]>(capacity);
count = vsnprintf(buf_dyn.get(), capacity - 1, format, arg);
if (count >= 0) {
str.assign(buf_dyn.get(), count);
break;
}
}
}
return count;
}
template<class _Elem, class _Traits, class _Ax>
static int sprintf(_Inout_ std::basic_string<_Elem, _Traits, _Ax> &str, _In_z_ _Printf_format_string_ const _Elem *format, ...)
{
va_list arg;
va_start(arg, format);
const int res = vsprintf(str, format, arg);
va_end(arg);
return res;
}
template<class _Traits, class _Ax>
static DWORD FormatMessage(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _Inout_ std::basic_string<char, _Traits, _Ax> &str, _In_opt_ va_list *Arguments)
{
std::unique_ptr<CHAR[], winstd::LocalFree_delete<CHAR[]> > lpBuffer;
DWORD dwResult = FormatMessageA(dwFlags | FORMAT_MESSAGE_ALLOCATE_BUFFER, lpSource, dwMessageId, dwLanguageId, reinterpret_cast<LPSTR>((LPSTR*)get_ptr(lpBuffer)), 0, Arguments);
if (dwResult)
str.assign(lpBuffer.get(), dwResult);
return dwResult;
}
template<class _Traits, class _Ax>
static DWORD FormatMessage(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _Inout_ std::basic_string<wchar_t, _Traits, _Ax> &str, _In_opt_ va_list *Arguments)
{
std::unique_ptr<WCHAR[], winstd::LocalFree_delete<WCHAR[]> > lpBuffer;
DWORD dwResult = FormatMessageW(dwFlags | FORMAT_MESSAGE_ALLOCATE_BUFFER, lpSource, dwMessageId, dwLanguageId, reinterpret_cast<LPWSTR>((LPWSTR*)get_ptr(lpBuffer)), 0, Arguments);
if (dwResult)
str.assign(lpBuffer.get(), dwResult);
return dwResult;
}
#pragma warning(pop)
namespace winstd
{
#ifdef _UNICODE
typedef std::wstring tstring;
#else
typedef std::string tstring;
#endif
template <class _Ty>
struct LocalFree_delete
{
typedef LocalFree_delete<_Ty> _Myt;
LocalFree_delete() {}
template <class _Ty2> LocalFree_delete(const LocalFree_delete<_Ty2>&) {}
void operator()(_Ty *_Ptr) const
{
LocalFree(_Ptr);
}
};
template <class _Ty>
struct LocalFree_delete<_Ty[]>
{
typedef LocalFree_delete<_Ty> _Myt;
LocalFree_delete() noexcept {}
void operator()(_Frees_ptr_opt_ _Ty *_Ptr) const noexcept
{
LocalFree(_Ptr);
}
template<class _Other>
void operator()(_Other *) const
{
LocalFree(_Ptr);
}
};
template<class _Ty, class _Dx>
class ref_unique_ptr
{
public:
ref_unique_ptr(_Inout_ std::unique_ptr<_Ty, _Dx> &owner) :
m_own(owner),
m_ptr(owner.release())
{}
ref_unique_ptr(_Inout_ ref_unique_ptr<_Ty, _Dx> &&other) :
m_own(other.m_own),
m_ptr(other.m_ptr)
{
other.m_ptr = nullptr;
}
~ref_unique_ptr()
{
if (m_ptr != nullptr)
m_own.reset(m_ptr);
}
operator typename _Ty**()
{
return &m_ptr;
}
operator typename _Ty*&()
{
return m_ptr;
}
protected:
std::unique_ptr<_Ty, _Dx> &m_own;
_Ty *m_ptr;
};
template<class _Ty, class _Dx>
ref_unique_ptr<_Ty, _Dx> get_ptr(_Inout_ std::unique_ptr<_Ty, _Dx> &owner) noexcept
{
return ref_unique_ptr<_Ty, _Dx>(owner);
}
template<class _Ty, class _Dx>
ref_unique_ptr<_Ty[], _Dx> get_ptr(_Inout_ std::unique_ptr<_Ty[], _Dx> &owner) noexcept
{
return ref_unique_ptr<_Ty[], _Dx>(owner);
}
#pragma warning(push)
#pragma warning(disable: 26432) // Copy constructor and assignment operator are also present, but not detected by code analysis as they are using base type source object reference.
template<class _Ty, class _Dx>
class ref_unique_ptr<_Ty[], _Dx>
{
public:
ref_unique_ptr(_Inout_ std::unique_ptr<_Ty[], _Dx> &owner) noexcept :
m_own(owner),
m_ptr(owner.release())
{}
ref_unique_ptr& operator=(_Inout_ std::unique_ptr<_Ty[], _Dx> &owner) noexcept
{
if (this != &other) {
m_own = owner;
m_ptr = owner.release();
}
return *this;
}
ref_unique_ptr(_Inout_ ref_unique_ptr<_Ty[], _Dx> &&other) :
m_own(other.m_own),
m_ptr(other.m_ptr)
{
other.m_ptr = nullptr;
}
ref_unique_ptr& operator=(_Inout_ ref_unique_ptr<_Ty[], _Dx> &&other)
{
if (this != &other) {
m_own = other.m_own;
m_ptr = other.m_ptr;
other.m_ptr = nullptr;
}
return *this;
}
virtual ~ref_unique_ptr()
{
if (m_ptr != nullptr)
m_own.reset(m_ptr);
}
operator typename _Ty**() noexcept
{
return &m_ptr;
}
operator typename _Ty*&()
{
return m_ptr;
}
protected:
std::unique_ptr<_Ty[], _Dx> &m_own;
_Ty *m_ptr;
};
#pragma warning(pop)
template <class T, const T INVAL>
class handle
{
public:
typedef T handle_type;
static const T invalid;
handle() noexcept : m_h(invalid)
{
}
handle(_In_opt_ handle_type h) noexcept : m_h(h)
{
}
handle(_Inout_ handle<handle_type, INVAL> &&h) noexcept
{
// Transfer handle.
m_h = h.m_h;
h.m_h = invalid;
}
private:
// This class is noncopyable.
handle(_In_ const handle<handle_type, INVAL> &h) noexcept {};
handle<handle_type, INVAL>& operator=(_In_ const handle<handle_type, INVAL> &h) noexcept {};
public:
handle<handle_type, INVAL>& operator=(_In_opt_ handle_type h) noexcept
{
attach(h);
return *this;
}
#pragma warning(suppress: 26432) // Move constructor is also present, but not detected by code analysis somehow.
handle<handle_type, INVAL>& operator=(_Inout_ handle<handle_type, INVAL> &&h) noexcept
{
if (this != std::addressof(h)) {
// Transfer handle.
if (m_h != invalid)
free_internal();
m_h = h.m_h;
h.m_h = invalid;
}
return *this;
}
operator handle_type() const
{
return m_h;
}
handle_type*& operator*() const
{
assert(m_h != invalid);
return *m_h;
}
handle_type* operator&()
{
assert(m_h == invalid);
return &m_h;
}
handle_type operator->() const
{
assert(m_h != invalid);
return m_h;
}
bool operator!() const
{
return m_h == invalid;
}
bool operator<(_In_opt_ handle_type h) const
{
return m_h < h;
}
bool operator<=(_In_opt_ handle_type h) const
{
return !operator>(h);
}
bool operator>=(_In_opt_ handle_type h) const
{
return !operator<(h);
}
bool operator>(_In_opt_ handle_type h) const
{
return h < m_h;
}
bool operator!=(_In_opt_ handle_type h) const
{
return !operator==(h);
}
bool operator==(_In_opt_ handle_type h) const
{
return m_h == h;
}
void attach(_In_opt_ handle_type h) noexcept
{
if (m_h != invalid)
free_internal();
m_h = h;
}
handle_type detach()
{
handle_type h = m_h;
m_h = invalid;
return h;
}
void free()
{
if (m_h != invalid) {
free_internal();
m_h = invalid;
}
}
protected:
virtual void free_internal() noexcept = 0;
protected:
handle_type m_h;
};
template <class T, const T INVAL>
const T handle<T, INVAL>::invalid = INVAL;
template <class T, T INVAL>
class dplhandle : public handle<T, INVAL>
{
public:
dplhandle() noexcept
{
}
dplhandle(_In_opt_ handle_type h) noexcept : handle<handle_type, INVAL>(h)
{
}
dplhandle<handle_type, INVAL>(_In_ const dplhandle<handle_type, INVAL> &h) noexcept : handle<handle_type, INVAL>(duplicate_internal(h.m_h))
{
}
dplhandle<handle_type, INVAL>(_Inout_ dplhandle<handle_type, INVAL> &&h) noexcept : handle<handle_type, INVAL>(std::move(h))
{
}
dplhandle<handle_type, INVAL>& operator=(_In_opt_ handle_type h) noexcept
{
handle<handle_type, INVAL>::operator=(h);
return *this;
}
dplhandle<handle_type, INVAL>& operator=(_In_ const dplhandle<handle_type, INVAL> &h) noexcept
{
if (this != std::addressof(h)) {
if (h.m_h != invalid) {
handle_type h_new = duplicate_internal(h.m_h);
if (h_new != invalid) {
if (m_h != invalid)
free_internal();
m_h = h_new;
} else
assert(0); // Could not duplicate the handle
} else {
if (m_h != invalid)
free_internal();
m_h = invalid;
}
}
return *this;
}
#pragma warning(disable: 26432) // Move constructor is also present, but not detected by code analysis somehow.
dplhandle<handle_type, INVAL>& operator=(_Inout_ dplhandle<handle_type, INVAL> &&h) noexcept
{
handle<handle_type, INVAL>::operator=(std::move(h));
return *this;
}
handle_type duplicate() const
{
return m_h != invalid ? duplicate_internal(m_h) : invalid;
}
bool attach_duplicated(_In_opt_ handle_type h)
{
if (m_h != invalid)
free_internal();
return h != invalid ? (m_h = duplicate_internal(h)) != invalid : (m_h = invalid, true);
}
protected:
virtual handle_type duplicate_internal(_In_ handle_type h) const noexcept = 0;
};
template <typename _Tn>
class num_runtime_error : public std::runtime_error
{
public:
typedef _Tn error_type;
public:
num_runtime_error(_In_ error_type num, _In_ const std::string& msg) :
m_num(num),
runtime_error(msg)
{
}
num_runtime_error(_In_ error_type num, _In_opt_z_ const char *msg = nullptr) :
m_num(num),
runtime_error(msg)
{
}
error_type number() const
{
return m_num;
}
protected:
error_type m_num;
};
class win_runtime_error : public num_runtime_error<DWORD>
{
public:
win_runtime_error(_In_ error_type num, _In_ const std::string& msg) : num_runtime_error<DWORD>(num, msg)
{
}
win_runtime_error(_In_ error_type num, _In_opt_z_ const char *msg = nullptr) : num_runtime_error<DWORD>(num, msg)
{
}
win_runtime_error(_In_ const std::string& msg) : num_runtime_error<DWORD>(GetLastError(), msg)
{
}
win_runtime_error(_In_opt_z_ const char *msg = nullptr) : num_runtime_error<DWORD>(GetLastError(), msg)
{
}
tstring msg(_In_opt_ DWORD dwLanguageId = 0) const
{
tstring str;
if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, m_num, dwLanguageId, str, NULL)) {
// Stock Windows error messages contain CRLF. Well... Trim all the trailing white space.
str.erase(str.find_last_not_of(_T(" \t\n\r\f\v")) + 1);
} else
sprintf(str, m_num >= 0x10000 ? _T("Error 0x%X") : _T("Error %u"), m_num);
return str;
}
};
template<class _Elem, class _Traits, class _Ax>
class basic_string_printf : public std::basic_string<_Elem, _Traits, _Ax>
{
public:
basic_string_printf(_In_z_ _Printf_format_string_ const _Elem *format, ...)
{
va_list arg;
va_start(arg, format);
vsprintf(*this, format, arg);
va_end(arg);
}
basic_string_printf(_In_ HINSTANCE hInstance, _In_ UINT nFormatID, ...)
{
_Myt format;
ATLENSURE(format.LoadString(hInstance, nFormatID));
va_list arg;
va_start(arg, nFormatID);
vsprintf(*this, format, arg);
va_end(arg);
}
basic_string_printf(_In_ HINSTANCE hInstance, _In_ WORD wLanguageID, _In_ UINT nFormatID, ...)
{
_Myt format;
ATLENSURE(format.LoadString(hInstance, nFormatID, wLanguageID));
va_list arg;
va_start(arg, nFormatID);
vsprintf(*this, format, arg);
va_end(arg);
}
};
typedef basic_string_printf<char, std::char_traits<char>, std::allocator<char> > string_printf;
typedef basic_string_printf<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > wstring_printf;
#ifdef _UNICODE
typedef wstring_printf tstring_printf;
#else
typedef string_printf tstring_printf;
#endif
template<class _Elem, class _Traits, class _Ax>
class basic_string_msg : public std::basic_string<_Elem, _Traits, _Ax>
{
public:
basic_string_msg(_In_z_ _FormatMessage_format_string_ const _Elem *format, ...)
{
va_list arg;
va_start(arg, format);
FormatMessage(FORMAT_MESSAGE_FROM_STRING, format, 0, 0, *this, &arg);
va_end(arg);
}
basic_string_msg(_In_ HINSTANCE hInstance, _In_ UINT nFormatID, ...)
{
_Myt format(GetManager());
ATLENSURE(format.LoadString(hInstance, nFormatID));
va_list arg;
va_start(arg, nFormatID);
FormatMessage(FORMAT_MESSAGE_FROM_STRING, format, 0, 0, *this, &arg);
va_end(arg);
}
basic_string_msg(_In_ HINSTANCE hInstance, _In_ WORD wLanguageID, _In_ UINT nFormatID, ...)
{
_Myt format(GetManager());
ATLENSURE(format.LoadString(hInstance, nFormatID, wLanguageID));
va_list arg;
va_start(arg, nFormatID);
FormatMessage(FORMAT_MESSAGE_FROM_STRING, format, 0, 0, *this, &arg);
va_end(arg);
}
basic_string_msg(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _In_opt_ va_list *Arguments)
{
FormatMessage(dwFlags & ~FORMAT_MESSAGE_ARGUMENT_ARRAY, lpSource, dwMessageId, dwLanguageId, *this, Arguments);
}
basic_string_msg(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _In_opt_ DWORD_PTR *Arguments)
{
FormatMessage(dwFlags | FORMAT_MESSAGE_ARGUMENT_ARRAY, lpSource, dwMessageId, dwLanguageId, *this, (va_list*)Arguments);
}
basic_string_msg(_In_ DWORD dwFlags, _In_z_ LPCTSTR pszFormat, _In_opt_ va_list *Arguments)
{
FormatMessage(dwFlags & ~FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_FROM_STRING, pszFormat, 0, 0, *this, Arguments);
}
basic_string_msg(_In_ DWORD dwFlags, _In_z_ LPCTSTR pszFormat, _In_opt_ DWORD_PTR *Arguments)
{
FormatMessage(dwFlags | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_FROM_STRING, pszFormat, 0, 0, *this, (va_list*)Arguments);
}
};
typedef basic_string_msg<char, std::char_traits<char>, std::allocator<char> > string_msg;
typedef basic_string_msg<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > wstring_msg;
#ifdef _UNICODE
typedef wstring_msg tstring_msg;
#else
typedef string_msg tstring_msg;
#endif
template<class _Elem, class _Traits, class _Ax>
class basic_string_guid : public std::basic_string<_Elem, _Traits, _Ax>
{
public:
basic_string_guid(_In_ const GUID &guid, _In_z_ _Printf_format_string_ const _Elem *format)
{
sprintf<_Elem, _Traits, _Ax>(*this, format,
guid.Data1,
guid.Data2,
guid.Data3,
guid.Data4[0], guid.Data4[1],
guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
}
};
class string_guid : public basic_string_guid<char, std::char_traits<char>, std::allocator<char> >
{
public:
string_guid(_In_ const GUID &guid) :
basic_string_guid<char, std::char_traits<char>, std::allocator<char> >(guid, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}")
{
}
};
class wstring_guid : public basic_string_guid<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >
{
public:
wstring_guid(_In_ const GUID &guid) :
basic_string_guid<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >(guid, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}")
{
}
};
#ifdef _UNICODE
typedef wstring_guid tstring_guid;
#else
typedef string_guid tstring_guid;
#endif
// winstd::sanitizing_allocator::destroy() member generates _Ptr parameter not used warning for primitive datatypes _Ty.
#pragma warning(push)
#pragma warning(disable: 4100)
template<class _Ty>
class sanitizing_allocator : public std::allocator<_Ty>
{
public:
typedef std::allocator<_Ty> _Mybase;
template<class _Other>
struct rebind
{
typedef sanitizing_allocator<_Other> other;
};
sanitizing_allocator() noexcept : _Mybase()
{
}
sanitizing_allocator(_In_ const sanitizing_allocator<_Ty> &_Othr) : _Mybase(_Othr)
{
}
template<class _Other>
sanitizing_allocator(_In_ const sanitizing_allocator<_Other> &_Othr) noexcept : _Mybase(_Othr)
{
}
void deallocate(_In_ pointer _Ptr, _In_ size_type _Size)
{
// Sanitize then free.
SecureZeroMemory(_Ptr, _Size);
_Mybase::deallocate(_Ptr, _Size);
}
};
#pragma warning(pop)
typedef std::basic_string<char, std::char_traits<char>, sanitizing_allocator<char> > sanitizing_string;
typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, sanitizing_allocator<wchar_t> > sanitizing_wstring;
#ifdef _UNICODE
typedef sanitizing_wstring sanitizing_tstring;
#else
typedef sanitizing_string sanitizing_tstring;
#endif
template<size_t N>
class sanitizing_blob
{
public:
sanitizing_blob()
{
ZeroMemory(m_data, N);
}
~sanitizing_blob()
{
SecureZeroMemory(m_data, N);
}
public:
unsigned char m_data[N];
};
}
winstd::basic_string_guid
Base template class to support converting GUID to string.
Definition: Common.h:1325
winstd::basic_string_guid::basic_string_guid
basic_string_guid(const GUID &guid, const _Elem *format)
Initializes a new string and formats its contents to string representation of given GUID.
Definition: Common.h:1336
winstd::basic_string_msg
Base template class to support string formatting using FormatMessage() style templates.
Definition: Common.h:1200
winstd::basic_string_msg::basic_string_msg
basic_string_msg(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, DWORD_PTR *Arguments)
Initializes a new string and formats its contents using FormatMessage() style.
Definition: Common.h:1275
winstd::basic_string_msg::basic_string_msg
basic_string_msg(DWORD dwFlags, LPCTSTR pszFormat, va_list *Arguments)
Initializes a new string and formats its contents using FormatMessage() style.
Definition: Common.h:1285
winstd::basic_string_msg::basic_string_msg
basic_string_msg(HINSTANCE hInstance, WORD wLanguageID, UINT nFormatID,...)
Initializes a new string and formats its contents using FormatMessage() style template in resources.
Definition: Common.h:1247
winstd::basic_string_msg::basic_string_msg
basic_string_msg(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, va_list *Arguments)
Initializes a new string and formats its contents using FormatMessage() style.
Definition: Common.h:1265
winstd::basic_string_msg::basic_string_msg
basic_string_msg(const _Elem *format,...)
Initializes a new string and formats its contents using FormatMessage() style template.
Definition: Common.h:1210
winstd::basic_string_msg::basic_string_msg
basic_string_msg(HINSTANCE hInstance, UINT nFormatID,...)
Initializes a new string and formats its contents using FormatMessage() style template in resources.
Definition: Common.h:1229
winstd::basic_string_msg::basic_string_msg
basic_string_msg(DWORD dwFlags, LPCTSTR pszFormat, DWORD_PTR *Arguments)
Initializes a new string and formats its contents using FormatMessage() style.
Definition: Common.h:1295
winstd::basic_string_printf
Base template class to support string formatting using printf() style templates.
Definition: Common.h:1115
winstd::basic_string_printf::basic_string_printf
basic_string_printf(const _Elem *format,...)
Initializes a new string and formats its contents using printf() style template.
Definition: Common.h:1125
winstd::basic_string_printf::basic_string_printf
basic_string_printf(HINSTANCE hInstance, WORD wLanguageID, UINT nFormatID,...)
Initializes a new string and formats its contents using printf() style template in resources.
Definition: Common.h:1162
winstd::basic_string_printf::basic_string_printf
basic_string_printf(HINSTANCE hInstance, UINT nFormatID,...)
Initializes a new string and formats its contents using printf() style template in resources.
Definition: Common.h:1144
winstd::dplhandle
Base abstract template class to support object handle keeping for objects that support handle duplica...
Definition: Common.h:866
winstd::dplhandle::operator=
dplhandle< handle_type, INVAL > & operator=(handle_type h) noexcept
Attaches already available object handle.
Definition: Common.h:907
winstd::dplhandle::duplicate
handle_type duplicate() const
Duplicates and returns a new object handle.
Definition: Common.h:957
winstd::dplhandle::operator=
dplhandle< handle_type, INVAL > & operator=(dplhandle< handle_type, INVAL > &&h) noexcept
Moves the object.
Definition: Common.h:946
winstd::dplhandle::attach_duplicated
bool attach_duplicated(handle_type h)
Duplicates an object handle and sets a new object handle.
Definition: Common.h:971
winstd::dplhandle::duplicate_internal
virtual handle_type duplicate_internal(handle_type h) const noexcept=0
Abstract member function that must be implemented by child classes to do the actual object handle dup...
winstd::dplhandle::dplhandle
dplhandle(handle_type h) noexcept
Initializes a new class instance with an already available object handle.
Definition: Common.h:880
winstd::dplhandle::operator=
dplhandle< handle_type, INVAL > & operator=(const dplhandle< handle_type, INVAL > &h) noexcept
Duplicates the object.
Definition: Common.h:918
winstd::dplhandle::dplhandle
dplhandle() noexcept
Initializes a new class instance with the object handle set to INVAL.
Definition: Common.h:871
winstd::handle
Base abstract template class to support generic object handle keeping.
Definition: Common.h:604
winstd::handle::operator*
handle_type *& operator*() const
Returns the object handle value when the object handle is a pointer to a value (class,...
Definition: Common.h:694
winstd::handle::free_internal
virtual void free_internal() noexcept=0
Abstract member function that must be implemented by child classes to do the actual object destructio...
winstd::handle::handle
handle() noexcept
Initializes a new class instance with the object handle set to INVAL.
Definition: Common.h:619
winstd::handle::operator>=
bool operator>=(handle_type h) const
Is handle greater than or equal to?
Definition: Common.h:767
winstd::handle::operator->
handle_type operator->() const
Provides object handle member access when the object handle is a pointer to a class or struct.
Definition: Common.h:715
winstd::handle::operator&
handle_type * operator&()
Returns the object handle reference.
Definition: Common.h:704
winstd::handle::handle_type
T handle_type
Datatype of the object handle this template class handles.
Definition: Common.h:609
winstd::handle::handle
handle(handle_type h) noexcept
Initializes a new class instance with an already available object handle.
Definition: Common.h:628
winstd::handle::operator<
bool operator<(handle_type h) const
Is handle less than?
Definition: Common.h:741
winstd::handle::operator=
handle< handle_type, INVAL > & operator=(handle_type h) noexcept
Attaches already available object handle.
Definition: Common.h:655
winstd::handle::operator!
bool operator!() const
Tests if the object handle is INVAL.
Definition: Common.h:728
winstd::handle::operator=
handle< handle_type, INVAL > & operator=(handle< handle_type, INVAL > &&h) noexcept
Move assignment.
Definition: Common.h:667
winstd::handle::operator!=
bool operator!=(handle_type h) const
Is handle not equal to?
Definition: Common.h:793
winstd::handle::free
void free()
Destroys the object.
Definition: Common.h:840
winstd::handle::m_h
handle_type m_h
Object handle.
Definition: Common.h:855
winstd::handle::attach
void attach(handle_type h) noexcept
Sets a new object handle for the class.
Definition: Common.h:818
winstd::handle::operator==
bool operator==(handle_type h) const
Is handle equal to?
Definition: Common.h:806
winstd::handle::handle
handle(handle< handle_type, INVAL > &&h) noexcept
Move constructor.
Definition: Common.h:637
winstd::handle::detach
handle_type detach()
Dismisses the object handle from this class.
Definition: Common.h:830
winstd::handle::operator>
bool operator>(handle_type h) const
Is handle greater than?
Definition: Common.h:780
winstd::handle::operator<=
bool operator<=(handle_type h) const
Is handle less than or equal to?
Definition: Common.h:754
winstd::num_runtime_error
Numerical runtime error.
Definition: Common.h:1003
winstd::num_runtime_error::num_runtime_error
num_runtime_error(error_type num, const char *msg=nullptr)
Constructs an exception.
Definition: Common.h:1026
winstd::num_runtime_error::num_runtime_error
num_runtime_error(error_type num, const std::string &msg)
Constructs an exception.
Definition: Common.h:1014
winstd::num_runtime_error::number
error_type number() const
Returns the Windows error number.
Definition: Common.h:1035
winstd::num_runtime_error::error_type
_Tn error_type
Error number type.
Definition: Common.h:1005
winstd::num_runtime_error::m_num
error_type m_num
Numeric error code.
Definition: Common.h:1041
winstd::ref_unique_ptr< _Ty[], _Dx >
Helper class for returning pointers to std::unique_ptr (specialization for arrays)
Definition: Common.h:498
winstd::ref_unique_ptr< _Ty[], _Dx >::m_own
std::unique_ptr< _Ty[], _Dx > & m_own
Original owner of the pointer.
Definition: Common.h:587
winstd::ref_unique_ptr< _Ty[], _Dx >::ref_unique_ptr
ref_unique_ptr(ref_unique_ptr< _Ty[], _Dx > &&other)
Moves object.
Definition: Common.h:532
winstd::ref_unique_ptr< _Ty[], _Dx >::~ref_unique_ptr
virtual ~ref_unique_ptr()
Returns ownership of the pointer.
Definition: Common.h:560
winstd::ref_unique_ptr< _Ty[], _Dx >::operator=
ref_unique_ptr & operator=(std::unique_ptr< _Ty[], _Dx > &owner) noexcept
Takes ownership of the pointer.
Definition: Common.h:517
winstd::ref_unique_ptr< _Ty[], _Dx >::ref_unique_ptr
ref_unique_ptr(std::unique_ptr< _Ty[], _Dx > &owner) noexcept
Takes ownership of the pointer.
Definition: Common.h:505
winstd::ref_unique_ptr< _Ty[], _Dx >::m_ptr
_Ty * m_ptr
Pointer.
Definition: Common.h:588
winstd::ref_unique_ptr< _Ty[], _Dx >::operator=
ref_unique_ptr & operator=(ref_unique_ptr< _Ty[], _Dx > &&other)
Moves object.
Definition: Common.h:546
winstd::ref_unique_ptr
Helper class for returning pointers to std::unique_ptr.
Definition: Common.h:405
winstd::ref_unique_ptr::m_own
std::unique_ptr< _Ty, _Dx > & m_own
Original owner of the pointer.
Definition: Common.h:459
winstd::ref_unique_ptr::m_ptr
_Ty * m_ptr
Pointer.
Definition: Common.h:460
winstd::ref_unique_ptr::ref_unique_ptr
ref_unique_ptr(ref_unique_ptr< _Ty, _Dx > &&other)
Moves object.
Definition: Common.h:422
winstd::ref_unique_ptr::~ref_unique_ptr
~ref_unique_ptr()
Returns ownership of the pointer.
Definition: Common.h:432
winstd::ref_unique_ptr::ref_unique_ptr
ref_unique_ptr(std::unique_ptr< _Ty, _Dx > &owner)
Takes ownership of the pointer.
Definition: Common.h:412
winstd::sanitizing_allocator
An allocator template that sanitizes each memory block before it is destroyed or reallocated.
Definition: Common.h:1423
winstd::sanitizing_allocator::sanitizing_allocator
sanitizing_allocator(const sanitizing_allocator< _Ty > &_Othr)
Construct by copying.
Definition: Common.h:1446
winstd::sanitizing_allocator::deallocate
void deallocate(pointer _Ptr, size_type _Size)
Deallocate object at _Ptr sanitizing its content first.
Definition: Common.h:1461
winstd::sanitizing_allocator::sanitizing_allocator
sanitizing_allocator(const sanitizing_allocator< _Other > &_Othr) noexcept
Construct from a related allocator.
Definition: Common.h:1454
winstd::sanitizing_allocator::_Mybase
std::allocator< _Ty > _Mybase
Base type.
Definition: Common.h:1425
winstd::sanitizing_allocator::sanitizing_allocator
sanitizing_allocator() noexcept
Construct default allocator.
Definition: Common.h:1439
winstd::sanitizing_blob
Sanitizing BLOB.
Definition: Common.h:1503
winstd::sanitizing_blob::sanitizing_blob
sanitizing_blob()
Constructs uninitialized BLOB.
Definition: Common.h:1508
winstd::sanitizing_blob::~sanitizing_blob
~sanitizing_blob()
Sanitizes BLOB.
Definition: Common.h:1516
winstd::string_guid
Single-byte character implementation of a class to support converting GUID to string.
Definition: Common.h:1353
winstd::string_guid::string_guid
string_guid(const GUID &guid)
Initializes a new string and formats its contents to string representation of given GUID.
Definition: Common.h:1363
winstd::win_runtime_error
Windows runtime error.
Definition: Common.h:1048
winstd::win_runtime_error::msg
tstring msg(DWORD dwLanguageId=0) const
Returns a user-readable Windows error message.
Definition: Common.h:1093
winstd::win_runtime_error::win_runtime_error
win_runtime_error(error_type num, const char *msg=nullptr)
Constructs an exception.
Definition: Common.h:1066
winstd::win_runtime_error::win_runtime_error
win_runtime_error(const std::string &msg)
Constructs an exception using GetLastError()
Definition: Common.h:1075
winstd::win_runtime_error::win_runtime_error
win_runtime_error(const char *msg=nullptr)
Constructs an exception using GetLastError()
Definition: Common.h:1084
winstd::win_runtime_error::win_runtime_error
win_runtime_error(error_type num, const std::string &msg)
Constructs an exception.
Definition: Common.h:1056
winstd::wstring_guid
Wide character implementation of a class to support converting GUID to string.
Definition: Common.h:1375
winstd::wstring_guid::wstring_guid
wstring_guid(const GUID &guid)
Initializes a new string and formats its contents to string representation of given GUID.
Definition: Common.h:1385
WINSTD_STACK_BUFFER_BYTES
#define WINSTD_STACK_BUFFER_BYTES
Size of the stack buffer in bytes used for initial system function call.
Definition: Common.h:80
winstd::get_ptr
ref_unique_ptr< _Ty[], _Dx > get_ptr(std::unique_ptr< _Ty[], _Dx > &owner) noexcept
Helper function template for returning pointers to std::unique_ptr (specialization for arrays)
Definition: Common.h:485
winstd::tstring
std::string tstring
Multi-byte / Wide-character string (according to _UNICODE)
Definition: Common.h:335
winstd::sanitizing_wstring
std::basic_string< wchar_t, std::char_traits< wchar_t >, sanitizing_allocator< wchar_t > > sanitizing_wstring
A sanitizing variant of std::wstring.
Definition: Common.h:1487
winstd::sanitizing_tstring
sanitizing_string sanitizing_tstring
Multi-byte / Wide-character sanitizing string (according to _UNICODE)
Definition: Common.h:1495
winstd::sanitizing_string
std::basic_string< char, std::char_traits< char >, sanitizing_allocator< char > > sanitizing_string
A sanitizing variant of std::string.
Definition: Common.h:1478
winstd::wstring_printf
basic_string_printf< wchar_t, std::char_traits< wchar_t >, std::allocator< wchar_t > > wstring_printf
Wide character implementation of a class to support string formatting using printf() style templates.
Definition: Common.h:1184
winstd::tstring_guid
string_guid tstring_guid
Multi-byte / Wide-character string GUID (according to _UNICODE)
Definition: Common.h:1399
winstd::wstring_msg
basic_string_msg< wchar_t, std::char_traits< wchar_t >, std::allocator< wchar_t > > wstring_msg
Wide character implementation of a class to support string formatting using FormatMessage() style tem...
Definition: Common.h:1309
winstd::string_printf
basic_string_printf< char, std::char_traits< char >, std::allocator< char > > string_printf
Single-byte character implementation of a class to support string formatting using printf() style tem...
Definition: Common.h:1179
winstd::tstring_printf
string_printf tstring_printf
Multi-byte / Wide-character formatted string (according to _UNICODE)
Definition: Common.h:1192
winstd::string_msg
basic_string_msg< char, std::char_traits< char >, std::allocator< char > > string_msg
Single-byte character implementation of a class to support string formatting using FormatMessage() st...
Definition: Common.h:1304
winstd::tstring_msg
string_msg tstring_msg
Multi-byte / Wide-character formatted string (according to _UNICODE)
Definition: Common.h:1317
winstd::handle::invalid
static const T invalid
Invalid handle value.
Definition: Common.h:614
winstd::LocalFree_delete< _Ty[]>::LocalFree_delete
LocalFree_delete() noexcept
Default construct.
Definition: Common.h:378
winstd::LocalFree_delete< _Ty[]>::_Myt
LocalFree_delete< _Ty > _Myt
This type.
Definition: Common.h:373
winstd::LocalFree_delete< _Ty[]>::operator()
void operator()(_Other *) const
Delete a pointer of another type.
Definition: Common.h:394
winstd::LocalFree_delete< _Ty[]>::operator()
void operator()(_Ty *_Ptr) const noexcept
Delete a pointer.
Definition: Common.h:383
winstd::LocalFree_delete
Deleter for unique_ptr using LocalFree.
Definition: Common.h:343
winstd::LocalFree_delete::_Myt
LocalFree_delete< _Ty > _Myt
This type.
Definition: Common.h:344
winstd::LocalFree_delete::LocalFree_delete
LocalFree_delete(const LocalFree_delete< _Ty2 > &)
Construct from another LocalFree_delete.
Definition: Common.h:354
winstd::LocalFree_delete::operator()
void operator()(_Ty *_Ptr) const
Delete a pointer.
Definition: Common.h:361
winstd::LocalFree_delete::LocalFree_delete
LocalFree_delete()
Default construct.
Definition: Common.h:349
winstd::sanitizing_allocator::rebind
Convert this type to sanitizing_allocator<_Other>
Definition: Common.h:1432
winstd::sanitizing_allocator::rebind::other
sanitizing_allocator< _Other > other
Other type.
Definition: Common.h:1433