Amebis/WinStd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Doxygen documentation updated & some minor issues stumbled upon fixed

Browse Source
This commit is contained in:
Simon Rozman
2016-11-02 00:16:33 +01:00
parent b2d27e993a
commit 85ad07ece5
18 changed files with 1373 additions and 1307 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
include/WinStd/Base64.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdBase64 Base64 conversion
/// Provides Base64 conversion for WinStd classes
///
#include "Common.h"
#include <string>
@@ -25,23 +30,8 @@
namespace winstd
{
///
/// \defgroup WinStdBase64 Base64 conversion
/// Provides Base64 conversion for WinStd classes
///
/// @{
///
/// Base64 encoding session
///
class WINSTD_API base64_enc;
///
/// Base64 decoding session
///
class WINSTD_API base64_dec;
/// @}
}
#pragma once
@@ -49,6 +39,12 @@ namespace winstd
namespace winstd
{
/// \addtogroup WinStdBase64
/// @{
///
/// Base64 encoding session
///
class WINSTD_API base64_enc
{
public:
@@ -167,10 +163,16 @@ namespace winstd
protected:
unsigned char buf[3]; ///< Internal buffer
size_t num; ///< Number of bytes used in `buf`
static const char lookup[64]; ///< Look-up table
/// \cond internal
static const char lookup[64];
/// \endcond
};
///
/// Base64 decoding session
///
class WINSTD_API base64_dec
{
public:
@@ -268,6 +270,11 @@ namespace winstd
protected:
unsigned char buf[4]; ///< Internal buffer
size_t num; ///< Number of bytes used in `buf`
static const unsigned char lookup[256]; ///< Look-up table
/// \cond internal
static const unsigned char lookup[256];
/// \endcond
};
/// @}
}

108
include/WinStd/COM.h
View File

@@ -18,51 +18,22 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdCOM COM object management
/// Provides helper templates for Windows COM object manipulation
///
#include "Common.h"
#include <string>
namespace winstd
{
///
/// \defgroup WinStdCOM COM object management
/// Provides helper templates for Windows COM object manipulation
///
/// @{
///
/// COM object wrapper template
///
template <class T> class com_obj;
///
/// BSTR string wrapper
///
class WINSTD_API bstr;
///
/// VARIANT struct wrapper
///
class WINSTD_API variant;
/// @}
class WINSTD_API com_initializer;
///
/// \defgroup WinStdExceptions Exceptions
/// Additional exceptions
///
/// @{
///
/// COM runtime error
///
/// \note Must be defined as derived class from num_runtime_error<> to allow correct type info for dynamic typecasting and prevent folding with other derivates of num_runtime_error<>.
///
class WINSTD_API com_runtime_error;
/// @}
}
#pragma once
@@ -70,6 +41,12 @@ namespace winstd
namespace winstd
{
/// \addtogroup WinStdCOM
/// @{
///
/// COM object wrapper template
///
template <class T>
class com_obj : public dplhandle<T*>
{
@@ -144,7 +121,9 @@ namespace winstd
protected:
///
/// Releases the object.
/// Releases the object by decrementing reference counter
///
/// \sa [IUnknown::Release method](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682317.aspx)
///
virtual void free_internal()
{
@@ -153,7 +132,9 @@ namespace winstd
///
/// Duplicates the object.
/// Duplicates the object by incrementing the reference counter
///
/// \sa [IUnknown::AddRef method](https://msdn.microsoft.com/en-us/library/windows/desktop/ms691379.aspx)
///
/// \param[in] h Object handle of existing object
///
@@ -167,6 +148,9 @@ namespace winstd
};
///
/// BSTR string wrapper
///
class WINSTD_API bstr : public dplhandle<BSTR>
{
DPLHANDLE_IMPL(bstr)
@@ -235,6 +219,9 @@ namespace winstd
};
///
/// VARIANT struct wrapper
///
class WINSTD_API variant : public VARIANT
{
public:
@@ -924,6 +911,32 @@ namespace winstd
return compare(static_cast<const VARIANT&>(*this), varSrc, LOCALE_USER_DEFAULT, 0)== static_cast<HRESULT>(VARCMP_GT);
}
///
/// Is variant less than or equal to?
///
/// \param[in] varSrc Variant to compare against
/// \return
/// - Non zero when variant is less than or equal to \p varSrc;
/// - Zero otherwise.
///
inline bool operator<=(_In_ const VARIANT& varSrc) const
{
return !operator>(varSrc);
}
///
/// Is variant greater than or equal to?
///
/// \param[in] varSrc Variant to compare against
/// \return
/// - Non zero when variant is greater than or equal to \p varSrc;
/// - Zero otherwise.
///
inline bool operator>=(_In_ const VARIANT& varSrc) const
{
return !operator<(varSrc);
}
///
/// Converts a variant from one type to another.
///
@@ -935,6 +948,7 @@ namespace winstd
}
private:
/// \cond internal
inline HRESULT compare(_In_ const VARIANT &varLeft, _In_ const VARIANT &varRight, _In_ LCID lcid, _In_ ULONG dwFlags) const
{
switch(vt) {
@@ -945,9 +959,13 @@ namespace winstd
default: return VarCmp(const_cast<LPVARIANT>(&varLeft), const_cast<LPVARIANT>(&varRight), lcid, dwFlags);
}
}
/// \endcond
};
///
/// Context scope automatic COM (un)initialization
///
class WINSTD_API com_initializer
{
public:
@@ -995,15 +1013,27 @@ namespace winstd
HRESULT m_result; ///< Result of CoInitialize call
};
/// @}
///
/// \defgroup WinStdExceptions Exceptions
/// Additional exceptions
///
/// @{
///
/// COM runtime error
///
/// \note Must be defined as derived class from num_runtime_error<> to allow correct type info for dynamic typecasting and prevent folding with other derivates of num_runtime_error<>.
///
class WINSTD_API com_runtime_error : public num_runtime_error<HRESULT>
{
public:
///
/// Constructs an exception
///
/// \param[in] error COM error code
/// \param[in] msg Error message
/// \param[in] num COM error code
/// \param[in] msg Error message
///
inline com_runtime_error(_In_ error_type num, _In_ const std::string& msg) : num_runtime_error<HRESULT>(num, msg.c_str())
{
@@ -1030,4 +1060,6 @@ namespace winstd
{
}
};
/// @}
}

660
include/WinStd/Common.h
View File

@@ -18,6 +18,41 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdGeneral General
/// General API
///
/// \defgroup WinStdSysHandles System Handles
/// Simplifies work with object handles of various type
///
/// \defgroup WinStdExceptions Exceptions
/// Additional exceptions
///
/// \defgroup WinStdStrFormat String Formatting
/// Formatted string generation
///
/// \par Example
/// \code
/// // Please note the PCSTR typecasting invokes an operator to return
/// // pointer to formatted buffer rather than class reference itself.
/// cout << (PCSTR)(winstd::string_printf("%i is less than %i.\n", 1, 5));
/// \endcode
///
/// \defgroup WinStdMemSanitize Auto-sanitize Memory Management
/// Sanitizes memory before dismissed
///
#include <Windows.h>
#include <stdarg.h>
#include <memory>
#include <stdexcept>
#include <string>
/// \addtogroup WinStdGeneral
/// @{
///
/// Public function calling convention
///
@@ -31,19 +66,45 @@
#endif
#endif
///
/// Class/struct with no virtual table declaration
///
/// Use for storing flat data.
///
/// This macro bypasses Doxygen limitation to parse class/struct declarations with parentheses.
///
#define WINSTD_NOVTABLE __declspec(novtable)
///
/// "L" stringizing macro
///
#ifndef __L
#define __L(x) L ## x
#endif
///
/// Makes string Unicode
///
#ifndef _L
#define _L(x) __L(x)
#endif
// Macros for building default constructors and operators to prevent their auto-generation by compiler.
///
/// Declares a class as non-copyable
///
#define WINSTD_NONCOPYABLE(C) \
private: \
inline C (_In_ const C &h); \
inline C& operator=(_In_ const C &h);
/// @}
/// \addtogroup WinStdSysHandles
/// @{
///
/// Implements default constructors and operators to prevent their auto-generation by compiler.
///
#define HANDLE_IMPL(C) \
public: \
inline C ( ) { } \
@@ -53,6 +114,9 @@ public: \
inline C& operator=(_Inout_ C &&h) { handle<handle_type>::operator=(std::move(h)); return *this; } \
WINSTD_NONCOPYABLE(C)
///
/// Implements default constructors and operators to prevent their auto-generation by compiler.
///
#define DPLHANDLE_IMPL(C) \
public: \
inline C ( ) { } \
@@ -64,15 +128,153 @@ public: \
inline C& operator=(_Inout_ C &&h) { dplhandle<handle_type>::operator=(std::move(h)); return *this; } \
private:
#include <Windows.h>
/// @}
#include <stdarg.h>
namespace winstd
{
/// \addtogroup WinStdStrFormat
/// @{
#include <memory>
#include <stdexcept>
#include <string>
///
/// Multi-byte / Wide-character string (according to _UNICODE)
///
#ifdef _UNICODE
typedef std::wstring tstring;
#else
typedef std::string tstring;
#endif
/// @}
template <class _Ty> struct LocalFree_delete;
template <class _Ty> struct LocalFree_delete<_Ty[]>;
template <class T> class handle;
template <class T> class dplhandle;
template <class T> class vector_queue;
template <typename _Tn> class num_runtime_error;
class WINSTD_API win_runtime_error;
/// \addtogroup WinStdStrFormat
/// @{
template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem> > class basic_string_printf;
///
/// Single-byte character implementation of a class to support string formatting using `printf()` style templates
///
typedef basic_string_printf<char, std::char_traits<char>, std::allocator<char> > string_printf;
///
/// Wide character implementation of a class to support string formatting using `printf()` style templates
///
typedef basic_string_printf<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > wstring_printf;
///
/// Multi-byte / Wide-character formatted string (according to _UNICODE)
///
#ifdef _UNICODE
typedef wstring_printf tstring_printf;
#else
typedef string_printf tstring_printf;
#endif
template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem> > class basic_string_msg;
///
/// Single-byte character implementation of a class to support string formatting using `FormatMessage()` style templates
///
typedef basic_string_msg<char, std::char_traits<char>, std::allocator<char> > string_msg;
///
/// Wide character implementation of a class to support string formatting using `FormatMessage()` style templates
///
typedef basic_string_msg<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > wstring_msg;
///
/// Multi-byte / Wide-character formatted string (according to _UNICODE)
///
#ifdef _UNICODE
typedef wstring_msg tstring_msg;
#else
typedef string_msg tstring_msg;
#endif
template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem> > class basic_string_guid;
class WINSTD_API string_guid;
class WINSTD_API wstring_guid;
///
/// Multi-byte / Wide-character string GUID (according to _UNICODE)
///
#ifdef _UNICODE
typedef wstring_guid tstring_guid;
#else
typedef string_guid tstring_guid;
#endif
/// @}
/// \addtogroup WinStdMemSanitize
/// @{
template<class _Ty> class sanitizing_allocator;
///
/// A sanitizing variant of std::string
///
/// \note
/// `sanitizing_string` introduces a performance penalty. However, it provides an additional level of security.
/// Use for security sensitive data memory storage only.
///
typedef std::basic_string<char, std::char_traits<char>, sanitizing_allocator<char> > sanitizing_string;
///
/// A sanitizing variant of std::wstring
///
/// \note
/// `sanitizing_wstring` introduces a performance penalty. However, it provides an additional level of security.
/// Use for security sensitive data memory storage only.
///
typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, sanitizing_allocator<wchar_t> > sanitizing_wstring;
///
/// Multi-byte / Wide-character sanitizing string (according to _UNICODE)
///
#ifdef _UNICODE
typedef sanitizing_wstring sanitizing_tstring;
#else
typedef sanitizing_string sanitizing_tstring;
#endif
/// @}
}
/// \addtogroup WinStdStrFormat
/// @{
///
/// Formats string using `printf()`.
///
/// \param[out] str Buffer to receive string
/// \param[in ] capacity Size of `str` in characters
/// \param[in ] format String template using `printf()` style
/// \param[in ] arg Arguments to `format`
///
/// \returns Number of characters in result.
///
inline int vsnprintf(_Out_z_cap_(capacity) char *str, _In_ size_t capacity, _In_z_ _Printf_format_string_ const char *format, _In_ va_list arg);
///
/// Formats string using `printf()`.
///
/// \param[out] str Buffer to receive string
/// \param[in ] capacity Size of `str` in characters
/// \param[in ] format String template using `printf()` style
/// \param[in ] arg Arguments to `format`
///
/// \returns Number of characters in result.
///
inline 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);
///
@@ -110,198 +312,7 @@ template<class _Traits, class _Ax> inline DWORD FormatMessage(_In_ DWORD dwFlags
///
template<class _Traits, class _Ax> inline DWORD FormatMessage(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &str, _In_opt_ va_list *Arguments);
namespace winstd
{
///
/// Multi-byte / Wide-character string (according to _UNICODE)
///
#ifdef _UNICODE
typedef std::wstring tstring;
#else
typedef std::string tstring;
#endif
///
/// Deleter for unique_ptr using LocalFree
///
template <class _Ty> struct LocalFree_delete;
///
/// Deleter for unique_ptr to array of unknown size using LocalFree
///
template <class _Ty> struct LocalFree_delete<_Ty[]>;
///
/// \defgroup WinStdSysHandles System Handles
/// Simplifies work with object handles of various type
///
/// @{
///
/// Base abstract template class to support generic object handle keeping
///
/// It provides basic operators and methods common to all descendands of this class establishing a base to ease the replacement of native object handle type with classes in object-oriented approach.
///
template <class T> class handle;
///
/// Base abstract template class to support object handle keeping for objects that support handle duplication
///
template <class T> class dplhandle;
///
/// Helper class to allow limited size FIFO queues implemented as vector of elements
///
template <class T> class vector_queue;
///
/// \defgroup WinStdExceptions Exceptions
/// Additional exceptions
///
/// @{
///
/// Numerical runtime error
///
template <typename _Tn> class num_runtime_error;
///
/// Windows runtime error
///
class WINSTD_API win_runtime_error;
/// @}
///
/// \defgroup WinStdStrFormat String Formatting
/// Formatted string generation
///
/// \par Example
/// \code
/// // Please note the PCSTR typecasting invokes an operator to return
/// // pointer to formatted buffer rather than class reference itself.
/// cout << (PCSTR)(winstd::string_printf("%i is less than %i.\n", 1, 5));
/// \endcode
///
/// @{
///
/// Base template class to support string formatting using `printf()` style templates
///
template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem> > class basic_string_printf;
///
/// Single-byte character implementation of a class to support string formatting using `printf()` style templates
///
typedef basic_string_printf<char, std::char_traits<char>, std::allocator<char> > string_printf;
///
/// Wide character implementation of a class to support string formatting using `printf()` style templates
///
typedef basic_string_printf<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > wstring_printf;
///
/// Multi-byte / Wide-character formatted string (according to _UNICODE)
///
#ifdef _UNICODE
typedef wstring_printf tstring_printf;
#else
typedef string_printf tstring_printf;
#endif
///
/// Base template class to support string formatting using `FormatMessage()` style templates
///
template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem> > class basic_string_msg;
///
/// Single-byte character implementation of a class to support string formatting using `FormatMessage()` style templates
///
typedef basic_string_msg<char, std::char_traits<char>, std::allocator<char> > string_msg;
///
/// Wide character implementation of a class to support string formatting using `FormatMessage()` style templates
///
typedef basic_string_msg<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > wstring_msg;
///
/// Multi-byte / Wide-character formatted string (according to _UNICODE)
///
#ifdef _UNICODE
typedef wstring_msg tstring_msg;
#else
typedef string_msg tstring_msg;
#endif
///
/// Base template class to support converting GUID to string
///
template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem> > class basic_string_guid;
///
/// Single-byte character implementation of a class to support converting GUID to string
///
class WINSTD_API string_guid;
///
/// Wide character implementation of a class to support converting GUID to string
///
class WINSTD_API wstring_guid;
///
/// Multi-byte / Wide-character string GUID (according to _UNICODE)
///
#ifdef _UNICODE
typedef wstring_guid tstring_guid;
#else
typedef string_guid tstring_guid;
#endif
/// @}
/// \defgroup WinStdMemSanitize Auto-sanitize Memory Management
/// Sanitizes memory before dismissed
///
/// @{
///
/// An allocator template that sanitizes each memory block before it is destroyed or reallocated
///
/// \note
/// `sanitizing_allocator` introduces a performance penalty. However, it provides an additional level of security.
/// Use for security sensitive data memory storage only.
///
template<class _Ty> class sanitizing_allocator;
///
/// A sanitizing variant of std::string
///
/// \note
/// `sanitizing_string` introduces a performance penalty. However, it provides an additional level of security.
/// Use for security sensitive data memory storage only.
///
typedef std::basic_string<char, std::char_traits<char>, sanitizing_allocator<char> > sanitizing_string;
///
/// A sanitizing variant of std::wstring
///
/// \note
/// `sanitizing_wstring` introduces a performance penalty. However, it provides an additional level of security.
/// Use for security sensitive data memory storage only.
///
typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, sanitizing_allocator<wchar_t> > sanitizing_wstring;
///
/// Multi-byte / Wide-character sanitizing string (according to _UNICODE)
///
#ifdef _UNICODE
typedef sanitizing_wstring sanitizing_tstring;
#else
typedef sanitizing_string sanitizing_tstring;
#endif
/// @}
}
/// @}
#pragma once
@@ -311,6 +322,9 @@ namespace winstd
#include <vector>
/// \addtogroup WinStdGeneral
/// @{
#ifndef WINSTD_STACK_BUFFER_BYTES
///
/// Size of the stack buffer in bytes used for initial system function call
@@ -328,89 +342,19 @@ namespace winstd
#define WINSTD_STACK_BUFFER_BYTES 1024
#endif
// 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(push)
#pragma warning(disable: 4995)
#pragma warning(disable: 4996)
inline 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);
}
inline 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)
{
return _vsnwprintf(str, capacity, format, arg);
}
template<class _Elem, class _Traits, class _Ax>
inline int vsprintf(_Out_ 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.
std::unique_ptr<_Elem[]> buf(new _Elem[capacity]);
count = vsnprintf(buf.get(), capacity - 1, format, arg);
if (count >= 0) {
str.assign(buf.get(), count);
break;
}
}
}
return count;
}
#pragma warning(pop)
template<class _Elem, class _Traits, class _Ax>
inline int sprintf(_Out_ std::basic_string<_Elem, _Traits, _Ax> &str, _In_z_ _Printf_format_string_ const _Elem *format, ...)
{
va_list arg;
va_start(arg, format);
int res = vsprintf(str, format, arg);
va_end(arg);
return res;
}
template<class _Traits, class _Ax>
inline DWORD FormatMessage(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _Out_ 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>(&lpBuffer._Myptr), 0, Arguments);
if (dwResult)
str.assign(lpBuffer.get(), dwResult);
return dwResult;
}
template<class _Traits, class _Ax>
inline DWORD FormatMessage(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _Out_ 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>(&lpBuffer._Myptr), 0, Arguments);
if (dwResult)
str.assign(lpBuffer.get(), dwResult);
return dwResult;
}
/// @}
namespace winstd
{
template <class _Ty> struct LocalFree_delete
/// \addtogroup WinStdGeneral
/// @{
///
/// Deleter for unique_ptr using LocalFree
///
template <class _Ty>
struct LocalFree_delete
{
typedef LocalFree_delete<_Ty> _Myt; ///< This type
@@ -427,6 +371,8 @@ namespace winstd
///
/// Delete a pointer
///
/// \sa [LocalFree function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa366730.aspx)
///
void operator()(_Ty *_Ptr) const
{
LocalFree(_Ptr);
@@ -434,7 +380,11 @@ namespace winstd
};
template <class _Ty> struct LocalFree_delete<_Ty[]>
///
/// Deleter for unique_ptr to array of unknown size using LocalFree
///
template <class _Ty>
struct LocalFree_delete<_Ty[]>
{
typedef LocalFree_delete<_Ty> _Myt; ///< This type
@@ -454,6 +404,8 @@ namespace winstd
///
/// Delete a pointer of another type
///
/// \sa [LocalFree function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa366730.aspx)
///
template<class _Other>
void operator()(_Other *) const
{
@@ -461,7 +413,17 @@ namespace winstd
}
};
/// @}
/// \addtogroup WinStdSysHandles
/// @{
///
/// Base abstract template class to support generic object handle keeping
///
/// It provides basic operators and methods common to all descendands of this class establishing a base to ease the replacement of native object handle type with classes in object-oriented approach.
///
template <class T>
class handle
{
@@ -715,6 +677,9 @@ namespace winstd
};
///
/// Base abstract template class to support object handle keeping for objects that support handle duplication
///
template <class T>
class dplhandle : public handle<T>
{
@@ -842,7 +807,12 @@ namespace winstd
/// @}
/// \addtogroup WinStdGeneral
/// @{
///
/// Helper class to allow limited size FIFO queues implemented as vector of elements
///
template <class T>
class vector_queue
{
@@ -1244,19 +1214,26 @@ namespace winstd
size_type m_size_max; ///< Maximum size
};
/// @}
/// \addtogroup WinStdExceptions
/// @{
///
/// Numerical runtime error
///
template <typename _Tn>
class num_runtime_error : public std::runtime_error
{
public:
typedef _Tn error_type;
typedef _Tn error_type; ///< Error number type
public:
///
/// Constructs an exception
///
/// \param[in] error Numeric error code
/// \param[in] msg Error message
/// \param[in] num Numeric error code
/// \param[in] msg Error message
///
inline num_runtime_error(_In_ error_type num, _In_ const std::string& msg) :
m_num(num),
@@ -1319,14 +1296,17 @@ namespace winstd
};
///
/// Windows runtime error
///
class WINSTD_API win_runtime_error : public num_runtime_error<DWORD>
{
public:
///
/// Constructs an exception
///
/// \param[in] error Windows error code
/// \param[in] msg Error message
/// \param[in] num Windows error code
/// \param[in] msg Error message
///
inline win_runtime_error(_In_ error_type num, _In_ const std::string& msg) : num_runtime_error<DWORD>(num, msg.c_str())
{
@@ -1374,7 +1354,14 @@ namespace winstd
}
};
/// @}
/// \addtogroup WinStdStrFormat
/// @{
///
/// Base template class to support string formatting using `printf()` style templates
///
template<class _Elem, class _Traits, class _Ax>
class basic_string_printf : public std::basic_string<_Elem, _Traits, _Ax>
{
@@ -1439,6 +1426,9 @@ namespace winstd
};
///
/// Base template class to support string formatting using `FormatMessage()` style templates
///
template<class _Elem, class _Traits, class _Ax>
class basic_string_msg : public std::basic_string<_Elem, _Traits, _Ax>
{
@@ -1547,6 +1537,9 @@ namespace winstd
};
///
/// Base template class to support converting GUID to string
///
template<class _Elem, class _Traits, class _Ax>
class basic_string_guid : public std::basic_string<_Elem, _Traits, _Ax>
{
@@ -1557,7 +1550,8 @@ namespace winstd
///
/// Initializes a new string and formats its contents to string representation of given GUID.
///
/// \param[in] guid GUID to convert
/// \param[in] guid GUID to convert
/// \param[in] format A `printf()` syntax template to convert GUID to string (i.e. `"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}"`)
///
inline basic_string_guid(_In_ const GUID &guid, _In_opt_z_ _Printf_format_string_ const _Elem *format)
{
@@ -1573,6 +1567,9 @@ namespace winstd
};
///
/// Single-byte character implementation of a class to support converting GUID to string
///
class WINSTD_API string_guid : public basic_string_guid<char, std::char_traits<char>, std::allocator<char> >
{
public:
@@ -1593,6 +1590,9 @@ namespace winstd
};
///
/// Wide character implementation of a class to support converting GUID to string
///
class WINSTD_API wstring_guid : public basic_string_guid<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >
{
public:
@@ -1612,11 +1612,22 @@ namespace winstd
/// @}
};
/// @}
/// \addtogroup WinStdMemSanitize
/// @{
// winstd::sanitizing_allocator::destroy() member generates _Ptr parameter not used warning for primitive datatypes _Ty.
#pragma warning(push)
#pragma warning(disable: 4100)
///
/// An allocator template that sanitizes each memory block before it is destroyed or reallocated
///
/// \note
/// `sanitizing_allocator` introduces a performance penalty. However, it provides an additional level of security.
/// Use for security sensitive data memory storage only.
///
template<class _Ty>
class sanitizing_allocator : public std::allocator<_Ty>
{
@@ -1670,4 +1681,85 @@ namespace winstd
};
#pragma warning(pop)
/// @}
}
// 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(push)
#pragma warning(disable: 4995)
#pragma warning(disable: 4996)
inline 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);
}
inline 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)
{
return _vsnwprintf(str, capacity, format, arg);
}
template<class _Elem, class _Traits, class _Ax>
inline int vsprintf(_Out_ 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.
std::unique_ptr<_Elem[]> buf(new _Elem[capacity]);
count = vsnprintf(buf.get(), capacity - 1, format, arg);
if (count >= 0) {
str.assign(buf.get(), count);
break;
}
}
}
return count;
}
#pragma warning(pop)
template<class _Elem, class _Traits, class _Ax>
inline int sprintf(_Out_ std::basic_string<_Elem, _Traits, _Ax> &str, _In_z_ _Printf_format_string_ const _Elem *format, ...)
{
va_list arg;
va_start(arg, format);
int res = vsprintf(str, format, arg);
va_end(arg);
return res;
}
template<class _Traits, class _Ax>
inline DWORD FormatMessage(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _Out_ 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>(&lpBuffer._Myptr), 0, Arguments);
if (dwResult)
str.assign(lpBuffer.get(), dwResult);
return dwResult;
}
template<class _Traits, class _Ax>
inline DWORD FormatMessage(_In_ DWORD dwFlags, _In_opt_ LPCVOID lpSource, _In_ DWORD dwMessageId, _In_ DWORD dwLanguageId, _Out_ 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>(&lpBuffer._Myptr), 0, Arguments);
if (dwResult)
str.assign(lpBuffer.get(), dwResult);
return dwResult;
}

49
include/WinStd/Cred.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdCryptoAPI Cryptography API
/// Integrates WinStd classes with Microsoft Cryptography API
///
#include "Common.h"
#include <wincred.h>
@@ -26,23 +31,8 @@
namespace winstd
{
///
/// \defgroup WinStdCryptoAPI Cryptography API
/// Integrates WinStd classes with Microsoft Cryptography API
///
/// @{
///
/// Deleter for unique_ptr using CredFree
///
template <class _Ty> struct CredFree_delete;
///
/// Deleter for unique_ptr to array of unknown size using CredFree
///
template <class _Ty> struct CredFree_delete<_Ty[]>;
/// @}
}
@@ -56,11 +46,7 @@ namespace winstd
///
inline BOOL CredEnumerate(_In_ LPCTSTR Filter, _In_ DWORD Flags, _Out_ DWORD *Count, _Out_ std::unique_ptr<PCREDENTIAL[], winstd::CredFree_delete<PCREDENTIAL[]> > &cCredentials);
///
/// Encrypts the specified credentials so that only the current security context can decrypt them.
///
/// \sa [CredProtect function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa374803.aspx)
///
/// @copydoc CredProtectW()
template<class _Elem, class _Traits, class _Ax> inline BOOL CredProtectA(_In_ BOOL fAsSelf, _In_ LPCSTR pszCredentials, _In_ DWORD cchCredentials, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sProtectedCredentials, _Out_ CRED_PROTECTION_TYPE *ProtectionType);
///
@@ -70,11 +56,7 @@ template<class _Elem, class _Traits, class _Ax> inline BOOL CredProtectA(_In_ BO
///
template<class _Elem, class _Traits, class _Ax> inline BOOL CredProtectW(_In_ BOOL fAsSelf, _In_ LPCWSTR pszCredentials, _In_ DWORD cchCredentials, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sProtectedCredentials, _Out_ CRED_PROTECTION_TYPE *ProtectionType);
///
/// Decrypts credentials that were previously encrypted by using the CredProtect function.
///
/// \sa [CredUnprotect function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa375186.aspx)
///
/// @copydoc CredUnprotectW()
template<class _Elem, class _Traits, class _Ax> inline BOOL CredUnprotectA(_In_ BOOL fAsSelf, _In_ LPCSTR pszProtectedCredentials, _In_ DWORD cchCredentials, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sCredentials);
///
@@ -91,6 +73,12 @@ template<class _Elem, class _Traits, class _Ax> inline BOOL CredUnprotectW(_In_
namespace winstd
{
/// \addtogroup WinStdCryptoAPI
/// @{
///
/// Deleter for unique_ptr using CredFree
///
template <class _Ty> struct CredFree_delete
{
typedef CredFree_delete<_Ty> _Myt; ///< This type
@@ -108,6 +96,8 @@ namespace winstd
///
/// Delete a pointer
///
/// \sa [CredFree function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa374796.aspx)
///
void operator()(_Ty *_Ptr) const
{
CredFree(_Ptr);
@@ -115,6 +105,9 @@ namespace winstd
};
///
/// Deleter for unique_ptr to array of unknown size using CredFree
///
template <class _Ty> struct CredFree_delete<_Ty[]>
{
typedef CredFree_delete<_Ty> _Myt; ///< This type
@@ -127,6 +120,8 @@ namespace winstd
///
/// Delete a pointer
///
/// \sa [CredFree function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa374796.aspx)
///
void operator()(_Ty *_Ptr) const
{
CredFree(_Ptr);
@@ -135,12 +130,16 @@ namespace winstd
///
/// Delete a pointer of another type
///
/// \sa [CredFree function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa374796.aspx)
///
template<class _Other>
void operator()(_Other *) const
{
CredFree(_Ptr);
}
};
/// @}
}

1150
include/WinStd/Crypt.h
View File

File diff suppressed because it is too large Load Diff

151
include/WinStd/EAP.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdEAPAPI Extensible Authentication Protocol API
/// Integrates WinStd classes with Microsoft EAP API
///
#include "Common.h"
#include <Windows.h>
@@ -28,93 +33,39 @@
namespace winstd
{
///
/// \defgroup WinStdEAPAPI Extensible Authentication Protocol API
/// Integrates WinStd classes with Microsoft EAP API
///
/// @{
///
/// EAP method numbers
///
/// \sa [Extensible Authentication Protocol (EAP) Registry (Chapter: Method Types)](https://www.iana.org/assignments/eap-numbers/eap-numbers.xhtml#eap-numbers-4)
///
enum eap_type_t;
///
/// Deleter for unique_ptr using EapHostPeerFreeMemory
///
struct WINSTD_API EapHostPeerFreeMemory_delete;
struct WINSTD_API EapHostPeerFreeRuntimeMemory_delete;
struct WINSTD_API EapHostPeerFreeErrorMemory_delete;
struct WINSTD_API EapHostPeerFreeEapError_delete;
class WINSTD_API WINSTD_NOVTABLE eap_attr;
class WINSTD_API WINSTD_NOVTABLE eap_method_prop;
class WINSTD_API eap_packet;
class WINSTD_API WINSTD_NOVTABLE eap_method_info_array;
class WINSTD_API eap_runtime_error;
/// \addtogroup WinStdEAPAPI
/// @{
///
/// EapHost BLOB wrapper class
///
typedef std::unique_ptr<BYTE[], EapHostPeerFreeMemory_delete> WINSTD_API eap_blob;
///
/// Deleter for unique_ptr using EapHostPeerFreeRuntimeMemory
///
struct WINSTD_API EapHostPeerFreeRuntimeMemory_delete;
///
/// EapHost BLOB wrapper class
///
typedef std::unique_ptr<BYTE[], EapHostPeerFreeRuntimeMemory_delete> WINSTD_API eap_blob_runtime;
///
/// Deleter for unique_ptr to EAP_ERROR using EapHostPeerFreeErrorMemory
///
struct WINSTD_API EapHostPeerFreeErrorMemory_delete;
///
/// EAP_ERROR wrapper class
///
typedef std::unique_ptr<EAP_ERROR, EapHostPeerFreeErrorMemory_delete> WINSTD_API eap_error;
///
/// Deleter for unique_ptr to EAP_ERROR using EapHostPeerFreeEapError
///
struct WINSTD_API EapHostPeerFreeEapError_delete;
///
/// EAP_ERROR wrapper class
///
typedef std::unique_ptr<EAP_ERROR, EapHostPeerFreeEapError_delete> WINSTD_API eap_error_runtime;
///
/// EAP_ATTRIBUTE wrapper class
///
class WINSTD_API eap_attr;
///
/// EAP_METHOD_PROPERTY wrapper class
///
class WINSTD_API eap_method_prop;
///
/// EapPacket wrapper class
///
class WINSTD_API eap_packet;
///
/// EAP_METHOD_INFO_ARRAY wrapper class
///
class WINSTD_API eap_method_info_array;
/// @}
///
/// \defgroup WinStdExceptions Exceptions
/// Additional exceptions
///
/// @{
///
/// EapHost runtime error
///
/// \sa [EAP_ERROR structure](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363699.aspx)
///
class WINSTD_API eap_runtime_error;
typedef std::unique_ptr<EAP_ERROR, EapHostPeerFreeEapError_delete> WINSTD_API eap_error_runtime;
/// @}
}
@@ -158,6 +109,14 @@ inline bool operator!=(_In_ const EAP_METHOD_TYPE &a, _In_ const EAP_METHOD_TYPE
namespace winstd
{
/// \addtogroup WinStdEAPAPI
/// @{
///
/// EAP method numbers
///
/// \sa [Extensible Authentication Protocol (EAP) Registry (Chapter: Method Types)](https://www.iana.org/assignments/eap-numbers/eap-numbers.xhtml#eap-numbers-4)
///
#pragma warning(suppress: 4480)
enum eap_type_t : unsigned char {
eap_type_undefined = 0, ///< Undefined EAP type
@@ -182,6 +141,9 @@ namespace winstd
};
///
/// Deleter for unique_ptr using EapHostPeerFreeMemory
///
struct WINSTD_API EapHostPeerFreeMemory_delete
{
///
@@ -192,6 +154,8 @@ namespace winstd
///
/// Delete a pointer
///
/// \sa [EapHostPeerFreeMemory function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363558.aspx)
///
template <class _T>
void operator()(_T *_Ptr) const
{
@@ -200,6 +164,9 @@ namespace winstd
};
///
/// Deleter for unique_ptr using EapHostPeerFreeRuntimeMemory
///
struct WINSTD_API EapHostPeerFreeRuntimeMemory_delete
{
///
@@ -218,6 +185,9 @@ namespace winstd
};
///
/// Deleter for unique_ptr to EAP_ERROR using EapHostPeerFreeErrorMemory
///
struct WINSTD_API EapHostPeerFreeErrorMemory_delete
{
///
@@ -228,6 +198,8 @@ namespace winstd
///
/// Delete a pointer
///
/// \sa [EapHostPeerFreeErrorMemory function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363557.aspx)
///
void operator()(EAP_ERROR *_Ptr) const
{
EapHostPeerFreeErrorMemory(_Ptr);
@@ -235,24 +207,32 @@ namespace winstd
};
struct WINSTD_API EapHostPeerFreeEapError_delete
///
/// Deleter for unique_ptr to EAP_ERROR using EapHostPeerFreeEapError
///
struct WINSTD_API EapHostPeerFreeEapError_delete
{
///
/// Default constructor
///
EapHostPeerFreeEapError_delete() {}
EapHostPeerFreeEapError_delete() {}
///
/// Delete a pointer
///
/// \sa [EapHostPeerFreeEapError function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363556.aspx)
///
void operator()(EAP_ERROR *_Ptr) const
{
EapHostPeerFreeEapError(_Ptr);
EapHostPeerFreeEapError(_Ptr);
}
};
class WINSTD_API __declspec(novtable) eap_attr : public EAP_ATTRIBUTE
///
/// EAP_ATTRIBUTE wrapper class
///
class WINSTD_API WINSTD_NOVTABLE eap_attr : public EAP_ATTRIBUTE
{
public:
///
@@ -353,11 +333,14 @@ namespace winstd
void create_ms_mppe_key(_In_ BYTE bVendorType, _In_count_(nKeySize) LPCBYTE pbKey, _In_ BYTE nKeySize);
public:
static const EAP_ATTRIBUTE blank;
static const EAP_ATTRIBUTE blank; ///< Blank EAP attribute
};
class WINSTD_API __declspec(novtable) eap_method_prop : public EAP_METHOD_PROPERTY
///
/// EAP_METHOD_PROPERTY wrapper class
///
class WINSTD_API WINSTD_NOVTABLE eap_method_prop : public EAP_METHOD_PROPERTY
{
public:
///
@@ -406,6 +389,9 @@ namespace winstd
};
///
/// EapPacket wrapper class
///
class WINSTD_API eap_packet : public dplhandle<EapPacket*>
{
DPLHANDLE_IMPL(eap_packet)
@@ -471,7 +457,10 @@ namespace winstd
};
class WINSTD_API __declspec(novtable) eap_method_info_array : public EAP_METHOD_INFO_ARRAY
///
/// EAP_METHOD_INFO_ARRAY wrapper class
///
class WINSTD_API WINSTD_NOVTABLE eap_method_info_array : public EAP_METHOD_INFO_ARRAY
{
WINSTD_NONCOPYABLE(eap_method_info_array)
@@ -522,11 +511,25 @@ namespace winstd
}
protected:
/// \cond internal
void free_internal();
static void free_internal(_In_ EAP_METHOD_INFO *pMethodInfo);
/// \endcond
};
/// @}
///
/// \defgroup WinStdExceptions Exceptions
/// Additional exceptions
///
/// @{
///
/// EapHost runtime error
///
/// \sa [EAP_ERROR structure](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363699.aspx)
///
class WINSTD_API eap_runtime_error : public win_runtime_error
{
public:
@@ -643,6 +646,8 @@ namespace winstd
GUID m_help_link_id; ///< A unique ID that maps to a localizable string that specifies an URL for a page that contains additional information about an error or repair message
};
/// @}
}

93
include/WinStd/ETW.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdETWAPI Event Tracing for Windows API
/// Integrates WinStd classes with Event Tracing for Windows API
///
#include "Common.h"
#include <assert.h>
@@ -32,57 +37,14 @@
namespace winstd
{
///
/// \defgroup WinStdETWAPI Event Tracing for Windows API
/// Integrates WinStd classes with Event Tracing for Windows API
///
/// @{
///
/// EVENT_DATA_DESCRIPTOR wrapper
///
class WINSTD_API __declspec(novtable) event_data;
///
/// EVENT_RECORD wrapper
///
class WINSTD_API __declspec(novtable) event_rec;
///
/// ETW event provider
///
class WINSTD_API WINSTD_NOVTABLE event_data;
class WINSTD_API WINSTD_NOVTABLE event_rec;
class WINSTD_API event_provider;
///
/// ETW session
///
class WINSTD_API event_session;
///
/// ETW trace
///
class WINSTD_API event_trace;
///
/// Helper class to enable event provider in constructor and disables it in destructor
///
class WINSTD_API event_trace_enabler;
///
/// Helper class to write an event on entry/exit of scope.
///
/// It writes one string event at creation and another at destruction.
///
class event_fn_auto;
///
/// Helper template to write an event on entry/exit of scope with one parameter (typically result).
///
/// It writes one string event at creation and another at destruction, with allowing one sprintf type parameter for string event at destruction.
///
class WINSTD_API event_fn_auto;
template<class T> class event_fn_auto_ret;
/// @}
}
/// \addtogroup WinStdCryptoAPI
@@ -116,7 +78,13 @@ template<class _Ty, class _Ax> inline ULONG TdhGetProperty(_In_ PEVENT_RECORD pE
namespace winstd
{
class WINSTD_API __declspec(novtable) event_data : public EVENT_DATA_DESCRIPTOR
/// \addtogroup WinStdETWAPI
/// @{
///
/// EVENT_DATA_DESCRIPTOR wrapper
///
class WINSTD_API WINSTD_NOVTABLE event_data : public EVENT_DATA_DESCRIPTOR
{
public:
///
@@ -228,7 +196,10 @@ namespace winstd
};
class WINSTD_API __declspec(novtable) event_rec : public EVENT_RECORD
///
/// EVENT_RECORD wrapper
///
class WINSTD_API WINSTD_NOVTABLE event_rec : public EVENT_RECORD
{
public:
///
@@ -367,6 +338,9 @@ namespace winstd
};
///
/// ETW event provider
///
class WINSTD_API event_provider : public handle<REGHANDLE>
{
HANDLE_IMPL(event_provider)
@@ -549,6 +523,9 @@ namespace winstd
};
///
/// ETW session
///
class WINSTD_API event_session : public handle<TRACEHANDLE>
{
WINSTD_NONCOPYABLE(event_session)
@@ -733,6 +710,9 @@ namespace winstd
};
///
/// ETW trace
///
class WINSTD_API event_trace : public handle<TRACEHANDLE>
{
HANDLE_IMPL(event_trace)
@@ -775,6 +755,9 @@ namespace winstd
};
///
/// Helper class to enable event provider in constructor and disables it in destructor
///
class WINSTD_API event_trace_enabler
{
public:
@@ -880,7 +863,12 @@ namespace winstd
};
class event_fn_auto
///
/// Helper class to write an event on entry/exit of scope.
///
/// It writes one string event at creation and another at destruction.
///
class WINSTD_API event_fn_auto
{
public:
///
@@ -966,6 +954,11 @@ namespace winstd
};
///
/// Helper template to write an event on entry/exit of scope with one parameter (typically result).
///
/// It writes one string event at creation and another at destruction, with allowing one sprintf type parameter for string event at destruction.
///
template<class T>
class event_fn_auto_ret
{
@@ -1059,6 +1052,8 @@ namespace winstd
EVENT_DATA_DESCRIPTOR m_desc[2]; ///< Function name and return value
T &m_result; ///< Function result
};
/// @}
}

31
include/WinStd/Hex.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdHexadecimal Hexadecimal conversion
/// Provides Hexadecimal conversion for WinStd classes
///
#include "Common.h"
#include <string>
@@ -25,23 +30,8 @@
namespace winstd
{
///
/// \defgroup WinStdHexadecimal Hexadecimal conversion
/// Provides Hexadecimal conversion for WinStd classes
///
/// @{
///
/// Hexadecimal encoding session
///
class WINSTD_API hex_enc;
///
/// Hexadecimal decoding session
///
class WINSTD_API hex_dec;
/// @}
}
#pragma once
@@ -49,6 +39,12 @@ namespace winstd
namespace winstd
{
/// \addtogroup WinStdHexadecimal
/// @{
///
/// Hexadecimal encoding session
///
class WINSTD_API hex_enc
{
public:
@@ -102,6 +98,9 @@ namespace winstd
};
///
/// Hexadecimal decoding session
///
class WINSTD_API hex_dec
{
public:
@@ -186,4 +185,6 @@ namespace winstd
unsigned char buf; ///< Internal buffer
size_t num; ///< Number of nibbles used in `buf`
};
/// @}
}

40
include/WinStd/MSI.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdMSIAPI Microsoft Installer API
/// Integrates WinStd classes with Microsoft Installer API
///
#include "Common.h"
#include <MsiQuery.h>
@@ -25,17 +30,10 @@
#include <string>
#include <vector>
///
/// \defgroup WinStdMSIAPI Microsoft Installer API
/// Integrates WinStd classes with Microsoft Installer API
///
/// \addtogroup WinStdMSIAPI
/// @{
///
/// Gets the value for an installer property and stores it in a std::string string.
///
/// \sa [MsiGetProperty function](https://msdn.microsoft.com/en-us/library/aa370134.aspx)
///
/// @copydoc MsiGetPropertyW()
template<class _Elem, class _Traits, class _Ax> inline UINT MsiGetPropertyA(_In_ MSIHANDLE hInstall, _In_ LPCSTR szName, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
@@ -45,11 +43,7 @@ template<class _Elem, class _Traits, class _Ax> inline UINT MsiGetPropertyA(_In_
///
template<class _Elem, class _Traits, class _Ax> inline UINT MsiGetPropertyW(_In_ MSIHANDLE hInstall, _In_ LPCWSTR szName, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
/// Returns the string value of a record field and stores it in a std::string string.
///
/// \sa [MsiRecordGetString function](https://msdn.microsoft.com/en-us/library/aa370368.aspx)
///
/// @copydoc MsiRecordGetStringW()
template<class _Elem, class _Traits, class _Ax> inline UINT MsiRecordGetStringA(_In_ MSIHANDLE hRecord, _In_ unsigned int iField, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
@@ -59,11 +53,7 @@ template<class _Elem, class _Traits, class _Ax> inline UINT MsiRecordGetStringA(
///
template<class _Elem, class _Traits, class _Ax> inline UINT MsiRecordGetStringW(_In_ MSIHANDLE hRecord, _In_ unsigned int iField, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
/// Formats record field data and properties using a format string and stores it in a std::string string.
///
/// \sa [MsiFormatRecord function](https://msdn.microsoft.com/en-us/library/aa370109.aspx)
///
/// @copydoc MsiFormatRecordW()
template<class _Elem, class _Traits, class _Ax> inline UINT MsiFormatRecordA(MSIHANDLE hInstall, MSIHANDLE hRecord, std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
@@ -80,11 +70,7 @@ template<class _Elem, class _Traits, class _Ax> inline UINT MsiFormatRecordW(MSI
///
template<class _Ty, class _Ax> inline UINT MsiRecordReadStream(_In_ MSIHANDLE hRecord, _In_ unsigned int iField, _Out_ std::vector<_Ty, _Ax> &binData);
///
/// Returns the full target path for a folder in the Directory table and stores it in a std::string string.
///
/// \sa [MsiGetTargetPath function](https://msdn.microsoft.com/en-us/library/aa370303.aspx)
///
/// @copydoc MsiGetTargetPathW()
template<class _Elem, class _Traits, class _Ax> inline UINT MsiGetTargetPathA(_In_ MSIHANDLE hInstall, _In_ LPCSTR szFolder, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
@@ -94,11 +80,7 @@ template<class _Elem, class _Traits, class _Ax> inline UINT MsiGetTargetPathA(_I
///
template<class _Elem, class _Traits, class _Ax> inline UINT MsiGetTargetPathW(_In_ MSIHANDLE hInstall, _In_ LPCWSTR szFolder, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
/// Returns the full path to an installed component. If the key path for the component is a registry key then the registry key is returned.
///
/// \sa [MsiGetComponentPath function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa370112.aspx)
///
/// @copydoc MsiGetComponentPathW()
template<class _Elem, class _Traits, class _Ax> inline INSTALLSTATE MsiGetComponentPathA(_In_ LPCSTR szProduct, _In_ LPCSTR szComponent, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///

78
include/WinStd/Sec.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdSecurityAPI Security API
/// Integrates WinStd classes with Microsoft Security API
///
#include "Common.h"
#include <Security.h>
@@ -26,53 +31,16 @@
namespace winstd
{
///
/// \defgroup WinStdSecurityAPI Security API
/// Integrates WinStd classes with Microsoft Security API
///
/// @{
///
/// PCredHandle wrapper class
///
class WINSTD_API sec_credentials;
///
/// PCtxtHandle wrapper class
///
class WINSTD_API sec_context;
///
/// SecBufferDesc wrapper class
///
class WINSTD_API sec_buffer_desc;
/// @}
///
/// \defgroup WinStdExceptions Exceptions
/// Additional exceptions
///
/// @{
///
/// Security runtime error
///
/// \note Must be defined as derived class from num_runtime_error<> to allow correct type info for dynamic typecasting and prevent folding with other derivates of num_runtime_error<>.
///
class WINSTD_API sec_runtime_error;
/// @}
}
/// \addtogroup WinStdSecurityAPI
/// @{
///
/// Retrieves the name of the user or other security principal associated with the calling thread and stores it in a std::string string.
///
/// \sa [GetUserNameEx function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724435.aspx)
///
/// @copydoc GetUserNameExW()
template<class _Elem, class _Traits, class _Ax> BOOLEAN GetUserNameExA(_In_ EXTENDED_NAME_FORMAT NameFormat, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sName);
///
@@ -89,6 +57,12 @@ template<class _Elem, class _Traits, class _Ax> BOOLEAN GetUserNameExW(_In_ EXTE
namespace winstd
{
/// \addtogroup WinStdSecurityAPI
/// @{
///
/// PCredHandle wrapper class
///
class WINSTD_API sec_credentials : public handle<PCredHandle>
{
WINSTD_NONCOPYABLE(sec_credentials)
@@ -105,8 +79,8 @@ namespace winstd
///
/// Initializes a new class with an already available object handle.
///
/// \param[in] h Initial class handle value
/// \param[in] prop Credentials expiration
/// \param[in] h Initial class handle value
/// \param[in] expires Credentials expiration
///
inline sec_credentials(_In_opt_ handle_type h, _In_ const TimeStamp expires) :
m_expires(expires),
@@ -188,6 +162,9 @@ namespace winstd
};
///
/// PCtxtHandle wrapper class
///
class WINSTD_API sec_context : public handle<PCtxtHandle>
{
public:
@@ -299,6 +276,9 @@ namespace winstd
};
///
/// SecBufferDesc wrapper class
///
class WINSTD_API sec_buffer_desc : public SecBufferDesc
{
public:
@@ -320,15 +300,27 @@ namespace winstd
virtual ~sec_buffer_desc();
};
/// @}
///
/// \defgroup WinStdExceptions Exceptions
/// Additional exceptions
///
/// @{
///
/// Security runtime error
///
/// \note Must be defined as derived class from num_runtime_error<> to allow correct type info for dynamic typecasting and prevent folding with other derivates of num_runtime_error<>.
///
class WINSTD_API sec_runtime_error : public num_runtime_error<SECURITY_STATUS>
{
public:
///
/// Constructs an exception
///
/// \param[in] error Security provider error code
/// \param[in] msg Error message
/// \param[in] num Security provider error code
/// \param[in] msg Error message
///
inline sec_runtime_error(_In_ error_type num, _In_ const std::string& msg) : num_runtime_error<SECURITY_STATUS>(num, msg.c_str())
{
@@ -355,6 +347,8 @@ namespace winstd
{
}
};
/// @}
}

15
include/WinStd/Shell.h
View File

@@ -18,23 +18,20 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdShellWAPI Shell API
/// Integrates WinStd classes with Microsoft Shell API
///
#include "Common.h"
#include <Shlwapi.h>
#include <string>
///
/// \defgroup WinStdShellWAPI Shell API
/// Integrates WinStd classes with Microsoft Shell API
///
/// \addtogroup WinStdShellWAPI
/// @{
///
/// Simplifies a path by removing navigation elements such as "." and ".." to produce a direct, well-formed path, and stores it in a std::string string.
///
/// \sa [PathCanonicalize function](https://msdn.microsoft.com/en-us/library/windows/desktop/bb773569.aspx)
///
/// @copydoc PathCanonicalizeW()
template<class _Elem, class _Traits, class _Ax> inline BOOL PathCanonicalizeA(__out std::basic_string<_Elem, _Traits, _Ax> &sValue, __in LPCSTR pszPath);
///

41
include/WinStd/WLAN.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdWLANAPI WLAN API
/// Integrates WinStd classes with Microsoft WLAN API
///
#include "Common.h"
#include <wlanapi.h>
@@ -28,36 +33,22 @@
// without a WLAN interface.
extern DWORD (WINAPI *pfnWlanReasonCodeToString)(__in DWORD dwReasonCode, __in DWORD dwBufferSize, __in_ecount(dwBufferSize) PWCHAR pStringBuffer, __reserved PVOID pReserved);
///
/// \defgroup WinStdWLANAPI WLAN API
/// Integrates WinStd classes with Microsoft WLAN API
///
/// @{
namespace winstd {
///
/// Deleter for unique_ptr using WlanFreeMemory
///
template <class _Ty> struct WlanFreeMemory_delete;
///
/// Deleter for unique_ptr to array of unknown size using WlanFreeMemory
///
template <class _Ty> struct WlanFreeMemory_delete<_Ty[]>;
///
/// WLAN handle wrapper
///
class WINSTD_API wlan_handle;
}
/// \addtogroup WinStdWLANAPI
/// @{
///
/// Retrieves a string that describes a specified reason code and stores it in a std::wstring string.
///
/// \sa [WlanReasonCodeToString function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms706768.aspx)
///
/// \note
/// Since Wlanapi.dll is not always present, the \c pfnWlanReasonCodeToString pointer to \c WlanReasonCodeToString
/// Since Wlanapi.dll is not always present, the `pfnWlanReasonCodeToString` pointer to `WlanReasonCodeToString()`
/// function must be loaded dynamically.
///
template<class _Elem, class _Traits, class _Ax> inline DWORD WlanReasonCodeToString(_In_ DWORD dwReasonCode, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue, __reserved PVOID pReserved);
@@ -69,6 +60,12 @@ template<class _Elem, class _Traits, class _Ax> inline DWORD WlanReasonCodeToStr
namespace winstd
{
/// \addtogroup WinStdWLANAPI
/// @{
///
/// Deleter for unique_ptr using WlanFreeMemory
///
template <class _Ty> struct WlanFreeMemory_delete
{
typedef WlanFreeMemory_delete<_Ty> _Myt; ///< This type
@@ -93,6 +90,9 @@ namespace winstd
};
///
/// Deleter for unique_ptr to array of unknown size using WlanFreeMemory
///
template <class _Ty> struct WlanFreeMemory_delete<_Ty[]>
{
typedef WlanFreeMemory_delete<_Ty> _Myt; ///< This type
@@ -121,6 +121,9 @@ namespace winstd
};
///
/// WLAN handle wrapper
///
class WINSTD_API wlan_handle : public handle<HANDLE>
{
HANDLE_IMPL(wlan_handle)
@@ -163,6 +166,8 @@ namespace winstd
///
virtual void free_internal();
};
/// @}
}

197
include/WinStd/Win.h
View File

@@ -18,6 +18,11 @@
along with Setup. If not, see <http://www.gnu.org/licenses/>.
*/
///
/// \defgroup WinStdWinAPI Windows API
/// Integrates WinStd classes with Microsoft Windows API
///
#include "Common.h"
#include <Windows.h>
@@ -27,69 +32,22 @@
namespace winstd
{
///
/// \defgroup WinStdWinAPI Windows API
/// Integrates WinStd classes with Microsoft Windows API
///
/// @{
///
/// Windows HANDLE wrapper class
///
class WINSTD_API win_handle;
///
/// Module handle wrapper
///
class WINSTD_API library;
///
/// Process handle wrapper
///
class WINSTD_API process;
///
/// Heap handle wrapper
///
class WINSTD_API heap;
///
/// HeapAlloc allocator
///
template <class _Ty> class heap_allocator;
///
/// Activates given activation context in constructor and deactivates it in destructor
///
class WINSTD_API actctx_activator;
///
/// Lets the calling thread impersonate the security context of a logged-on user
///
class WINSTD_API user_impersonator;
///
/// Memory in virtual address space of a process handle wrapper
///
class WINSTD_API vmemory;
///
/// Registry wrapper class
///
class WINSTD_API reg_key;
/// @}
}
/// \addtogroup WinStdWinAPI
/// @{
///
/// Retrieves the fully qualified path for the file that contains the specified module and stores it in a std::string string.
///
/// \sa [GetModuleFileName function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms683197.aspx)
///
/// @copydoc GetModuleFileNameW()
template<class _Elem, class _Traits, class _Ax> inline DWORD GetModuleFileNameA(_In_opt_ HMODULE hModule, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
@@ -99,11 +57,7 @@ template<class _Elem, class _Traits, class _Ax> inline DWORD GetModuleFileNameA(
///
template<class _Elem, class _Traits, class _Ax> inline DWORD GetModuleFileNameW(_In_opt_ HMODULE hModule, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
/// Copies the text of the specified window's title bar (if it has one) into a std::string string.
///
/// \sa [GetWindowText function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms633520.aspx)
///
/// @copydoc GetWindowTextW()
template<class _Elem, class _Traits, class _Ax> inline int GetWindowTextA(_In_ HWND hWnd, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
@@ -113,11 +67,7 @@ template<class _Elem, class _Traits, class _Ax> inline int GetWindowTextA(_In_ H
///
template<class _Elem, class _Traits, class _Ax> inline int GetWindowTextW(_In_ HWND hWnd, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
/// Retrieves version information for the specified file and stores it in a std::vector buffer.
///
/// \sa [GetFileVersionInfo function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms647003.aspx)
///
/// @copydoc GetFileVersionInfoW()
template<class _Ty, class _Ax> inline BOOL GetFileVersionInfoA(_In_ LPCSTR lptstrFilename, __reserved DWORD dwHandle, _Out_ std::vector<_Ty, _Ax> &aValue);
///
@@ -127,12 +77,8 @@ template<class _Ty, class _Ax> inline BOOL GetFileVersionInfoA(_In_ LPCSTR lptst
///
template<class _Ty, class _Ax> inline BOOL GetFileVersionInfoW(_In_ LPCWSTR lptstrFilename, __reserved DWORD dwHandle, _Out_ std::vector<_Ty, _Ax> &aValue);
///
/// Expands environment-variable strings, replaces them with the values defined for the current user, and stores it in a std::string string.
///
/// \sa [ExpandEnvironmentStrings function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724265.aspx)
///
template<class _Elem, class _Traits, class _Ax> inline DWORD ExpandEnvironmentStringsW(_In_ LPCSTR lpSrc, std::basic_string<_Elem, _Traits, _Ax> &sValue);
/// @copydoc ExpandEnvironmentStringsW()
template<class _Elem, class _Traits, class _Ax> inline DWORD ExpandEnvironmentStringsA(_In_ LPCSTR lpSrc, std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
/// Expands environment-variable strings, replaces them with the values defined for the current user, and stores it in a std::wstring string.
@@ -141,12 +87,7 @@ template<class _Elem, class _Traits, class _Ax> inline DWORD ExpandEnvironmentSt
///
template<class _Elem, class _Traits, class _Ax> inline DWORD ExpandEnvironmentStringsW(_In_ LPCWSTR lpSrc, std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
/// Formats GUID and stores it in a std::string string.
///
/// \param[in ] lpGuid Pointer to GUID
/// \param[out] str String to store the result to
///
/// @copydoc GuidToStringW()
template<class _Elem, class _Traits, class _Ax> inline VOID GuidToStringA(_In_ LPCGUID lpGuid, _Out_ std::basic_string<_Elem, _Traits, _Ax> &str);
///
@@ -156,28 +97,29 @@ template<class _Elem, class _Traits, class _Ax> inline VOID GuidToStringA(_In_ L
/// \param[out] str String to store the result to
///
template<class _Elem, class _Traits, class _Ax> inline VOID GuidToStringW(_In_ LPCGUID lpGuid, _Out_ std::basic_string<_Elem, _Traits, _Ax> &str);
/// @copydoc GuidToStringW()
#ifdef _UNICODE
#define GuidToString GuidToStringW
#else
#define GuidToString GuidToStringA
#endif
///
/// Parses string with GUID and stores it to GUID
///
/// \param[in ] lpszGuid String with GUID
/// \param[out] lpGuid GUID to store the result to
///
BOOL WINSTD_API StringToGuidA(_In_z_ LPCSTR lpszGuid, _Out_ LPGUID lpGuid, _Out_ LPCSTR *lpszGuidEnd = NULL);
/// @copydoc StringToGuidW()
BOOL WINSTD_API StringToGuidA(_In_z_ LPCSTR lpszGuid, _Out_ LPGUID lpGuid, _Out_opt_ LPCSTR *lpszGuidEnd = NULL);
///
/// Parses string with GUID and stores it to GUID
///
/// \param[in ] lpszGuid String with GUID
/// \param[out] lpGuid GUID to store the result to
/// \param[in ] lpszGuid String with GUID
/// \param[out] lpGuid GUID to store the result to
/// \param[out] lpszGuidEnd If non-NULL the pointer to the end of parsed GUID within `lpszGuid` is returned
///
BOOL WINSTD_API StringToGuidW(_In_z_ LPCWSTR lpszGuid, _Out_ LPGUID lpGuid, _Out_ LPCWSTR *lpszGuidEnd = NULL);
/// \returns
/// - `TRUE` if GUID successfuly parsed;
/// - `FALSE` otherwise.
///
BOOL WINSTD_API StringToGuidW(_In_z_ LPCWSTR lpszGuid, _Out_ LPGUID lpGuid, _Out_opt_ LPCWSTR *lpszGuidEnd = NULL);
/// @copydoc StringToGuidW()
#ifdef _UNICODE
#define StringToGuid StringToGuidW
#else
@@ -224,11 +166,7 @@ template<class _Elem, class _Traits, class _Ax> inline LSTATUS RegQueryStringVal
///
template<class _Elem, class _Traits, class _Ax> inline LSTATUS RegQueryStringValue(_In_ HKEY hReg, _In_z_ LPCWSTR pszName, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sValue);
///
/// Retrieves the type and data for the specified value name associated with an open registry key and stores the data in a std::vector buffer.
///
/// \sa [RegQueryValueEx function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724911.aspx)
///
/// @copydoc RegQueryValueExW()
template<class _Ty, class _Ax> inline LSTATUS RegQueryValueExA(_In_ HKEY hKey, _In_opt_ LPCSTR lpValueName, __reserved LPDWORD lpReserved, _Out_opt_ LPDWORD lpType, _Out_ std::vector<_Ty, _Ax> &aData);
///
@@ -240,11 +178,7 @@ template<class _Ty, class _Ax> inline LSTATUS RegQueryValueExW(_In_ HKEY hKey, _
#if _WIN32_WINNT >= _WIN32_WINNT_VISTA
///
/// Loads the specified string from the specified key and subkey, and stores it in a std::string string.
///
/// \sa [RegLoadMUIString function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724890.aspx)
///
/// @copydoc RegLoadMUIStringW()
template<class _Elem, class _Traits, class _Ax> inline LSTATUS RegLoadMUIStringA(_In_ HKEY hKey, _In_opt_ LPCSTR pszValue, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sOut, _In_ DWORD Flags, _In_opt_ LPCSTR pszDirectory);
///
@@ -270,19 +204,15 @@ template<class _Elem, class _Traits, class _Ax> inline int WideCharToMultiByte(_
///
template<class _Elem, class _Traits, class _Ax> inline int MultiByteToWideChar(_In_ UINT CodePage, _In_ DWORD dwFlags, _In_z_count_(cbMultiByte) LPCSTR lpMultiByteStr, _In_ int cbMultiByte, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sWideCharStr);
///
/// Loads a string resource from the executable file associated with a specified module.
///
/// \sa [LoadString function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms647486.aspx)
///
template<class _Traits, class _Ax> inline int WINAPI LoadString(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ std::basic_string<char, _Traits, _Ax> &sBuffer);
/// @copydoc LoadStringW
template<class _Traits, class _Ax> inline int WINAPI LoadStringA(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ std::basic_string<char, _Traits, _Ax> &sBuffer);
///
/// Loads a string resource from the executable file associated with a specified module.
///
/// \sa [LoadString function](https://msdn.microsoft.com/en-us/library/windows/desktop/ms647486.aspx)
///
template<class _Traits, class _Ax> inline int WINAPI LoadString(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sBuffer);
template<class _Traits, class _Ax> inline int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sBuffer);
///
/// Formats and sends a string to the debugger for display.
@@ -312,11 +242,7 @@ inline VOID OutputDebugStr(_In_ LPCSTR lpOutputString, ...);
///
inline VOID OutputDebugStr(_In_ LPCWSTR lpOutputString, ...);
///
/// Formats a date as a date string for a locale specified by the locale identifier. The function formats either a specified date or the local system date.
///
/// \sa [GetDateFormat function](https://msdn.microsoft.com/en-us/library/windows/desktop/dd318086.aspx)
///
/// @copydoc GetDateFormatW()
template<class _Elem, class _Traits, class _Ax> inline int GetDateFormatA(_In_ LCID Locale, _In_ DWORD dwFlags, _In_opt_ const SYSTEMTIME *lpDate, _In_opt_ LPCSTR lpFormat, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sDate);
///
@@ -326,11 +252,7 @@ template<class _Elem, class _Traits, class _Ax> inline int GetDateFormatA(_In_ L
///
template<class _Elem, class _Traits, class _Ax> inline int GetDateFormatW(_In_ LCID Locale, _In_ DWORD dwFlags, _In_opt_ const SYSTEMTIME *lpDate, _In_opt_ LPCWSTR lpFormat, _Out_ std::basic_string<_Elem, _Traits, _Ax> &sDate);
///
/// Retrieves the name of the account for this SID and the name of the first domain on which this SID is found.
///
/// \sa [LookupAccountSid function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379166.aspx)
///
/// @copydoc LookupAccountSidW()
template<class _Elem, class _Traits, class _Ax> inline BOOL LookupAccountSidA(_In_opt_ LPCSTR lpSystemName, _In_ PSID lpSid, _Out_opt_ std::basic_string<_Elem, _Traits, _Ax> *sName, _Out_opt_ std::basic_string<_Elem, _Traits, _Ax> *sReferencedDomainName, _Out_ PSID_NAME_USE peUse);
///
@@ -347,6 +269,12 @@ template<class _Elem, class _Traits, class _Ax> inline BOOL LookupAccountSidW(_I
namespace winstd
{
/// \addtogroup WinStdWinAPI
/// @{
///
/// Windows HANDLE wrapper class
///
class WINSTD_API win_handle : public handle<HANDLE>
{
HANDLE_IMPL(win_handle)
@@ -369,6 +297,9 @@ namespace winstd
};
///
/// Module handle wrapper
///
class WINSTD_API library : public handle<HMODULE>
{
HANDLE_IMPL(library)
@@ -410,6 +341,9 @@ namespace winstd
};
///
/// Process handle wrapper
///
class WINSTD_API process : public win_handle
{
public:
@@ -434,6 +368,9 @@ namespace winstd
};
///
/// Heap handle wrapper
///
class WINSTD_API heap : public handle<HANDLE>
{
HANDLE_IMPL(heap)
@@ -484,24 +421,30 @@ namespace winstd
};
///
/// HeapAlloc allocator
///
template <class _Ty>
class heap_allocator
{
public:
typedef typename _Ty value_type;
typedef typename _Ty value_type; ///< A type that is managed by the allocator
typedef _Ty *pointer;
typedef _Ty& reference;
typedef const _Ty *const_pointer;
typedef const _Ty& const_reference;
typedef _Ty *pointer; ///< A type that provides a pointer to the type of object managed by the allocator
typedef _Ty& reference; ///< A type that provides a reference to the type of object managed by the allocator
typedef const _Ty *const_pointer; ///< A type that provides a constant pointer to the type of object managed by the allocator
typedef const _Ty& const_reference; ///< A type that provides a constant reference to type of object managed by the allocator
typedef SIZE_T size_type;
typedef ptrdiff_t difference_type;
typedef SIZE_T size_type; ///< An unsigned integral type that can represent the length of any sequence that an object of template class `heap_allocator` can allocate
typedef ptrdiff_t difference_type; ///< A signed integral type that can represent the difference between values of pointers to the type of object managed by the allocator
///
/// A structure that enables an allocator for objects of one type to allocate storage for objects of another type.
///
template <class _Other>
struct rebind
{
typedef heap_allocator<_Other> other;
typedef heap_allocator<_Other> other; ///< Other allocator type
};
public:
@@ -591,10 +534,13 @@ namespace winstd
}
public:
HANDLE m_heap;
HANDLE m_heap; ///< Heap handle
};
///
/// Activates given activation context in constructor and deactivates it in destructor
///
class WINSTD_API actctx_activator
{
public:
@@ -619,6 +565,9 @@ namespace winstd
};
///
/// Lets the calling thread impersonate the security context of a logged-on user
///
class WINSTD_API user_impersonator
{
public:
@@ -643,6 +592,9 @@ namespace winstd
};
///
/// Memory in virtual address space of a process handle wrapper
///
class WINSTD_API vmemory : public handle<LPVOID>
{
WINSTD_NONCOPYABLE(vmemory)
@@ -752,6 +704,9 @@ namespace winstd
};
///
/// Registry wrapper class
///
class WINSTD_API reg_key : public handle<HKEY>
{
HANDLE_IMPL(reg_key)
@@ -827,6 +782,8 @@ namespace winstd
///
virtual void free_internal();
};
/// @}
}
@@ -973,7 +930,7 @@ inline BOOL GetFileVersionInfoW(_In_ LPCWSTR lptstrFilename, __reserved DWORD dw
template<class _Elem, class _Traits, class _Ax>
inline DWORD ExpandEnvironmentStringsW(_In_ LPCSTR lpSrc, std::basic_string<_Elem, _Traits, _Ax> &sValue)
inline DWORD ExpandEnvironmentStringsA(_In_ LPCSTR lpSrc, std::basic_string<_Elem, _Traits, _Ax> &sValue)
{
assert(0); // TODO: Test this code.
@@ -1281,7 +1238,7 @@ inline int MultiByteToWideChar(_In_ UINT CodePage, _In_ DWORD dwFlags, _In_z_cou
template<class _Traits, class _Ax>
inline int WINAPI LoadString(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ std::basic_string<char, _Traits, _Ax> &sBuffer)
inline int WINAPI LoadStringA(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ std::basic_string<char, _Traits, _Ax> &sBuffer)
{
// Get read-only pointer to string resource.
LPCSTR pszStr;
@@ -1295,7 +1252,7 @@ inline int WINAPI LoadString(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_
template<class _Traits, class _Ax>
inline int WINAPI LoadString(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sBuffer)
inline int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sBuffer)
{
// Get read-only pointer to string resource.
LPCWSTR pszStr;