Common.h

/*
    SPDX-License-Identifier: MIT
    Copyright © 1991-2023 Amebis
    Copyright © 2016 GÉANT
*/
 
#pragma once
 
#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);
        }
    };
 
    struct GlobalFree_delete
    {
        GlobalFree_delete() {}
 
        void operator()(HGLOBAL _Ptr) const
        {
            GlobalFree(_Ptr);
        }
    };
 
    template <class T>
    class globalmem_accessor
    {
        WINSTD_NONCOPYABLE(globalmem_accessor)
        WINSTD_NONMOVABLE(globalmem_accessor)
 
    public:
        globalmem_accessor(_In_ HGLOBAL hMem) : m_h(hMem)
        {
            m_data = (T*)GlobalLock(hMem);
            if (!m_data)
                throw win_runtime_error("GlobalLock failed");
        }
 
        virtual ~globalmem_accessor()
        {
            GlobalUnlock(m_h);
        }
 
        T* data() const noexcept
        {
            return m_data;
        }
 
    protected:
        HGLOBAL m_h;  
        T* m_data;    
    };
 
    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>
    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(_Inout_ ref_unique_ptr<_Ty[], _Dx> &&other) :
            m_own(other.m_own),
            m_ptr(other.m_ptr)
        {
            other.m_ptr = nullptr;
        }
 
        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;   
    };
 
    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 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) : 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 (m_h != invalid)
                        free_internal();
 
                    m_h = h_new;
                } 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;
        }
 
        void attach_duplicated(_In_opt_ handle_type h)
        {
            if (m_h != invalid)
                free_internal();
 
            m_h = h != invalid ? duplicate_internal(h) : invalid;
        }
 
    protected:
        virtual handle_type duplicate_internal(_In_ handle_type h) const = 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];    
    };
 
}