cVariant.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cVariant_H
#define _INC_cVariant_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cVariantData.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/cArchive.h"
 
#ifdef _WIN32
struct tagVARIANT;
typedef tagVARIANT VARIANT;
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cVariant);
 
        class GRAYLIB_LINK cVariant : public cVariantData
        {
 
                typedef cVariantData SUPER_t;
                typedef cVariant THIS_t;
 
        public:
                static const cVariant k_VarNULL;        
 
        protected:
                VARTYPE_TYPE m_eVarType;        
 
        protected:
                // Helper functions.
                void InitVar(const cVariant& vVar);
                void InitVar(VARTYPE_TYPE eVarType, const void* pStr, size_t iLen);
                void EmptyLast();
 
                const cStringA& ref_StrA() const;
 
        public:
                cVariant() noexcept
                        : m_eVarType(VARTYPE_NoType)    
                {
                        // default = null.
                }
 
                cVariant(const ATOMCHAR_t** ppArrayArgs, ITERATE_t iArgQty);
                cVariant(const cVariantArray& aVals);
                cVariant(const cVariantArrayT& aVals);
                cVariant(const cAtomRef& atomVal);
                cVariant(const cStringA& strAVal);
                cVariant(const cStringW& strWVal);
                cVariant(const char* pszVal);   
                cVariant(const wchar_t* pwsVal);        
                cVariant(const cTimeInt& timei);
                cVariant(const cTimeDouble& timed);
                cVariant(const GUID& guid);
                cVariant(const cVarMap& rMap);
                cVariant(cVariantMap* pMap);
                cVariant(IXObject* pXObj);
 
                // Construct any basic type.
#define CTYPE_DEF(a,_TYPE,c,d,e,f,g,h)  cVariant( _TYPE bVal );
#include "GrayCore/include/cTypes.tbl"
#undef CTYPE_DEF
 
                cVariant(VARTYPE_TYPE eVarType, UINT32 uVal)
                {
                        ASSERT(eVarType == VARTYPE_UID || eVarType == VARTYPE_Color || eVarType == VARTYPE_HResult || eVarType == VARTYPE_TimeInt);
                        InitVar(eVarType, &uVal, sizeof(uVal));
                }
                cVariant(VARTYPE_TYPE eVarType, UINT64 uVal)
                {
                        InitVar(eVarType, &uVal, sizeof(uVal));
                }
                cVariant(VARTYPE_TYPE eVarType, const void* pvData, size_t nLen = 0)
                {
                        InitVar(eVarType, pvData, nLen);
                }
                cVariant(const THIS_t& vVal)
                {
                        InitVar(vVal);
                }
                cVariant(THIS_t&& ref) noexcept
                {
                        m_eVarType = ref.m_eVarType;
                        m_u = ref.m_u;  // memcpy()
                        ref.m_eVarType = VARTYPE_NoType;        // Clear source.
                }
 
                ~cVariant()
                {
                        SetNoType();    // should just use EmptyLast() but clear type just to be safe.
                }
 
                size_t GetHeapStats(OUT ITERATE_t& iAllocCount) const;
 
                VARTYPE_TYPE get_VarType() const noexcept
                {
                        return m_eVarType;
                }
                const cVariantTypeDef& get_VarTypeDef() const noexcept
                {
                        return GetVarTypeDef(m_eVarType);
                }
 
                bool isNoType() const noexcept
                {
                        return m_eVarType == VARTYPE_NoType ;
                }
                bool isVarTypeNumeric() const noexcept
                {
                        return get_VarTypeDef().isNumeric();
                }
                bool isVarTypeFloat() const noexcept
                {
                        return get_VarTypeDef().isFloat();
                }
                bool isVarTypeString() const noexcept
                {
                        return get_VarTypeDef().isString();
                }
 
                bool isNumSigned() const noexcept
                {
                        return get_VarTypeDef().isNumSigned();
                }
                bool isStringA() const noexcept 
                {
                        return get_VarTypeDef().isStringA();
                }
                bool isStringW() const noexcept 
                {
                        return get_VarTypeDef().isStringW();
                }
                bool isTime() const     noexcept        
                {
                        return get_VarTypeDef().isTime();
                }
 
                bool isArray() const noexcept
                {
                        return m_eVarType == VARTYPE_Array || m_eVarType == VARTYPE_ArrayT ;
                }
                bool isStringExp() const noexcept
                {
                        return m_eVarType == VARTYPE_StringExp ;
                }
                bool isXObj() const noexcept
                {
                        return IsXObj(m_eVarType) ;
                }
                bool isHResult() const noexcept
                {
                        return m_eVarType == VARTYPE_HResult ;
                }
 
                size_t get_DataSize() const;
                const void* get_DataPtr() const;
 
                COMPARE_t Compare(const cVariant& vVar) const;
                bool IsEqualTo(const THIS_t& vVar) const
                {
                        return(!Compare(vVar));
                }
                bool operator == (const THIS_t& vVar) const
                {
                        return(!Compare(vVar));
                }
                bool operator != (const THIS_t& vVar) const
                {
                        return(Compare(vVar));
                }
 
                bool isHResultError() const
                {
                        if (!isHResult())
                                return false;
                        return FAILED(m_u.m_HResult);
                }
                bool isEmptyVar() const;        
                bool isZeroVar() const;         
                void SetZeroVar(VARTYPE_TYPE eVarType = VARTYPE_NoType); 
 
                void SetNoType()
                {
                        EmptyLast();
                        m_eVarType = VARTYPE_NoType;
                }
                void SetClear()
                {
                        SetNoType();
                }
 
                void put_Var(const cVariant& vVar);
                void SetVarData(VARTYPE_TYPE eVarType, const void* pData, size_t iLen);
                bool SetVarType(VARTYPE_TYPE eVarType, const cVariant& vVal);
 
                // define getters and setters.
#define VARIANT_DEF(a,b,c) b get_##a() const;  \
        void put_##a( c x );
 
                VARIANT_DEF(StrCA, const char*, const char*);                   
                VARIANT_DEF(StrCW, const wchar_t*, const wchar_t*);     
                VARIANT_DEF(StrC, const GChar_t*, const GChar_t*);      // TCHAR GChar_t
                VARIANT_DEF(Atom, cAtomRef, cAtomRef);
                VARIANT_DEF(Str, cString, cString);     // TCHAR GChar_t
                VARIANT_DEF(StrA, cStringA, cStringA);
                VARIANT_DEF(StrW, cStringW, cStringW);
                VARIANT_DEF(StrExp, cStringA, cStringA);
                VARIANT_DEF(TimeDouble, double, double);
                VARIANT_DEF(TimeInt, TIMESEC_t, TIMESEC_t);
                VARIANT_DEF(CYS, CYS_t, CYS_t);
                VARIANT_DEF(CY, CY_t, CY_t);
                VARIANT_DEF(UID, UID_t, UID_t);
                VARIANT_DEF(HResult, HRESULT, HRESULT);
                VARIANT_DEF(Color, COLORREF, COLORREF);
                VARIANT_DEF(Vector3, cVariantVector3<float>, const float*);     // TODO: rename this Vector3f ??
                // put_Map, get_Map ??
 
#define CTYPE_DEF(a,_TYPE,c,d,e,f,g,h) _TYPE get_##a() const;  \
        void put_##a( _TYPE x );
#include "GrayCore/include/cTypes.tbl"
#undef CTYPE_DEF
 
#undef VARIANT_DEF
 
                inline void put_Int(int nVal)
                {
                        put_Int32(nVal);
                }
                inline int get_Int() const
                {
                        return get_Int32();
                }
 
#ifdef USE_LONG_AS_INT64
                void put_Long(signed long iVal );
                signed long get_Long() const;
                void put_ULong( unsigned long uVal );
                unsigned long get_ULong() const;
#endif
 
                template<typename _TYPE_CH>
                inline cStringT<_TYPE_CH> get_StrT() const;
 
                void put_UID(const IXObject* pXObj);
                void put_Array(const cVariantArray& aVars);
                void put_ArrayT(const cVariantArrayT& aVals);
                void put_Vector3(float x, float y, float z);
                IXObject* get_XObj() const;
                void put_XObj(IXObject* pXObj);
 
                void SetTimeIntNow();
                void SetTimeDoubleNow();
 
                void StrExpIgnore();    
                void SetVarTypeSimplest(bool bKeepFloat );
 
                HRESULT put_StrExpUnk(const ATOMCHAR_t* pStrExp);       
#ifdef USE_EXPRESSION
                HRESULT put_StrExpEval(const ATOMCHAR_t* pStrExp);
                cVariant get_VarExpEval() const;
#endif
                StrLen_t GetStrExpUnk(ATOMCHAR_t* pszStr, StrLen_t iLenMax, bool bInArray = false) const
                {
                        return SUPER_t::GetStrExpT(m_eVarType, pszStr, iLenMax, bInArray);
                }
 
                CY_t GetCY(bool bAssumeNaked = false, CY_t uValMul = k_CYMul) const;
 
                void SetBlobData(const void* pData, size_t nSize, VARTYPE_TYPE eVarType = VARTYPE_Blob);        // or VARTYPE_GUID
                void put_Blob(const cHeapBlock& b, VARTYPE_TYPE eVarType = VARTYPE_Blob)
                {
                        SetBlobData(b.get_Data(), b.get_DataSize(), eVarType);
                }
                size_t GetBlobData(void* pData, size_t nSizeMax) const;
                size_t SetBlobStr(VARTYPE_TYPE eVarType, const ATOMCHAR_t* pszStr);
                cHeapBlock& MakeRefBlob(VARTYPE_TYPE eVarType);
 
#define VARIANT_OP(a,b,c)  operator b() const { return( get_##a()); } \
        const THIS_t& operator=( c x ) { put_##a( x ); return *this; }
 
                VARIANT_OP(StrCA, const char*, const char*);
                VARIANT_OP(StrCW, const wchar_t*, const wchar_t*);
                VARIANT_OP(StrA, cStringA, const cStringA&);
                VARIANT_OP(StrW, cStringW, const cStringW&);
 
#define CTYPE_DEF(a,_TYPE,c,d,e,f,g,h)  VARIANT_OP(a,_TYPE,_TYPE)
#include "GrayCore/include/cTypes.tbl"
#undef CTYPE_DEF
 
#undef VARIANT_OP
 
                const THIS_t& operator=(const THIS_t& vVal)
                {
                        put_Var(vVal);
                        return *this;
                }
 
                void SetMove(THIS_t& ref)
                {
                        m_eVarType = ref.m_eVarType;
                        m_u = ref.m_u;  // ::memcpy()
                        ref.m_eVarType = VARTYPE_NoType;
                }
 
                THIS_t& operator = (THIS_t&& ref)
                {
                        SetMove(ref);
                        return *this;
                }
 
                void put_Map(cVariantMap* pMap);
                const cVariant& GetMapVar(const ATOMCHAR_t* pszName) const;
                cVariantMapPtr MakeMap();
                cVariant& MakeMapVar(const ATOMCHAR_t* pszName);
                HRESULT SetMapVar(const ATOMCHAR_t* pszName, const cVariant& vSet);
                const THIS_t& operator[](const ATOMCHAR_t* pszName) const
                {
                        return GetMapVar(pszName);
                }
                THIS_t& operator[](const ATOMCHAR_t* pszName)
                {
                        return MakeMapVar(pszName);
                }
 
                ITERATE_t get_ArraySize() const;
                ITERATE_t MakeArraySize(bool bBreakQuotes = false);     
                THIS_t& MakeArrayElement(ITERATE_t index = k_ITERATE_BAD);
                cVariantArray& MakeArray();
 
                bool IsArrayChild(const cVariant& vVal) const;
                ITERATE_t SetArray(const ATOMCHAR_t** ppArgs, ITERATE_t iArgQty, ITERATE_t nQtyAppend = 0);
                ITERATE_t SetArrayParse(const ATOMCHAR_t* pszStr);
 
                void RemoveArrayElement(ITERATE_t index, ITERATE_t iQty = 1);
                bool InsertArrayElement(ITERATE_t index, const cVariant& vVal);
                double get_ArrayRangeDouble() const;
 
                ITERATE_t AppendArray(cVariant& vValArray );    // Parse also !
 
                const THIS_t& GetArrayElement(ITERATE_t index) const;
                const THIS_t& operator[](ITERATE_t index) const
                {
                        return GetArrayElement(index);
                }
 
                bool SetArrayElement(ITERATE_t index, const cVariant& vVal);
                void AddArrayElement(const THIS_t& vVal)
                {
                        MakeArrayElement(k_ITERATE_BAD).put_Var(vVal);
                }
                THIS_t& operator[](ITERATE_t index)
                {
                        return MakeArrayElement(index);
                }
 
#if 1
 
                // _TYPE GetArray##_NAME( ITERATE_t index ) const { return( GetArrayElement(index).get_##_NAME()); }
                        
#define VARIANT_ARRAY_TYPE(_NAME,_TYPE) \
        void SetArray##_NAME( ITERATE_t index, _TYPE Val ) { MakeArrayElement(index).put_##_NAME(Val); } \
        void AddArray##_NAME( _TYPE Val ) { MakeArrayElement(k_ITERATE_BAD).put_##_NAME(Val); }
 
                VARIANT_ARRAY_TYPE(StrCA, const char*)
                VARIANT_ARRAY_TYPE(StrCW, const wchar_t*)
                VARIANT_ARRAY_TYPE(StrC, const GChar_t*)
                VARIANT_ARRAY_TYPE(Atom, cAtomRef)
                VARIANT_ARRAY_TYPE(Str, cString)
                VARIANT_ARRAY_TYPE(StrA, cStringA)
                VARIANT_ARRAY_TYPE(StrW, cStringW)
                VARIANT_ARRAY_TYPE(StrExp, cStringA)
                VARIANT_ARRAY_TYPE(UID, UID_t)
                VARIANT_ARRAY_TYPE(TimeInt, TIMESEC_t)
                VARIANT_ARRAY_TYPE(Vector3, const float*)
                VARIANT_ARRAY_TYPE(Int, int)
                VARIANT_ARRAY_TYPE(XObj, IXObject*)
 
#define CTYPE_DEF(a,_TYPE,c,d,e,f,g,h)  VARIANT_ARRAY_TYPE(a,_TYPE)
#include "GrayCore/include/cTypes.tbl"
#undef CTYPE_DEF
 
#undef VARIANT_ARRAY_TYPE
#endif
 
                void AddArrayUID(const IXObject* pObj)
                {
                        MakeArrayElement(k_ITERATE_BAD).put_UID(pObj);
                }
 
                HRESULT SerializeOutput(cStreamOutput& file) const;
                HRESULT SerializeInputType(cStreamInput& file, VARTYPE_TYPE eVarType);
                HRESULT SerializeInput(cStreamInput& file);
                HRESULT Serialize(cArchive& a);
 
                static bool GRAYCALL v_Var2Strings(cArrayStringA& a, cVariant& vVal);
                static void GRAYCALL v_Strings2Var(cVariant& vVal, const cArrayStringA& a);
 
#ifdef _WIN32
                static HRESULT GRAYCALL CvtWin2Var(const VARIANT& src, cVariant& dst);
                static HRESULT GRAYCALL CvtVar2Win(const cVariant& src, VARIANT& dst);
                HRESULT put_VARIANT(const VARIANT& var);        
                HRESULT get_VARIANT(VARIANT& var);      
#endif
 
                UNITTEST_FRIEND(cVariant);
        };
 
        template<> inline cStringT<char> cVariant::get_StrT<char>() const
        {
                return get_StrA();
        }
        template<> inline cStringT<wchar_t> cVariant::get_StrT<wchar_t>() const
        {
                return get_StrW();
        }
};
#endif // _INC_cVariant_H