Msi_ccomvariant.h

Go to the documentation of this file.

// File:    ccomvariant.h
// Date:    8/28/2001
// Author:  Yuling Ma
//
// Copyright (C) 2001 MicroStrategy Incorporated
// All rights reserved

// This header file is for defining the CComVariant related structures, symbols and functions.
// On NT platform, the these structures, symbols and functions are defined in the following
// header files: atlbase.h
#ifndef _CCOMVARIANT_H_
#define _CCOMVARIANT_H_

#include "Msi_variant.h"

#include "Base/Base/MultiByteConverter.h"

#import "string"
#include <sstream>

// CComVariant

class CComVariant : public tagVARIANT
{
// Constructors
public:
    CComVariant()
    {
        vt = VT_EMPTY;
    }
    ~CComVariant()
    {
        Clear();
    }

    CComVariant(const VARIANT& varSrc)
    {
        vt = VT_EMPTY;
        InternalCopy(&varSrc);
    }

    CComVariant(const CComVariant& varSrc)
    {
        vt = VT_EMPTY;
        InternalCopy(&varSrc);
    }

    CComVariant(BSTR bstrSrc)
    {
        vt = VT_EMPTY;
        *this = bstrSrc;
    }

#ifndef NO_WCHAR_SUPPORT    
    CComVariant(LPCOLESTR lpszSrc)
    {
        vt = VT_EMPTY;
        *this = lpszSrc;
    }
#endif

    CComVariant(LPCSTR lpszSrc)
    {
        vt = VT_EMPTY;
        *this = lpszSrc;
    }

    CComVariant(bool bSrc)
    {
        vt = VT_BOOL;
        boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
    }

    CComVariant(int nSrc)
    {
        vt = VT_I4;
        lVal = nSrc;
    }
    CComVariant(BYTE nSrc)
    {
        vt = VT_UI1;
        bVal = nSrc;
    }
    CComVariant(short nSrc)
    {
        vt = VT_I2;
        iVal = nSrc;
    }
    CComVariant(long nSrc, VARTYPE vtSrc = VT_I4)
    {
        ATLASSERT(vtSrc == VT_I4 || vtSrc == VT_ERROR);
        vt = vtSrc;
        lVal = nSrc;
    }
    CComVariant(float fltSrc)
    {
        vt = VT_R4;
        fltVal = fltSrc;
    }
    CComVariant(double dblSrc)
    {
        vt = VT_R8;
        dblVal = dblSrc;
    }
    CComVariant(CY cySrc)
    {
        vt = VT_CY;
        cyVal._Parts.Hi = cySrc._Parts.Hi;
        cyVal._Parts.Lo = cySrc._Parts.Lo;
    }
    CComVariant(IDispatch* pSrc)
    {
        vt = VT_DISPATCH;
        pdispVal = pSrc;
        // Need to AddRef as VariantClear will Release
        if (pdispVal != NULL)
            pdispVal->AddRef();
    }
    CComVariant(IUnknown* pSrc)
    {
        vt = VT_UNKNOWN;
        punkVal = pSrc;
        // Need to AddRef as VariantClear will Release
        if (punkVal != NULL)
            punkVal->AddRef();
    }
    CComVariant(const SAFEARRAY* pSrc)
    {
        VARTYPE lvt;
        SafeArrayGetVartype((SAFEARRAY*)pSrc,&lvt);
        // Gopal - Oct 15 2007
        // Using VT_ARRAY and not VT_SAFEARRAY to conform with MSDN documentation
        // of the original constructor in NTCOM
        vt = VT_EMPTY;
        VARIANT lTempVar;
        lTempVar.vt = VT_ARRAY | lvt;
        lTempVar.parray = (SAFEARRAY*)pSrc;
        InternalCopy(&lTempVar);
    }

// Assignment Operators
public:
    CComVariant& operator=(const CComVariant& varSrc)
    {
        InternalCopy(&varSrc);
        return *this;
    }
    CComVariant& operator=(const VARIANT& varSrc)
    {
        InternalCopy(&varSrc);
        return *this;
    }

    CComVariant& operator=(BSTR bstrSrc)
    {
        InternalClear();
        vt = VT_BSTR;
        bstrVal = ::SysAllocString(bstrSrc);
        if (bstrVal == NULL && bstrSrc != NULL)
        {
            vt = VT_ERROR;
            scode = E_OUTOFMEMORY;
        }
        return *this;
    }

    CComVariant& operator=(LPCOLESTR lpszSrc)
    {
        InternalClear();
        vt = VT_BSTR;
        bstrVal = ::SysAllocString(lpszSrc);

        if (bstrVal == NULL && lpszSrc != NULL)
        {
            vt = VT_ERROR;
            scode = E_OUTOFMEMORY;
        }
        return *this;
    }

#ifndef NO_WCHAR_SUPPORT
    CComVariant& operator=(LPCSTR lpszSrc) //Drop the ReturnWString support and replace our own logic here
    {
        //const MBase::ReturnWString lStr(MBase::MultiByteToWideChar(lpszSrc));
        /*       Seems what we need here is nothing but a wchar_t string, so....        */  
        std::string lInpuStr = lpszSrc;
        const size_t lSize = lInpuStr.size();
        wchar_t lBuffer[lSize + 1];
        
        //size_t     mbstowcs(wchar_t * __restrict , const char * __restrict, size_t);
        mbstowcs(lBuffer, lInpuStr.c_str(), lSize + 1);
        std::wstring lStr(lBuffer); 

        *this = lStr.c_str();
        return *this;
    }
#endif
    CComVariant& operator=(bool bSrc)
    {
        if (vt != VT_BOOL)
        {
            InternalClear();
            vt = VT_BOOL;
        }
        boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
        return *this;
    }

    CComVariant& operator=(int nSrc)
    {
        if (vt != VT_I4)
        {
            InternalClear();
            vt = VT_I4;
        }
        lVal = nSrc;

        return *this;
    }

    CComVariant& operator=(BYTE nSrc)
    {
        if (vt != VT_UI1)
        {
            InternalClear();
            vt = VT_UI1;
        }
        bVal = nSrc;
        return *this;
    }

    CComVariant& operator=(short nSrc)
    {
        if (vt != VT_I2)
        {
            InternalClear();
            vt = VT_I2;
        }
        iVal = nSrc;
        return *this;
    }

    CComVariant& operator=(long nSrc)
    {
        if (vt != VT_I4)
        {
            InternalClear();
            vt = VT_I4;
        }
        lVal = nSrc;
        return *this;
    }

    CComVariant& operator=(float fltSrc)
    {
        if (vt != VT_R4)
        {
            InternalClear();
            vt = VT_R4;
        }
        fltVal = fltSrc;
        return *this;
    }

    CComVariant& operator=(double dblSrc)
    {
        if (vt != VT_R8)
        {
            InternalClear();
            vt = VT_R8;
        }
        dblVal = dblSrc;
        return *this;
    }

    CComVariant& operator=(CY cySrc)
    {
        if (vt != VT_CY)
        {
            InternalClear();
            vt = VT_CY;
        }
        cyVal._Parts.Hi = cySrc._Parts.Hi;
        cyVal._Parts.Lo = cySrc._Parts.Lo;
        return *this;
    }

    CComVariant& operator=(IDispatch* pSrc)
    {
        InternalClear();
        vt = VT_DISPATCH;
        pdispVal = pSrc;
        // Need to AddRef as VariantClear will Release
        if (pdispVal != NULL)
            pdispVal->AddRef();
        return *this;
    }

    CComVariant& operator=(IUnknown* pSrc)
    {
        InternalClear();
        vt = VT_UNKNOWN;
        punkVal = pSrc;

        // Need to AddRef as VariantClear will Release
        if (punkVal != NULL)
            punkVal->AddRef();
        return *this;
    }


// Comparison Operators
public:
    bool operator==(const VARIANT& varSrc) const
    {
        if (this == &varSrc)
            return true;

        // Variants not equal if types don't match
        if (vt != varSrc.vt)
            return false;

        // Check type specific values
        switch (vt)
        {
            case VT_EMPTY:
            case VT_NULL:
                return true;

            case VT_BOOL:
                return boolVal == varSrc.boolVal;

            case VT_UI1:
                return bVal == varSrc.bVal;

            case VT_I2:
                return iVal == varSrc.iVal;

            case VT_I4:
                return lVal == varSrc.lVal;

            case VT_R4:
                return fltVal == varSrc.fltVal;

            case VT_R8:
                return dblVal == varSrc.dblVal;

            case VT_BSTR:
                return (::SysStringByteLen(bstrVal) == ::SysStringByteLen(varSrc.bstrVal)) &&
                        (::memcmp(bstrVal, varSrc.bstrVal, ::SysStringByteLen(bstrVal)) == 0);

            case VT_ERROR:
                return scode == varSrc.scode;

            case VT_DISPATCH:
                return pdispVal == varSrc.pdispVal;

            case VT_UNKNOWN:
                return punkVal == varSrc.punkVal;
            // weilin 2016/10/21
            case VT_DATE:
                return date == varSrc.date;

            default:
                ATLASSERT(false);
                // fall through
        }

        return false;
    }
    bool operator!=(const VARIANT& varSrc) const {return !operator==(varSrc);}

    bool operator<(const VARIANT& varSrc) const {return VarCmp((VARIANT*)this, (VARIANT*)&varSrc, LOCALE_USER_DEFAULT, 0)==VARCMP_LT;}
    bool operator>(const VARIANT& varSrc) const {return VarCmp((VARIANT*)this, (VARIANT*)&varSrc, LOCALE_USER_DEFAULT, 0)==VARCMP_GT;}

// Operations
public:
    HRESULT Clear() { return ::VariantClear(this); }
    HRESULT Copy(const VARIANT* pSrc) { return ::VariantCopy(this, const_cast<VARIANT*>(pSrc)); }
    HRESULT Attach(VARIANT* pSrc)
    {
        // Clear out the variant
        HRESULT hr = Clear();
        if (!FAILED(hr))
        {
            // Copy the contents and give control to CComVariant
            memmove(this, pSrc, sizeof(VARIANT));
            pSrc->vt = VT_EMPTY;
            hr = S_OK;
        }
        return hr;
    }

    HRESULT Detach(VARIANT* pDest)
    {
        // Clear out the variant
        HRESULT hr = ::VariantClear(pDest);
        if (!FAILED(hr))
        {
            // Copy the contents and remove control from CComVariant
            memmove(pDest, this, sizeof(VARIANT));
            vt = VT_EMPTY;
            hr = S_OK;
        }
        return hr;
    }

    HRESULT ChangeType(VARTYPE vtNew, const VARIANT* pSrc = NULL)
    {
        VARIANT* pVar = const_cast<VARIANT*>(pSrc);
        // Convert in place if pSrc is NULL
        if (pVar == NULL)
            pVar = this;
        // Do nothing if doing in place convert and vts not different
        return ::VariantChangeType(this, pVar, 0, vtNew);
    }

    HRESULT WriteToStream(IStream* pStream);
    HRESULT ReadFromStream(IStream* pStream);

// Implementation
public:
    HRESULT InternalClear()
    {
        HRESULT hr = Clear();
        ATLASSERT(SUCCEEDED(hr));
        if (FAILED(hr))
        {
            vt = VT_ERROR;
            scode = hr;
        }
        return hr;
    }

    void InternalCopy(const VARIANT* pSrc)
    {
        HRESULT hr = Copy(pSrc);
        if (FAILED(hr))
        {
            vt = VT_ERROR;
            scode = hr;
        }
    }

    std::string ToString()
    {
        std::stringstream oss;
        oss.str("");
        std::string lstring = "";
        switch (vt)
        {
            case VT_I4:
            {
                oss<<lVal;
                lstring = oss.str();
                break;
            }
            case VT_I2:
            {
                oss<<iVal;
                lstring = oss.str();
                break;
            }
            case VT_R8:
            {
                oss<<dblVal;
                lstring = oss.str();
                break;
            }
            case VT_BOOL:
            {
                if (boolVal==VARIANT_TRUE)
                    lstring = "1";
                else
                    lstring = "0";
                break;
            }
            case VT_BSTR:
            {
#ifndef __ANDROID__
                size_t size = wcslen(bstrVal);
                char* lpText = (char*)malloc(wcslen(bstrVal) + 1);
                wcstombs(lpText, bstrVal, size + 1);
#else
                size_t size = strlen(bstrVal);
                char* lpText = (char*)malloc(size+1);
                std::string lstrVal = bstrVal;
                strncpy(lpText, lstrVal.c_str(), size);
                //TODO:
                //int size = wcslen(bstrVal);
                //char* lpText = (char*)malloc(wcslen(bstrVal) + 1);
                //wcstombs(lpText, bstrVal, size + 1);
#endif
                lstring = lpText;
                free(lpText);//xiazhou, 969563, fix memory leak;
                break;
            }
            default:
                break;
        }
        return lstring;
    }
};

/* unfinished
inline HRESULT CComVariant::WriteToStream(IStream* pStream)
{
    HRESULT hr = pStream->Write(&vt, sizeof(VARTYPE), NULL);
    if (FAILED(hr))
        return hr;

    int cbWrite = 0;
    switch (vt)
    {
    case VT_UNKNOWN:
    case VT_DISPATCH:
        {
            CComPtr<IPersistStream> spStream;
            if (punkVal != NULL)
            {
                hr = punkVal->QueryInterface(IID_IPersistStream, (void**)&spStream);
                if (FAILED(hr))
                    return hr;
            }
            if (spStream != NULL)
                return OleSaveToStream(spStream, pStream);
            else
                return WriteClassStm(pStream, CLSID_NULL);
        }
    case VT_UI1:
    case VT_I1:
        cbWrite = sizeof(BYTE);
        break;
    case VT_I2:
    case VT_UI2:
    case VT_BOOL:
        cbWrite = sizeof(short);
        break;
    case VT_I4:
    case VT_UI4:
    case VT_R4:
    case VT_INT:
    case VT_UINT:
    case VT_ERROR:
        cbWrite = sizeof(long);
        break;
    case VT_R8:
    case VT_CY:
    case VT_DATE:
        cbWrite = sizeof(double);
        break;
    default:
        break;
    }
    if (cbWrite != 0)
        return pStream->Write((void*) &bVal, cbWrite, NULL);

    CComBSTR bstrWrite;
    CComVariant varBSTR;
    if (vt != VT_BSTR)
    {
        hr = VariantChangeType(&varBSTR, this, VARIANT_NOVALUEPROP, VT_BSTR);
        if (FAILED(hr))
            return hr;
        bstrWrite = varBSTR.bstrVal;
    }
    else
        bstrWrite = bstrVal;

    return bstrWrite.WriteToStream(pStream);
}

inline HRESULT CComVariant::ReadFromStream(IStream* pStream)
{
    ATLASSERT(pStream != NULL);
    HRESULT hr;
    hr = VariantClear(this);
    if (FAILED(hr))
        return hr;
    VARTYPE vtRead;
    hr = pStream->Read(&vtRead, sizeof(VARTYPE), NULL);
    if (hr == S_FALSE)
        hr = E_FAIL;
    if (FAILED(hr))
        return hr;

    vt = vtRead;
    int cbRead = 0;
    switch (vtRead)
    {
    case VT_UNKNOWN:
    case VT_DISPATCH:
        {
            punkVal = NULL;
            hr = OleLoadFromStream(pStream,
                (vtRead == VT_UNKNOWN) ? IID_IUnknown : IID_IDispatch,
                (void**)&punkVal);
            if (hr == REGDB_E_CLASSNOTREG)
                hr = S_OK;
            return S_OK;
        }
    case VT_UI1:
    case VT_I1:
        cbRead = sizeof(BYTE);
        break;
    case VT_I2:
    case VT_UI2:
    case VT_BOOL:
        cbRead = sizeof(short);
        break;
    case VT_I4:
    case VT_UI4:
    case VT_R4:
    case VT_INT:
    case VT_UINT:
    case VT_ERROR:
        cbRead = sizeof(long);
        break;
    case VT_R8:
    case VT_CY:
    case VT_DATE:
        cbRead = sizeof(double);
        break;
    default:
        break;
    }
    if (cbRead != 0)
    {
        hr = pStream->Read((void*) &bVal, cbRead, NULL);
        if (hr == S_FALSE)
            hr = E_FAIL;
        return hr;
    }
    CComBSTR bstrRead;

    hr = bstrRead.ReadFromStream(pStream);
    if (FAILED(hr))
        return hr;
    vt = VT_BSTR;
    bstrVal = bstrRead.Detach();
    if (vtRead != VT_BSTR)
        hr = ChangeType(vtRead);
    return hr;
}
*/

#endif /* _CCOMVARIANT_H_ */