StdVariant.h

Go to the documentation of this file.

#pragma once

namespace StdUtils
{
enum StdVariantType
{
        StdVtEmpty = -1,
        StdVtShort = 0,
        StdVtLong = 1,
        StdVtFloat = 2,
        StdVtDouble = 3,
        StdVtBool = 4,
        StdVtChar = 5,
        StdVtUChar = 6,
        StdVtUShort = 7,
        StdVtULong = 8,
        StdVtInt = 9,
        StdVtUInt = 10,
        StdVtString = 11
};

class STD_UTILS_PORT CStdVariant : public CStdSerialize  
{
protected:
        bool m_bCreatedVar;

        int m_iVariantType;

        short *m_lpShort;                                                       

        long *m_lpLong; 

        float *m_lpFloat;       

        double *m_lpDouble;     

        bool *m_lpBool;

        char *m_lpChar;         

        unsigned char *m_lpUChar;

        unsigned short *m_lpUShort;

        unsigned long *m_lpULong;                       

        int *m_lpInt;

        unsigned int *m_lpUInt;                         

        std::string *m_lpString;                                                

public:
        CStdVariant();
        virtual ~CStdVariant();

        void Reset();
        int VariantType();
        std::string VariantTypeName();

        short GetShort(bool bConvert = true);
        short *GetShortPtr();
        void SetValue(short Val);
        void SetPtr(short *lpVal);

        long GetLong(bool bConvert = true);
        long *GetLongPtr();
        void SetValue(long Val);
        void SetPtr(long *lpVal);

        float GetFloat(bool bConvert = true);
        float *GetFloatPtr();
        void SetValue(float Val);
        void SetPtr(float *lpVal);

        double GetDouble(bool bConvert = true);
        double *GetDoublePtr();
        void SetValue(double Val);
        void SetPtr(double *lpVal);

        bool GetBool(bool bConvert = true);
        bool *GetBoolPtr();
        void SetValue(bool Val);
        void SetPtr(bool *lpVal);

        char GetChar(bool bConvert = true);
        char *GetCharPtr();
        void SetValue(char Val);
        void SetPtr(char *lpVal);

        unsigned char GetUChar(bool bConvert = true);
        unsigned char *GetUCharPtr();
        void SetValue(unsigned char Val);
        void SetPtr(unsigned char *lpVal);

        unsigned short GetUShort(bool bConvert = true);
        unsigned short *GetUShortPtr();
        void SetValue(unsigned short Val);
        void SetPtr(unsigned short *lpVal);

        unsigned long GetULong(bool bConvert = true);
        unsigned long *GetULongPtr();
        void SetValue(unsigned long Val);
        void SetPtr(unsigned long *lpVal);

        int GetInt(bool bConvert = true);
        int *GetIntPtr();
        void SetValue(int Val);
        void SetPtr(int *lpVal);

        unsigned int GetUInt(bool bConvert = true);
        unsigned int *GetUIntPtr();
        void SetValue(unsigned int Val);
        void SetPtr(unsigned int *lpVal);

        std::string GetString(bool bConvert = true);
        std::string GetNumericString();
        std::string *GetStringPtr();
        void SetValue(std::string Val);
        void SetPtr(std::string *lpVal);

        void Copy(CStdVariant &oVar);
        void operator=(CStdVariant &oVar);

        //CStdSerialize overloads
        virtual CStdSerialize *Clone();
        virtual void Trace(std::ostream &oOs);
        virtual void Load(CStdXml &oXml);
        virtual void Save(CStdXml &oXml);
};

}                               //StdUtils