cVariantData.h

Go to the documentation of this file.

//
 
#ifndef _INC_cVariantData_H
#define _INC_cVariantData_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cVariantType.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cAtom.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cIUnkPtr.h"
#include "GrayCore/include/cTimeInt.h"  // just predefine this? class Gray::cTimeInt;
#include "GrayCore/include/cTimeDouble.h"       // just predefine this? class Gray::cTimeDouble;
#include "GrayCore/include/cArrayString.h"
 
#ifndef _WIN32
typedef UINT32 COLORREF;        
#endif
 
namespace GrayLib
{
        struct IXObject;
        typedef cIUnkPtr<IXObject> CIXObjPtr;
        DECLARE_INTERFACE(IXObjMgr);
        typedef UINT32 UID_t;   // Sort of the same as a HASHCODE_t. cUID
        class cVarMap;
        class cVariantMap;
        typedef cRefPtr<cVariantMap> cVariantMapPtr;
        class cVariantData;
        class cVariant;
 
        struct GRAYLIB_LINK cVariantCommon      // static
        {
 
                static const ITERATE_t k_MaxElements = 64*1024; 
                static const ITERATE_t k_MaxElements2 = 256;    
 
                typedef INT32 CYS_t;    
                typedef INT64 CY_t;             
 
                static const CYS_t k_CYSMul = 100;      
                static const CY_t k_CYMul = 10000;      
 
                static StrLen_t GRAYCALL CopyLenQ(ATOMCHAR_t* pszDst, const ATOMCHAR_t* pszSrc, StrLen_t iLenMax, STR_BLOCK_TYPE eBlock);
        };
 
#pragma pack(push, 4)   // must be packed in known format.
 
        class GRAYLIB_LINK CATTR_PACKED cVariantArray : public cArrayStruct<cVariant>, public cVariantCommon
        {
                typedef cArrayStruct<cVariant> SUPER_t;
        public:
                cVariantArray(ITERATE_t iSize = 0)
                        : cArrayStruct<cVariant>(iSize)
                {
                        ASSERT(IS_INDEX_GOOD(iSize,k_MaxElements));
                }
                cVariantArray(const SUPER_t& a)
                        : cArrayStruct<cVariant>(a)
                {
                }
 
                size_t get_DataSize() const;
                HRESULT SerializeOutput(cStreamOutput& file) const;
                HRESULT SerializeInput2(cStreamInput& file);
                COMPARE_t Compare(const cVariantArray& aVals) const;
 
                const cVariant& GetArrayElement(ITERATE_t index) const;
        };
 
        class GRAYLIB_LINK CATTR_PACKED cVariantArrayT : private cHeapBlock, public cVariantCommon
        {
 
                typedef cHeapBlock SUPER_t;
 
        private:
                ITERATE_t m_nQty;                       
                BYTE m_eVarTypeElem;            
 
        public:
                cVariantArrayT(ITERATE_t iSize, VARTYPE_TYPE eVarTypeElem);
                cVariantArrayT(const cVariantArrayT& a);
                ~cVariantArrayT();
 
                ITERATE_t GetSize() const
                {
                        return m_nQty;
                }
                VARTYPE_TYPE get_VarTypeElem() const
                {
                        return (VARTYPE_TYPE)m_eVarTypeElem;
                }
                cVariantData* GetElemPtr(ITERATE_t i) const;
                size_t get_DataSize() const;
 
                size_t GetHeapStats(OUT ITERATE_t& iAllocCount) const
                {
                        return SUPER_t::GetHeapStats(iAllocCount);
                }
                HRESULT SerializeOutput(cStreamOutput& file) const;
                HRESULT SerializeInput2(cStreamInput& file);
        };
 
        template< class _TYPE = float >
        class CATTR_PACKED cVariantVector3
        {
        public:
                _TYPE m_v[3];
 
        public:
                operator _TYPE*()
                {
                        return m_v;
                }
                operator const _TYPE*() const
                {
                        return m_v;
                }
        };
 
        template<class _TYPE>
        struct CATTR_PACKED cVariantStub
        {
                BYTE m_data[sizeof(_TYPE)];
        };
 
        class CATTR_PACKED GRAYLIB_LINK cVariantData : public cVariantCommon
        {
 
                friend class cVariantArrayT;
 
        public:
                union // of cVariantStub
                {
#define cVariantTypeDEF(a,b,c,d,e,f) c m_##a;   
#include "cVariantTypes.tbl"
#undef cVariantTypeDEF
                } m_u;
 
                static const cVariantTypeDef k_VarTypeDef[VARTYPE_QTY]; 
 
                static IXObjMgr* sm_pIXObjMgr;          
                static bool sm_bShowUnsignedAsHex;      
 
        protected:
                void DestructData(VARTYPE_TYPE eVarType);
                void construct_Array(ITERATE_t iSize);
                void construct_Array(const cVariantArray& a);
                void construct_ArrayT(ITERATE_t iSize, VARTYPE_TYPE eVarTypeElem);
                void construct_ArrayT(const cVariantArrayT& a);
                void construct_Atom(const cAtomRef& a);
                void construct_Atom(const ATOMCHAR_t* p);
                void construct_String(const cStringA& s);
                void construct_String(const char* pszVal);
                void construct_StringW(const cStringW& s);
                void construct_StringW(const wchar_t* pwVal);
                void construct_Blob(const void* pData, size_t nSize);
                void construct_Blob(const cHeapBlock& b);
                void construct_Map(cVariantMap* p);
                void construct_XObj(IXObject* p);
 
                size_t GetDataSize(VARTYPE_TYPE eVarType) const;
                const void* GetDataPtr(VARTYPE_TYPE eVarType) const;
                size_t GetHeapStats(VARTYPE_TYPE eVarType, OUT ITERATE_t& iAllocCount) const;
 
                bool IsEmptyVar(VARTYPE_TYPE eVarType) const;
                bool IsZeroVar(VARTYPE_TYPE eVarType) const;
                void InitZeroVar(VARTYPE_TYPE eVarType);
                void InitVar(VARTYPE_TYPE eVarType, const cVariantData& vVal);
 
                StrLen_t GetStr_Array(ATOMCHAR_t* pszStr, StrLen_t iLenMax) const;
                StrLen_t GetStr_ArrayT(ATOMCHAR_t* pszStr, StrLen_t iLenMax) const;
                StrLen_t GetStr_CY(ATOMCHAR_t* pszStr, StrLen_t iLenMax) const;
                StrLen_t GetStr_CYS(ATOMCHAR_t* pszStr, StrLen_t iLenMax) const;
                StrLen_t GetStr_Blob(ATOMCHAR_t* pszStr, StrLen_t nLenMax) const;
                StrLen_t GetStr_HResult(ATOMCHAR_t* pszStr, StrLen_t iLenMax, bool bQuote = true) const;
 
                StrLen_t GetStrExpT(VARTYPE_TYPE eVarType, ATOMCHAR_t* pszStr, StrLen_t iLenMax, bool bInArray = true) const;
 
        public:
                static inline const cVariantTypeDef& GetVarTypeDef(VARTYPE_TYPE eVarType) noexcept
                {
                        if (IS_INDEX_BAD(eVarType, VARTYPE_QTY))
                        {
                                DEBUG_CHECK(false);
                                eVarType = VARTYPE_NoType;
                        }
                        return k_VarTypeDef[eVarType];
                }
                static bool GRAYCALL IsVarTypeCompatible(VARTYPE_TYPE eVarType1, VARTYPE_TYPE eVarType2);
                static COMPARE_t GRAYCALL CompareDataPtr(VARTYPE_TYPE eVarType, const void* pData1, const void* pData2);
 
                static inline bool IsXObj(VARTYPE_TYPE eVarType) noexcept
                {
                        return eVarType == VARTYPE_XObj || eVarType == VARTYPE_UID ;
                }
 
                // ASSUME we know type.
                cVariantArray& dref_Array() const;      // AKA AsArray ??
                cVariantArrayT& dref_ArrayT() const;
                const cAtomRef& dref_Atom() const;
                const cStringA& dref_String() const;
                const cStringW& dref_StringW() const;
                cHeapBlock& dref_Blob() const;
                cVariantMapPtr& dref_Map() const;
                CIXObjPtr& dref_XObj() const;
 
                HRESULT SerializeOutputType(cStreamOutput& file, VARTYPE_TYPE eVarType) const;
                HRESULT SerializeInputType(cStreamInput& file, VARTYPE_TYPE eVarType);
        };
 
#pragma pack(pop)
 
}
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
namespace Gray
{
        template class CArray<GrayLib::cVariant, const GrayLib::cVariant&>;
        template class cArrayTyped<GrayLib::cVariant, const GrayLib::cVariant&>;
}
#endif
 
#endif