AttributeField.h

#pragma once
#include "Variable.h"

namespace ParaEngine
{
    using namespace std;

    enum SIMPLE_SCHEMA
    {
        SCHEMA_RGB = 0,
        SCHEMA_FILE,
        SCHEMA_SCRIPT,
        SCHEMA_INTEGER,
        SCHEMA_FLOAT,
        SCHEMA_DIALOG,
    };

    class CAttributeField
    {
    public:
        CAttributeField();
        ~CAttributeField();
    public:
        union any_offset{
            void* ptr_fun;
            int offset_data;
        };
        any_offset m_offsetSetFunc;
        any_offset m_offsetGetFunc;

        
        DWORD       m_type;

        string      m_sSchematics;
        string      m_sHelpString;

    protected:
        string      m_sFieldname;
        /* hash of filed name, used to fast query*/
        size_t      m_hash;
    public:
        void SetFieldname(const string& sFieldname);

        const string& GetFieldname() const;

        size_t GetHash() const;

        static std::hash<string> HashFunc;
        const char* GetTypeAsString();

        inline bool HasGetFunction() { return (m_offsetGetFunc.ptr_fun != 0); }
        inline bool HasSetFunction() { return (m_offsetSetFunc.ptr_fun != 0); }

        inline HRESULT Call(void* obj)
        {
            if (m_offsetSetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj))m_offsetSetFunc.ptr_fun)(obj);
            else if (m_offsetGetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj))m_offsetSetFunc.ptr_fun)(obj);
            else
                return E_FAIL;
        };
        inline HRESULT Get(void* obj)
        {
            if (m_offsetGetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj))m_offsetSetFunc.ptr_fun)(obj);
            else
                return E_FAIL;
        };
        /* attention should be paid: alway explicitly pass the parameter type to the function. e.g. Set(obj, (bool)bValue)*/
        template <class datatype>
        inline HRESULT Set(void* obj, datatype p1)
        {
            if (m_offsetSetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, datatype p1))m_offsetSetFunc.ptr_fun)(obj, p1);
            else
                return E_FAIL;
        };
        // this ensure that Matrix4 is always passed by reference. when defining attribute, one should always use const Matrix4&
        inline HRESULT Set(void* obj, const Matrix4& p1)
        {
            if (m_offsetSetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, const Matrix4& p1))m_offsetSetFunc.ptr_fun)(obj, p1);
            else
                return E_FAIL;
        };
        template <class datatype>
        inline HRESULT Set(void* obj, datatype p1, datatype p2)
        {
            if (m_offsetSetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, datatype p1, datatype p2))m_offsetSetFunc.ptr_fun)(obj, p1, p2);
            else
                return E_FAIL;
        };
        template <class datatype>
        inline HRESULT Set(void* obj, datatype p1, datatype p2, datatype p3)
        {
            if (m_offsetSetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, datatype p1, datatype p2, datatype p3))m_offsetSetFunc.ptr_fun)(obj, p1, p2, p3);
            else
                return E_FAIL;
        };
        template <class datatype>
        inline HRESULT Set(void* obj, datatype p1, datatype p2, datatype p3, datatype p4)
        {
            if (m_offsetSetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, datatype p1, datatype p2, datatype p3, datatype p4))m_offsetSetFunc.ptr_fun)(obj, p1, p2, p3, p4);
            else
                return E_FAIL;
        };
        template <class datatype>
        inline HRESULT Get(void* obj, datatype* p1)
        {
            if (m_offsetGetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, datatype* p1))m_offsetGetFunc.ptr_fun)(obj, p1);
            else
                return E_FAIL;
        };
        template <class datatype>
        inline HRESULT Get(void* obj, datatype* p1, datatype* p2)
        {
            if (m_offsetGetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, datatype* p1, datatype* p2))m_offsetGetFunc.ptr_fun)(obj, p1, p2);
            else
                return E_FAIL;
        };
        template <class datatype>
        inline HRESULT Get(void* obj, datatype* p1, datatype* p2, datatype* p3)
        {
            if (m_offsetGetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, datatype* p1, datatype* p2, datatype* p3))m_offsetGetFunc.ptr_fun)(obj, p1, p2, p3);
            else
                return E_FAIL;
        };
        template <class datatype>
        inline HRESULT Get(void* obj, datatype* p1, datatype* p2, datatype* p3, datatype* p4)
        {
            if (m_offsetGetFunc.ptr_fun != 0)
                return ((HRESULT(*)(void* obj, datatype* p1, datatype* p2, datatype* p3, datatype* p4))m_offsetGetFunc.ptr_fun)(obj, p1, p2, p3, p4);
            else
                return E_FAIL;
        };
    public:
        static const char* GetSimpleSchema(SIMPLE_SCHEMA schema);
        static const char* GetSimpleSchemaOfRGB(){ return GetSimpleSchema(SCHEMA_RGB); };
        static const char* GetSimpleSchemaOfFile(){ return GetSimpleSchema(SCHEMA_FILE); };
        static const char* GetSimpleSchemaOfScript(){ return GetSimpleSchema(SCHEMA_SCRIPT); };
        static const char* GetSimpleSchemaOfInt(int nMin, int nMax);
        static const char* GetSimpleSchemaOfFloat(float nMin, float nMax);

        const char* GetSchematicsType();

        bool GetSchematicsMinMax(float& fMin, float& fMax);
    };
}