NPLTable.h

#pragma once
#include "util/intrusive_ptr.h"
#include <string>
#include <map>

#ifdef _MSC_VER
#pragma warning( push )
#pragma warning( disable:4275 )
#pragma warning( disable:4251 )
#endif

namespace NPL
{
    class NPLObjectBase;
    class NPLNumberObject;
    class NPLBoolObject;
    class NPLTable;
    class NPLStringObject;
    class NPLObjectProxy;
    typedef ParaIntrusivePtr<NPLObjectBase> NPLObjectBase_ptr;
    typedef ParaIntrusivePtr<NPLTable> NPLTable_ptr;
    typedef ParaIntrusivePtr<NPLNumberObject> NPLNumberObject_ptr;
    typedef ParaIntrusivePtr<NPLBoolObject> NPLBoolObject_ptr;
    typedef ParaIntrusivePtr<NPLStringObject> NPLStringObject_ptr;

    class PE_CORE_DECL NPLObjectBase : public ParaEngine::intrusive_ptr_single_thread_base
    {
    public:
        typedef std::map<std::string, NPLObjectProxy> TableFieldMap_Type;
        typedef std::map<int, NPLObjectProxy> TableIntFieldMap_Type;
        typedef TableFieldMap_Type::iterator    Iterator_Type;
        typedef TableIntFieldMap_Type::iterator IndexIterator_Type;

        enum NPLObjectType 
        {
            NPLObjectType_Nil, 
            NPLObjectType_Table, 
            NPLObjectType_Number, 
            NPLObjectType_String, 
            NPLObjectType_Bool,
        };
        NPLObjectBase():m_type(NPLObjectType_Nil){};
        virtual ~NPLObjectBase(){};

        inline NPLObjectType GetType(){return m_type;}

        bool isTable() { return GetType() == NPLObjectType_Table; }
        bool isNumber() { return GetType() == NPLObjectType_Number; }
        bool isString() { return GetType() == NPLObjectType_String; }
        bool isNil() { return GetType() == NPLObjectType_Nil; }
        bool isBool() { return GetType() == NPLObjectType_Bool; }

    protected:
        NPLObjectType m_type;
    };

    class PE_CORE_DECL NPLObjectProxy : public NPLObjectBase_ptr
    {
    public:
        NPLObjectProxy() {};
        NPLObjectProxy( NPLObjectBase* pObject);

        operator double ();

        void operator = (double value);

        operator bool ();

        void operator = (bool value);

        operator const string& ();
        const char* c_str();
        int toInt();

        bool operator == (const string& value);
        bool operator == (const char* value);

        void operator = (const std::string& value);
        void operator = (const char* value);

        NPLObjectProxy& operator [] (const string& sName);

        NPLObjectProxy& operator [] (const char* sName);

        NPLObjectProxy& operator [](int nIndex);

        NPLObjectProxy GetField(const string& sName);

        NPLObjectProxy GetField(const char* sName);

        
        void SetField(const string& sName, const NPLObjectProxy& pObject);

        void SetField(int nIndex, const NPLObjectProxy& pObject);

        void MakeNil();

        NPLObjectBase::Iterator_Type begin();
        NPLObjectBase::Iterator_Type end();

        NPLObjectBase::IndexIterator_Type index_begin();
        NPLObjectBase::IndexIterator_Type index_end();

        NPLObjectBase::NPLObjectType  GetType();
    };


    class PE_CORE_DECL NPLNumberObject : public NPLObjectBase
    {
    public:
        NPLNumberObject():m_value(0){m_type = NPLObjectType_Number;};
        NPLNumberObject(double value):m_value(value){m_type = NPLObjectType_Number;};

        virtual ~NPLNumberObject(){};

        void SetValue(double value){m_value = value;}
        double GetValue() {return m_value;}

        NPLNumberObject& operator = (double value) { SetValue(value); return *this;}

    private:
        double m_value;
    };


    class PE_CORE_DECL NPLBoolObject : public NPLObjectBase
    {
    public:
        NPLBoolObject():m_value(false){m_type = NPLObjectType_Bool;};
        NPLBoolObject(bool value):m_value(value){m_type = NPLObjectType_Bool;};

        virtual ~NPLBoolObject(){};

        inline void SetValue(bool value){m_value = value;}
        bool GetValue() {return m_value;}

        NPLBoolObject& operator = (bool value) { SetValue(value); return *this;}

    private:
        bool m_value;
    };


    class PE_CORE_DECL NPLStringObject : public NPLObjectBase
    {
    public:
        NPLStringObject(){m_type = NPLObjectType_String;};
        NPLStringObject(const std::string& value):m_value(value){m_type = NPLObjectType_String;};

        virtual ~NPLStringObject(){};

        void SetValue(const std::string& value){m_value = value;}
        std::string& GetValue(){return m_value;}

        NPLStringObject& operator = (const std::string& value) { SetValue(value); return *this;}

    private:
        std::string m_value;
    };


    class PE_CORE_DECL NPLTable : public NPLObjectBase
    {
    public:
        NPLTable(){m_type = NPLObjectType_Table;};

        virtual ~NPLTable();
    public:
        void ToString(std::string& str);

        void Clear();

        void SetField(const string& sName, const NPLObjectProxy& pObject);

        void SetField(int nIndex, const NPLObjectProxy& pObject);       

        NPLObjectProxy GetField(const string& sName);
        NPLObjectProxy GetField(int nIndex);

        NPLObjectProxy& CreateGetField(const string& sName);
        NPLObjectProxy& CreateGetField(int nIndex);

        Iterator_Type begin() {return m_fields.begin();}; 
        Iterator_Type end() {return m_fields.end();}; 

        IndexIterator_Type index_begin() { return m_index_fields.begin(); };
        IndexIterator_Type index_end() { return m_index_fields.end(); };

        NPLObjectProxy& operator [](const string& sName) {return CreateGetField(sName);};
        NPLObjectProxy& operator [](const char* sName) {return CreateGetField(sName);};
        NPLObjectProxy& operator [](int nIndex) {return CreateGetField(nIndex);};
    private:
        TableFieldMap_Type  m_fields;
        TableIntFieldMap_Type m_index_fields;
    };
}

// required by DLL interface
//EXPIMP_TEMPLATE template class PE_CORE_DECL ParaIntrusivePtr<NPL::NPLObjectBase>;
//EXPIMP_TEMPLATE template class PE_CORE_DECL ParaIntrusivePtr<NPL::NPLTable>;
//EXPIMP_TEMPLATE template class PE_CORE_DECL ParaIntrusivePtr<NPL::NPLNumberObject>;
//EXPIMP_TEMPLATE template class PE_CORE_DECL ParaIntrusivePtr<NPL::NPLBoolObject>;
//EXPIMP_TEMPLATE template class PE_CORE_DECL ParaIntrusivePtr<NPL::NPLStringObject>;

#ifdef _MSC_VER
#pragma warning( pop ) 
#endif