builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/a_utils/include/a_utils/core/variant.h

Go to the documentation of this file.

 
#ifndef _VARIANT_CLASS_HEADER_
#define _VARIANT_CLASS_HEADER_
 
namespace A_UTILS_NS
{
 
typedef enum : tUInt8
{
    VT_Empty   = 0,
    VT_Null    = 1,
    VT_Bool    = 2,
    VT_Int8    = 3,
    VT_UInt8   = 4,
    VT_Int16   = 5,
    VT_UInt16  = 6,
    VT_Int32   = 7,
    VT_UInt32  = 8,
    VT_Float32 = 9,
    VT_Float64 = 10,
    VT_String  = 11,
    VT_Int64   = 12,
    VT_UInt64  = 13,
 
    VT_Array   = 0x80
} tVariantType;
 
 
 
class DOEXPORT cVariant
{
    public:
        static const cVariant vEmpty;      
 
    protected:
        static const tUInt8 m_ui8Version;  
        tVariantType        m_Type;        
 
        union
        {
            tBool           bool_val;      
            tInt8           int8_val;      
            tUInt8          uint8_val;     
            tInt16          int16_val;     
            tUInt16         uint16_val;    
            tInt32          int32_val;     
            tUInt32         uint32_val;    
            tInt64          int64_val;     
            tUInt64         uint64_val;    
            tFloat32        float32_val;   
            tFloat64        float64_val;   
 
            tBool*          bool_array;    
            tInt8*          int8_array;    
            tUInt8*         uint8_array;   
            tInt16*         int16_array;   
            tUInt16*        uint16_array;  
            tInt32*         int32_array;   
            tUInt32*        uint32_array;  
            tInt64*         int64_array;   
            tUInt64*        uint64_array;  
            tFloat32*       float32_array; 
            tFloat64*       float64_array; 
        } m_Data;                          
 
        cString             m_strBuffer;   
        tSize               m_nArraySize;  
 
    public:
        cVariant();
 
        cVariant(const cVariant& oVariant);
 
        cVariant(tBool      Value);
        cVariant(tInt8      Value);
        cVariant(tUInt8     Value);
        cVariant(tInt16     Value);
        cVariant(tUInt16    Value);
        cVariant(tInt32     Value);
        cVariant(tUInt32    Value);
        cVariant(tInt64     Value);
        cVariant(tUInt64    Value);
        cVariant(tFloat32   Value);
        cVariant(tFloat64   Value);
        cVariant(const cString& Value);
        cVariant(const tChar* Value);
 
        virtual ~cVariant();
 
        tVoid Clear();
 
        tVariantType GetType() const;
 
        tSize GetArraySize() const;
 
        tVoid Set(const cVariant& oVariant);
 
        tVoid Set(tBool      Value);
        tVoid Set(tInt8      Value);
        tVoid Set(tUInt8     Value);
        tVoid Set(tInt16     Value);
        tVoid Set(tUInt16    Value);
        tVoid Set(tInt32     Value);
        tVoid Set(tUInt32    Value);
        tVoid Set(tInt64     Value);
        tVoid Set(tUInt64    Value);
        tVoid Set(tFloat32   Value);
        tVoid Set(tFloat64   Value);
        tVoid Set(const cString& Value);
        tVoid Set(const tChar* Value);
 
        tVoid Set(tInt8* pArray, tSize nSize);
        tVoid Set(tUInt8* pArray, tSize nSize);
        tVoid Set(tInt16* pArray, tSize nSize);
        tVoid Set(tUInt16* pArray, tSize nSize);
        tVoid Set(tInt32* pArray, tSize nSize);
        tVoid Set(tUInt32* pArray, tSize nSize);
        tVoid Set(tInt64* pArray, tSize nSize);
        tVoid Set(tUInt64* pArray, tSize nSize);
        tVoid Set(tFloat32*  pArray, tSize nSize);
        tVoid Set(tFloat64* pArray, tSize nSize);
 
        tBool    GetBool(tBool* pIsOk=nullptr) const;
        tInt8    GetInt8(tBool* pIsOk=nullptr) const;
        tUInt8   GetUInt8(tBool* pIsOk=nullptr) const;
        tInt16   GetInt16(tBool* pIsOk=nullptr) const;
        tUInt16  GetUInt16(tBool* pIsOk=nullptr) const;
        tInt32   GetInt32(tBool* pIsOk=nullptr) const;
        tUInt32  GetUInt32(tBool* pIsOk=nullptr) const;
        tInt64   GetInt64(tBool* pIsOk=nullptr) const;
        tUInt64  GetUInt64(tBool* pIsOk=nullptr) const;
        tInt     GetInt(tBool* pIsOk=nullptr) const;
        tUInt    GetUInt(tBool* pIsOk=nullptr) const;
        tFloat32 GetFloat32(tBool* pIsOk=nullptr) const;
        tFloat64 GetFloat64(tBool* pIsOk=nullptr) const;
        tFloat64 GetFloat(tBool* pIsOk=nullptr) const;
        const tChar* GetStringPtr(tBool* pIsOk=nullptr) const;
        cString  GetString(tBool* pIsOk=nullptr) const;
 
        tInt32   AsInt(tBool* pIsOk=nullptr) const;
 
        tFloat64 AsFloat(tBool* pIsOk=nullptr) const;
 
        cString  AsString(tBool* pIsOk=nullptr) const;
 
        const tBool*    GetBoolArray() const;
        const tInt8*    GetInt8Array() const;
        const tUInt8*   GetUInt8Array() const;
        const tInt16*   GetInt16Array() const;
        const tUInt16*  GetUInt16Array() const;
        const tInt32*   GetInt32Array() const;
        const tUInt32*  GetUInt32Array() const;
        const tInt64*   GetInt64Array() const;
        const tUInt64*  GetUInt64Array() const;
        const tInt*     GetIntArray() const;
        const tUInt*    GetUIntArray() const;
        const tFloat32* GetFloat32Array() const;
        const tFloat64* GetFloat64Array() const;
        tVoid*          GetArray() const;
 
        tBool IsArray() const;
 
        tBool IsInt() const;
 
 
        tBool IsFloat() const;
 
        tBool IsBool() const;
 
        tBool IsString() const;
 
        tBool IsIntArray() const;
 
        tBool IsFloatArray() const;
 
        tBool IsStringArray() const;
 
        tBool IsEmpty() const;
 
        operator tBool() const;
        operator tInt8() const;
        operator tUInt8() const;
        operator tInt16() const;
        operator tUInt16() const;
        operator tInt32() const;
        operator tUInt32() const;
        operator tInt64() const;
        operator tUInt64() const;
        operator tFloat32() const;
        operator tFloat64() const;
        operator const cString() const;
        operator const tChar*() const;
 
        cVariant& operator=(const cVariant& Value);
        cVariant& operator=(const tBool Value);
        cVariant& operator=(const tInt8 Value);
        cVariant& operator=(const tUInt8 Value);
        cVariant& operator=(const tInt16 Value);
        cVariant& operator=(const tUInt16 Value);
        cVariant& operator=(const tInt32 Value);
        cVariant& operator=(const tUInt32 Value);
        cVariant& operator=(const tInt64 Value);
        cVariant& operator=(const tUInt64 Value);
        cVariant& operator=(const tFloat32 Value);
        cVariant& operator=(const tFloat64 Value);
        cVariant& operator=(const cString& Value);
        cVariant& operator=(const tChar* Value);
 
        static tResult Serialize(cVariant& oVariant, tVoid* pWriteBuffer, tSize szSize, tSize* pszWriteSize=nullptr);
        static tResult Deserialize(cVariant& oVariant, tVoid* pReadBuffer, tSize szSize, tSize* pszReadSize=nullptr);
 
    protected:
        tVoid Initialize();
 
        tVoid Free();
};
 
bool operator==(const cVariant& a, const cVariant& b);
bool operator!=(const cVariant& a, const cVariant& b);
 
} // namespace A_UTILS_NS
 
#endif // _VARIANT_CLASS_HEADER_