KviKvsVariant.h

Go to the documentation of this file.

#ifndef _KVI_KVS_VARIANT_H_
#define _KVI_KVS_VARIANT_H_
//=============================================================================
//
//   File : KviKvsVariant.h
//   Creation date : Tue 07 Oct 2003 04:01:19 by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2003-2010 Szymon Stefanek <pragma at kvirc dot net>
//
//   This program is FREE software. You can redistribute it and/or
//   modify it under the terms of the GNU General Public License
//   as published by the Free Software Foundation; either version 2
//   of the License, or (at your option) any later version.
//
//   This program is distributed in the HOPE that it will be USEFUL,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//   See the GNU General Public License for more details.
//
//   You should have received a copy of the GNU General Public License
//   along with this program. If not, write to the Free Software Foundation,
//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================

#include "kvi_settings.h"
#include "KviQString.h"
#include "KviHeapObject.h"
#include "KviKvsTypes.h"

class KviKvsVariant;
class KviKvsArrayCast;

// pre-declare.. the real declarations are included below
class KviKvsHash;
class KviKvsArray;

class KVIRC_API KviKvsNumber
{
        friend class KviKvsVariant;

public:
        enum Type
        {
                Real,   
                Integer 
        };

protected:
        union DataType {
                kvs_int_t iInt;
                kvs_real_t dReal;
        };

protected:
        Type m_type;
        DataType m_u;

public:
        Type type() const { return m_type; };

        bool isReal() const { return m_type == Real; };

        bool isInteger() const { return m_type == Integer; };

        kvs_real_t real() const { return m_u.dReal; };

        kvs_int_t integer() const { return m_u.iInt; };
};

class KviKvsVariantData
{
public:
        enum Type
        {
                Nothing = 0,  
                String = 1,   
                Integer = 2,  
                Real = 4,     
                Array = 8,    
                Hash = 16,    
                Boolean = 32, 
                HObject = 64  
        };

public:
        union DataType {
                kvs_int_t iInt;
                kvs_real_t * pReal;
                QString * pString;
                KviKvsArray * pArray;
                KviKvsHash * pHash;
                bool bBoolean;
                kvs_hobject_t hObject;
        };

public:
        unsigned int m_uRefs;
        Type m_eType;
        DataType m_u;
};

class KviKvsVariantComparison
{
public:
        enum Result
        {
                FirstGreater = -1, 
                Equal = 0,         
                SecondGreater = 1  
        };

public:
        static inline int compareIntString(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareIntReal(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareIntBool(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareIntHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareIntArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareIntHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareRealHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareRealString(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareRealBool(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareRealHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareRealArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareStringHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareStringArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareStringHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareBoolString(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareBoolHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareBoolArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareBoolHObject(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareArrayHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareHObjectHash(const KviKvsVariant * pV1, const KviKvsVariant * pV2);

        static inline int compareHObjectArray(const KviKvsVariant * pV1, const KviKvsVariant * pV2);
};

class KVIRC_API KviKvsVariant : public KviHeapObject
{
        friend class KviKvsVariantComparison;

public:
        KviKvsVariant();

        KviKvsVariant(const KviKvsVariant & variant);

        KviKvsVariant(const QString & szString, bool bEscape = false);

        KviKvsVariant(const char * pcString, bool bEscape = false);

        KviKvsVariant(QString * pszString, bool bEscape = false);

        KviKvsVariant(kvs_int_t iInteger, bool bEscape = false);

        KviKvsVariant(kvs_real_t dReal);

        KviKvsVariant(kvs_real_t * pReal);

        KviKvsVariant(bool bBoolean);

        KviKvsVariant(KviKvsArray * pArray);

        KviKvsVariant(KviKvsHash * pHash);

        KviKvsVariant(kvs_hobject_t hObject);

        ~KviKvsVariant();

protected:
        KviKvsVariantData * m_pData;

public:
        KviKvsVariantData::Type type() { return m_pData ? m_pData->m_eType : KviKvsVariantData::Nothing; };

        void setReal(kvs_real_t dReal);

        void setReal(kvs_real_t * pReal);

        void setInteger(kvs_int_t iInteger);

        void setString(const QString & szString);

        void setString(QString * pszString);

        void setArray(KviKvsArray * pArray);

        void setHash(KviKvsHash * pHash);

        void setBoolean(bool bBoolean);

        void setHObject(kvs_hobject_t hObject);

        void setNothing();

        void getTypeName(QString & szBuffer) const;

        bool isNothing() const { return !m_pData; };

        bool isInteger() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Integer) : false; };

        bool isReal() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Real) : false; };

        bool isNumeric() const { return m_pData ? (m_pData->m_eType & (KviKvsVariantData::Integer | KviKvsVariantData::Real)) : false; };

        bool isString() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::String) : false; };

        bool isScalar() const { return m_pData ? (m_pData->m_eType & (KviKvsVariantData::String | KviKvsVariantData::Integer | KviKvsVariantData::Real)) : false; };

        bool isArray() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Array) : false; };

        bool isHash() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Hash) : false; };

        bool isBoolean() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::Boolean) : false; };

        bool isHObject() const { return m_pData ? (m_pData->m_eType == KviKvsVariantData::HObject) : false; };

        bool isEmpty() const;

        bool isEqualToNothing() const;

        bool asInteger(kvs_int_t & iVal) const;

        bool asReal(kvs_real_t & dVal) const;

        bool asNumber(KviKvsNumber & n) const;

        bool asBoolean() const;

        bool asHObject(kvs_hobject_t & hObject) const;

        void asString(QString & szBuffer) const;

        void appendAsString(QString & szBuffer) const;

        void castToNumber(KviKvsNumber & number) const;

        void castToInteger(kvs_int_t & iVal) const;

        void castToArray(KviKvsArrayCast * pCast) const;

        void convertToArray();

        kvs_int_t integer() const { return m_pData ? m_pData->m_u.iInt : 0; };

        kvs_real_t real() const { return m_pData ? *(m_pData->m_u.pReal) : 0.0; };

        const QString & string() const { return m_pData ? *(m_pData->m_u.pString) : KviQString::Empty; };

        bool boolean() const { return m_pData ? m_pData->m_u.bBoolean : false; };

        KviKvsArray * array() const { return m_pData ? m_pData->m_u.pArray : 0; };

        KviKvsHash * hash() const { return m_pData ? m_pData->m_u.pHash : 0; };

        kvs_hobject_t hobject() const { return m_pData ? m_pData->m_u.hObject : (kvs_hobject_t)0; };

        void copyFrom(const KviKvsVariant * pVariant);

        void copyFrom(const KviKvsVariant & variant);

        void takeFrom(KviKvsVariant * pVariant);

        void takeFrom(KviKvsVariant & variant);

        void dump(const char * pcPrefix) const;

        int compare(const KviKvsVariant * pOther, bool bPreferNumeric = false) const;

        // JSON serialization
        void serialize(QString & szResult);

        static void serializeString(QString & szBuffer);

        static KviKvsVariant * unserialize(const QString & szBuffer);

        void operator=(const KviKvsVariant & variant) { copyFrom(variant); };
private:
        static KviKvsVariant * unserialize(const QChar ** ppAux);

        static KviKvsVariant * unserializeBool(const QChar ** ppAux, bool bBool);

        static KviKvsVariant * unserializeNull(const QChar ** ppAux);

        static KviKvsVariant * unserializeArray(const QChar ** ppAux);

        static KviKvsVariant * unserializeHash(const QChar ** ppAux);

        static void unserializeString(const QChar ** ppAux, QString & szBuffer);

        static KviKvsVariant * unserializeString(const QChar ** ppAux);

        static KviKvsVariant * unserializeNumber(const QChar ** ppAux);

        static KviKvsVariant * unserializeReal(const QChar ** ppAux, QString & szData);

        static KviKvsVariant * unserializeInteger(const QChar ** ppAux, QString & szData);
};

#include "KviKvsArray.h"
#include "KviKvsHash.h"

#endif // _KVI_KVS_VARIANT_H_