cWinVariant.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cWinVariant_H
#define _INC_cWinVariant_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cWinString.h"
 
#if defined(_WIN32)
#include "GrayCore/include/cIUnkPtr.h"
#include "GrayCore/include/cValT.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cWinVariant);
 
        class GRAYLIB_LINK cWinVariant
#if defined(_MFC_VER)   // using MFC.
                : public CComVariant
#else
                : public tagVARIANT
#endif
        {
 
        public:
#if defined(_MFC_VER)   // using MFC.
                cWinVariant()
                {
                }
                cWinVariant(enum VARENUM vtSrc)
                {
                        this->vt = vtSrc;
                }
                cWinVariant(int nSrc, enum VARENUM vtSrc = VT_I4)
                : CComVariant(nSrc,vtSrc)
                {
                }
 
#else
                cWinVariant() throw()
                {
                        // vt = VT_EMPTY is faster than ::VariantInit(this);
                        cMem::Zero(this, sizeof(*this));
                }
                ~cWinVariant() throw()
                {
                        Clear();
                }
                cWinVariant(enum VARENUM vtinit)
                {
                        cMem::Zero(this, sizeof(*this));
                        // V_VT(this) = vtinit;
                        vt = (VARTYPE)vtinit;
                }
 
                cWinVariant(const VARIANT& varSrc)
                {
                        vt = VT_EMPTY;
                        InternalCopy(&varSrc);
                }
                cWinVariant(const cWinVariant& varSrc)
                {
                        vt = VT_EMPTY;
                        InternalCopy(&varSrc);
                }
                cWinVariant(VARIANT* pvarSrc)
                {
                        vt = VT_EMPTY;
                        *this = pvarSrc;
                }
                cWinVariant(LPCOLESTR lpszSrc)
                {
                        vt = VT_EMPTY;
                        *this = lpszSrc;
                }
                cWinVariant(const char* lpszSrc)
                {
                        vt = VT_EMPTY;
                        *this = lpszSrc;
                }
                cWinVariant(bool bSrc)
                {
                        vt = VT_BOOL;
                        boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
                }
                cWinVariant(int nSrc, VARTYPE vtSrc = VT_I4) throw()
                {
                        ASSERT(vtSrc == VT_I4 || vtSrc == VT_INT);
                        vt = vtSrc;
                        intVal = nSrc;
                }
                cWinVariant(BYTE nSrc) throw()
                {
                        vt = VT_UI1;
                        bVal = nSrc;
                }
                cWinVariant(short nSrc) throw()
                {
                        vt = VT_I2;
                        iVal = nSrc;
                }
                cWinVariant(long nSrc, VARTYPE vtSrc = VT_I4) throw()
                {
                        ASSERT(vtSrc == VT_I4 || vtSrc == VT_ERROR);
                        vt = vtSrc;
                        lVal = nSrc;
                }
                cWinVariant(float fltSrc) throw()
                {
                        vt = VT_R4;
                        fltVal = fltSrc;
                }
                cWinVariant(double dblSrc, VARTYPE vtSrc = VT_R8) throw()
                {
                        ASSERT(vtSrc == VT_R8 || vtSrc == VT_DATE);
                        vt = vtSrc;
                        dblVal = dblSrc;
                }
#if !defined(UNDER_CE) && (defined(USE_64BIT) || (_WIN32_WINNT >= 0x0501) || defined(_ATL_SUPPORT_VT_I8))
                cWinVariant(LONGLONG nSrc) throw()
                {
                        vt = VT_I8;
                        llVal = nSrc;
                }
                cWinVariant(ULONGLONG nSrc) throw()
                {
                        vt = VT_UI8;
                        ullVal = nSrc;
                }
#endif
                cWinVariant(CY cySrc) throw()
                {
                        // money/currency
                        vt = VT_CY;
                        cyVal.Hi = cySrc.Hi;
                        cyVal.Lo = cySrc.Lo;
                }
                cWinVariant(IDispatch* pSrc) throw()
                {
                        vt = VT_DISPATCH;
                        pdispVal = pSrc;
                        // Need to AddRef as VariantClear will Release
                        if (pdispVal != nullptr)
                                pdispVal->AddRef();
                }
                cWinVariant(IUnknown* pSrc) throw()
                {
                        // cIUnkPtr<>
                        vt = VT_UNKNOWN;
                        punkVal = pSrc;
                        // Need to AddRef as VariantClear will Release
                        if (punkVal != nullptr)
                                punkVal->AddRef();
                }
                cWinVariant(char cSrc) throw()
                {
                        vt = VT_I1;
                        cVal = cSrc;
                }
                cWinVariant(unsigned short nSrc) throw()
                {
                        vt = VT_UI2;
                        uiVal = nSrc;
                }
                cWinVariant(unsigned long nSrc) throw()
                {
                        vt = VT_UI4;
                        ulVal = nSrc;
                }
                cWinVariant(unsigned int nSrc, VARTYPE vtSrc = VT_UI4) throw()
                {
                        ASSERT(vtSrc == VT_UI4 || vtSrc == VT_UINT);
                        vt = vtSrc;
                        uintVal = nSrc;
                }
                cWinVariant(const CComBSTR& bstrSrc)
                {
                        vt = VT_EMPTY;
                        *this = bstrSrc;
                }
 
#ifndef UNDER_CE
                cWinVariant(const SAFEARRAY *pSrc)
                {
                        if (pSrc == nullptr)
                        {
                                // vt = VT_EMPTY;
                                cMem::Zero(this, sizeof(*this));
                                return;
                        }
                        InternalSafeArray(pSrc);
                }
#endif
 
        protected:
                void InitTypeInt(enum VARENUM vtinit)
                {
                        if (vtinit == vt)
                                return;
                        Clear();
                        vt = (VARTYPE)vtinit; // V_VT(this) = vtinit;
                }
 
        public:
                void InitType(enum VARENUM vtinit)
                {
                        Clear();
                        cMem::Zero(this, sizeof(*this));
                        vt = (VARTYPE)vtinit; // V_VT(this) = vtinit;
                }
 
                // Assignment Operators
        public:
                const cWinVariant& operator=(const cWinVariant& varSrc)
                {
                        InternalCopy(&varSrc);
                        return *this;
                }
                const cWinVariant& operator=(const VARIANT& varSrc)
                {
                        InternalCopy(&varSrc);
                        return *this;
                }
 
                const cWinVariant& operator=(const CComBSTR& bstrSrc)
                {
                        InitType(VT_BSTR);
                        bstrVal = bstrSrc.Copy();
                        if (bstrVal == nullptr && bstrSrc.m_str != nullptr)
                        {
                                vt = VT_ERROR;
                                scode = E_OUTOFMEMORY;
                        }
                        return *this;
                }
 
                const cWinVariant& operator=(LPCOLESTR lpszSrc)
                {
                        // wchar_t* for UNICODE
                        InitType(VT_BSTR);
                        bstrVal = ::SysAllocString(lpszSrc);
 
                        if (bstrVal == nullptr && lpszSrc != nullptr)
                        {
                                vt = VT_ERROR;
                                scode = E_OUTOFMEMORY;
                        }
                        return *this;
                }
 
                const cWinVariant& operator=(const char* lpszSrc)
                {
                        // USES_CONVERSION_EX;
                        // char*
                        InitType(VT_BSTR);
                        cWinString strTmp(lpszSrc);
                        this->bstrVal = strTmp.Detach();
 
                        if (bstrVal == nullptr && lpszSrc != nullptr)
                        {
                                vt = VT_ERROR;
                                scode = E_OUTOFMEMORY;
                        }
                        return *this;
                }
 
                const cWinVariant& operator=(bool bSrc)
                {
                        InitTypeInt(VT_BOOL);
                        boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
                        return *this;
                }
 
                const cWinVariant& operator=(int nSrc) throw()
                {
                        InitTypeInt(VT_I4);
                        intVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(BYTE nSrc) throw()
                {
                        InitTypeInt(VT_UI1);
                        bVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(short nSrc) throw()
                {
                        InitTypeInt(VT_I2);
                        iVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(long nSrc) throw()
                {
                        InitTypeInt(VT_I4);
                        lVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(float fltSrc) throw()
                {
                        InitTypeInt(VT_R4);
                        fltVal = fltSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(double dblSrc) throw()
                {
                        InitTypeInt(VT_R8);
                        dblVal = dblSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(CY cySrc) throw()
                {
                        InitTypeInt(VT_CY);
                        cyVal.Hi = cySrc.Hi;
                        cyVal.Lo = cySrc.Lo;
                        return *this;
                }
 
                const cWinVariant& operator=(IDispatch* pSrc) throw()
                {
                        InitType(VT_DISPATCH);
                        pdispVal = pSrc;
                        // Need to AddRef as VariantClear will Release
                        if (pdispVal != nullptr)
                                pdispVal->AddRef();
                        return *this;
                }
 
                const cWinVariant& operator=(IUnknown* pSrc) throw()
                {
                        InitType(VT_UNKNOWN);
                        punkVal = pSrc;
 
                        // Need to AddRef as VariantClear will Release
                        if (punkVal != nullptr)
                                punkVal->AddRef();
                        return *this;
                }
 
                const cWinVariant& operator=(VARIANT* ppSrc)
                {
                        InitType((VARENUM)(VT_VARIANT | VT_BYREF));
                        pvarVal = ppSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(char cSrc) throw()
                {
                        InitTypeInt(VT_I1);
                        cVal = cSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(unsigned short nSrc) throw()
                {
                        InitTypeInt(VT_UI2);
                        uiVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(unsigned long nSrc) throw()
                {
                        InitTypeInt(VT_UI4);
                        ulVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(unsigned int nSrc) throw()
                {
                        InitTypeInt(VT_UI4);
                        uintVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(BYTE* pbSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_UI1 | VT_BYREF));
                        pbVal = pbSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(short* pnSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_I2 | VT_BYREF));
                        piVal = pnSrc;
                        return *this;
                }
 
#ifdef _NATIVE_WCHAR_T_DEFINED
                const cWinVariant& operator=(WORD* pnSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_UI2 | VT_BYREF));
                        puiVal = pnSrc;
                        return *this;
                }
#endif
 
                const cWinVariant& operator=(int* pnSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_I4 | VT_BYREF));
                        pintVal = pnSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(UINT* pnSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_UI4 | VT_BYREF));
                        puintVal = pnSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(long* pnSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_I4 | VT_BYREF));
                        plVal = pnSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(ULONG* pnSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_UI4 | VT_BYREF));
                        pulVal = pnSrc;
                        return *this;
                }
 
#if ! defined(UNDER_CE) && (defined(USE_64BIT) || (_WIN32_WINNT >= 0x0501) || defined(_ATL_SUPPORT_VT_I8))
                const cWinVariant& operator=(LONGLONG nSrc) throw()
                {
                        InitTypeInt(VT_I8);
                        llVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(LONGLONG* pnSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_I8 | VT_BYREF));
                        pllVal = pnSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(ULONGLONG nSrc) throw()
                {
                        InitTypeInt(VT_UI8);
                        ullVal = nSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(ULONGLONG* pnSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_UI8 | VT_BYREF));
                        pullVal = pnSrc;
                        return *this;
                }
#endif
 
                const cWinVariant& operator=(float* pfSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_R4 | VT_BYREF));
                        pfltVal = pfSrc;
                        return *this;
                }
 
                const cWinVariant& operator=(double* pfSrc) throw()
                {
                        InitTypeInt((VARENUM)(VT_R8 | VT_BYREF));
                        pdblVal = pfSrc;
                        return *this;
                }
 
#ifndef UNDER_CE
                void InternalSafeArray(const SAFEARRAY *pSrc)
                {
                        ASSERT(pSrc != nullptr);
                        LPSAFEARRAY pCopy;
                        HRESULT hRes = ::SafeArrayCopy((LPSAFEARRAY)pSrc, &pCopy);
                        if (SUCCEEDED(hRes) && pCopy != nullptr)
                        {
                                ::SafeArrayGetVartype((LPSAFEARRAY)pSrc, &vt);
                                vt |= VT_ARRAY;
                                parray = pCopy;
                        }
                        else
                        {
                                vt = VT_ERROR;
                                scode = hRes;
                        }
                }
 
                const cWinVariant& operator=(const SAFEARRAY *pSrc)
                {
                        Clear();
                        if (pSrc != nullptr)
                        {
                                InternalSafeArray(pSrc);
                        }
                        return *this;
                }
#endif
 
                // Comparison Operators
        public:
 
#ifndef UNDER_CE
                COMPARE_t CompareVar(const VARIANT& varSrc) const
                {
                        // VARCMP_EQ, VARCMP_LT, VARCMP_GT
                        // NOTE: NOT the same as COMPARE_t
#if ( _MSC_VER >= 1300 ) || defined(__GNUC__)
                        return ::VarCmp((VARIANT*)this, (VARIANT*)&varSrc, LOCALE_USER_DEFAULT, 0);
#else
                        return ::VarCmp((VARIANT*)this, (VARIANT*)&varSrc, LOCALE_USER_DEFAULT);
#endif
                }
                bool operator==(const VARIANT& varSrc) const throw()
                {
                        // For backwards compatibility
                        if (vt == VT_NULL && varSrc.vt == VT_NULL)
                                return VARCMP_EQ;
                        return(CompareVar(varSrc) == VARCMP_EQ);
                }
                bool operator!=(const VARIANT& varSrc) const throw()
                {
                        if (vt == VT_NULL && varSrc.vt == VT_NULL)
                                return VARCMP_EQ;
                        return(CompareVar(varSrc) != VARCMP_EQ);
                }
                bool operator<(const VARIANT& varSrc) const throw()
                {
                        if (vt == VT_NULL && varSrc.vt == VT_NULL)
                                return false;
                        return(CompareVar(varSrc) == VARCMP_LT);
                }
                bool operator>(const VARIANT& varSrc) const throw()
                {
                        if (vt == VT_NULL && varSrc.vt == VT_NULL)
                                return false;
                        return(CompareVar(varSrc) == VARCMP_GT);
                }
#endif
 
                // Operations
        public:
                HRESULT Clear()
                {
                        return ::VariantClear(this);
                }
                HRESULT Copy(const VARIANT* pSrc)
                {
                        return ::VariantCopy(this, const_cast<VARIANT*>(pSrc));
                }
 
                HRESULT CopyTo(BSTR* pstrDest) const;
                HRESULT Attach(VARIANT* pSrc)
                {
                        // Move pDest into this.
                        if (pSrc == nullptr)
                                return E_INVALIDARG;
 
                        // Clear out the variant
                        HRESULT hRes = Clear();
                        if (!FAILED(hRes))
                        {
                                // Copy the contents and give control to cWinVariant
                                memcpy(this, pSrc, sizeof(VARIANT));
                                pSrc->vt = VT_EMPTY;
                                hRes = S_OK;
                        }
                        return hRes;
                }
 
                HRESULT Detach(VARIANT* pDest)
                {
                        // Move this into pDest.
                        ASSERT(pDest != nullptr);
                        if (pDest == nullptr)
                                return E_POINTER;
 
                        // Clear out the variant
                        HRESULT hRes = ::VariantClear(pDest);
                        if (!FAILED(hRes))
                        {
                                // Copy the contents and remove control from cWinVariant
                                memcpy(pDest, this, sizeof(VARIANT));
                                vt = VT_EMPTY;
                                hRes = S_OK;
                        }
                        return hRes;
                }
                void Detach()
                {
                        vt = VT_EMPTY;
                }
 
                HRESULT ChangeType(VARTYPE vtNew, const VARIANT* pSrc = nullptr)
                {
                        VARIANT* pVar = const_cast<VARIANT*>(pSrc);
                        // Convert in place if pSrc is nullptr
                        if (pVar == nullptr)
                                pVar = this;
                        // Do nothing if doing in place convert and vts not different
                        return ::VariantChangeType(this, pVar, 0, vtNew);
                }
 
#if 0
                template< typename _TYPE >
                void SetByRef(_TYPE* pT) throw()
                {
                        Clear();
                        vt = CVarTypeInfo< _TYPE >::VT | VT_BYREF;
                        byref = pT;
                }
#endif
 
                HRESULT WriteToStream(IStream* pStream);
                HRESULT ReadFromStream(IStream* pStream);
 
                // Return the size in bytes of the current contents
                ULONG GetSize() const;
 
                // Implementation
                HRESULT InternalClear()
                {
                        HRESULT hRes = Clear();
                        ASSERT(SUCCEEDED(hRes));
                        if (FAILED(hRes))
                        {
                                vt = VT_ERROR;
                                scode = hRes;
                        }
                        return hRes;
                }
 
                void InternalCopy(const VARIANT* pSrc)
                {
                        HRESULT hRes = Copy(pSrc);
                        if (FAILED(hRes))
                        {
                                vt = VT_ERROR;
                                scode = hRes;
                        }
                }
#endif // _MFC_VER
 
                static inline BSTR GetBStr(VARIANT* pVar);
 
                UNITTEST2_PREDEF(cWinVariant);
        };
 
        inline BSTR cWinVariant::GetBStr(VARIANT* pVar) // static
        {
                ASSERT(pVar != nullptr);
                switch (pVar->vt)
                {
                case VT_BYREF | VT_VARIANT:
                        return cWinVariant::GetBStr(pVar->pvarVal);
                case VT_BYREF | VT_BSTR:
                        return *pVar->pbstrVal;
                case VT_BSTR:
                        return pVar->bstrVal;
                default:
                        return nullptr;
                }
        }
};
 
#ifndef _MFC_VER
typedef GrayLib::cWinVariant CComVariant;       // alias
#endif
 
#endif // _WIN32
#endif // _INC_cWinVariant_H