cScriptableInterface.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cScriptableInterface_H
#define _INC_cScriptableInterface_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "../Auth/PrivLevel.h"  // PLEVEL_TYPE
#include "../Misc/cStructElem.h"
#include "../Variant/cVariant.h"
 
#include "GrayCore/include/cArraySort.h"
#include "GrayCore/include/cAtom.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cSingleton.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/cLogMgr.h"
#include "GrayCore/include/cTypeInfo.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cScriptableInterface);
 
        // predefine these
        class GRAYLIB_LINK cScriptContext;
        class GRAYLIB_LINK cScriptableInterfaceDef;
        typedef cScriptableInterfaceDef* cScriptableInterfaceDefPtr;
 
        typedef BYTE SCRIPTINTERFACEID_t;       
        const SCRIPTINTERFACEID_t SCRIPTINTERFACEID_MAX = 0xFF; // max number of interfaces defined in the system.
        typedef BYTE SCRIPTPROPID_t;            
        const SCRIPTPROPID_t SCRIPTPROPINDEX_MAX = 0xFF;        // max number of properties or methods per object.
 
        enum XOBJ_DUMP_MASK_
        {
                XOBJ_DUMP_NAME = 0x01,
                XOBJ_DUMP_VALUE = 0x02,
                XOBJ_DUMP_HELP = 0x04,
                XOBJ_DUMP_FLAGS = 0x08,
                XOBJ_DUMP_INTERFACE = 0x10,     
                XOBJ_DUMP_UNUSED = 0x20,        
        };
        typedef UINT XOBJ_DUMP_MASK_t;  
 
        typedef WORD CSCRIPTPROP_MASK_t;
        enum CSCRIPTPROP_MASK_
        {
                CSCRIPTPROP_DEFAULT = 0,                
 
                CSCRIPTPROP_RETNUL = 0x0000,    
                CSCRIPTPROP_RETVAL = 0x0020,    
                CSCRIPTPROP_RETREF = 0x0040,    
                CSCRIPTPROP_EXTPROP = 0x0080,   
 
                CSCRIPTPROPP_READO = 0x0100,   
                CSCRIPTPROP_NARGS = 0x0100,     
                CSCRIPTPROPP_WRITEO = 0x0200,   
                CSCRIPTPROP_ARG1S = 0x0401,     
                CSCRIPTPROPM_DISPAT = 0x0800,   
                CSCRIPTPROPP_NOPRIV = 0x0800,   
 
                CSCRIPTPROP_UNUSED = 0x1000,    
                CSCRIPTPROP_DUPE = 0x2000,      
 
                CSCRIPTPROPP_TEMP = 0x4000,     
                CSCRIPTPROPP_KEY = 0x0010,      
                CSCRIPTPROPI_STATIC = 0x4000,   
                CSCRIPTPROPI_PRIVNAME = 0x8000, 
                CSCRIPTPROPM_DELETE = 0x4000,   
                CSCRIPTPROPM_FUNC = 0x8000,     
 
                CSCRIPTPROP_ARG1 = 0x0001,      
                CSCRIPTPROP_ARG2 = 0x0002,
                CSCRIPTPROP_ARG3 = 0x0003,
                CSCRIPTPROP_ARG4 = 0x0004,
                CSCRIPTPROP_ARG5 = 0x0005,
                CSCRIPTPROP_ARGS_MASK = 0x000F,
 
                CSCRIPTPROP_NARG1 = CSCRIPTPROP_NARGS | CSCRIPTPROP_ARG1, 
                CSCRIPTPROP_NARG2 = CSCRIPTPROP_NARGS | CSCRIPTPROP_ARG2,
                CSCRIPTPROP_NARG3 = CSCRIPTPROP_NARGS | CSCRIPTPROP_ARG3,
                CSCRIPTPROP_NARG4 = CSCRIPTPROP_NARGS | CSCRIPTPROP_ARG4,
                CSCRIPTPROP_NARG5 = CSCRIPTPROP_NARGS | CSCRIPTPROP_ARG5,
        };
 
        class GRAYLIB_LINK cScriptableProp
        {
 
        public:
                cStructNamedElem m_a;                           
 
                CSCRIPTPROP_MASK_t m_wFlags;    
                BYTE m_PrivLevelWrite;                  
                BYTE m_PrivLevelRead;                   
                const ATOMCHAR_t* m_pszHelp;    
                UINT_PTR m_nMethodStub;                 
                cScriptableInterfaceDef* m_pInterfaceDef;       
                ATOMCODE_t m_nHashCode;                 
 
        public:
 
                static inline BYTE GetARGS(CSCRIPTPROP_MASK_t flag) noexcept
                {
                        return flag & CSCRIPTPROP_ARGS_MASK;            // recommended number of args.
                }
                static inline bool isNOARGS(CSCRIPTPROP_MASK_t flag) noexcept
                {
                        return (GetARGS(flag) == 0) && (flag & CSCRIPTPROP_NARGS);
                }
 
                void InitProp();
 
                const ATOMCHAR_t* get_Name() const noexcept
                {
                        return m_a.get_Name();  // StrT::k_LEN_MAX_KEY
                }
                ATOMCODE_t get_HashCode() const noexcept
                {
                        return m_nHashCode;
                }
 
                StrLen_t get_NamePropLen() const;
                cAtomRef get_NamePropA() const;
 
                bool IsPropFlags(CSCRIPTPROP_MASK_t wFlags) const noexcept
                {
                        return (m_wFlags & wFlags) != 0;
                }
                bool isFunction() const noexcept
                {
                        return IsPropFlags(CSCRIPTPROPM_FUNC);
                }
                bool isMethod() const noexcept
                {
                        return (m_nMethodStub != 0) && !isFunction();
                }
                bool isProp() const noexcept
                {
                        return m_nMethodStub == 0;
                }
                bool isDeprecated() const noexcept
                {
                        return IsPropFlags(CSCRIPTPROP_UNUSED | CSCRIPTPROP_DUPE);
                }
                int get_NumArgs() const noexcept
                {
                        return GetARGS(m_wFlags);
                }
                bool HasNoArgs() const noexcept
                {
                        return (m_wFlags & (CSCRIPTPROP_ARGS_MASK | CSCRIPTPROP_NARGS)) == CSCRIPTPROP_NARGS;
                }
                bool HasKnownArgs() const noexcept
                {
                        return IsPropFlags(CSCRIPTPROP_NARGS);
                }
                bool HasPrivLevelRead(PLEVEL_TYPE ePrivLevel) const noexcept
                {
                        return ePrivLevel >= m_PrivLevelRead;
                }
                bool HasPrivLevelWrite(PLEVEL_TYPE ePrivLevel) const noexcept
                {
                        return ePrivLevel >= m_PrivLevelWrite;
                }
                bool isValidProp() const noexcept
                {
                        if (!cMem::IsValidApp(this))
                                return false;
                        if (this->get_Name() == nullptr)
                                return false;
                        if (!StrChar::IsCSymF(this->get_Name()[0]))
                                return false;
                        if (this->m_pInterfaceDef == nullptr)
                                return false;
                        // ASSERT(this->m_pInterfaceDef->get_Name()!=nullptr);
                        return true;
                }
 
                SCRIPTINTERFACEID_t get_InterfaceID() const;
                SCRIPTPROPID_t get_PropIndex() const;
                SCRIPTPROPID_t get_MethodIndex() const;
 
                HRESULT SerializeOutput(cStreamOutput& file, PLEVEL_TYPE ePrivLevel);
 
                bool GetElementVal(const void* pBaseInst, OUT cVariant& vValRet) const
                {
                        ASSERT(isProp());
                        return m_a.m_elem.GetValVar(pBaseInst, vValRet);
                }
                bool SetElementVal(void* pBaseInst, const cVariant& vVal) const
                {
                        ASSERT(isProp());
                        if ((m_wFlags & CSCRIPTPROP_UNUSED) && m_a.m_elem.m_eVarType == VARTYPE_NoType)
                                return true;
                        return m_a.SetValVar(pBaseInst, vVal);
                }
                HRESULT SetElementCheck(void* pBaseInst, const cVariant& vVal) const
                {
                        if ((m_wFlags & CSCRIPTPROP_UNUSED) && m_a.m_elem.m_eVarType == VARTYPE_NoType)
                                return S_FALSE;
                        ASSERT(isProp());
                        return m_a.SetValCheck(pBaseInst, vVal);
                }
 
                VARTYPE_TYPE get_ElementType() const
                {
                        // Get the native data type.
                        return m_a.m_elem.m_eVarType;
                }
 
                HRESULT ScriptWrite(IScriptableSetter* pScript, const void* pBaseInst) const;
                HRESULT ScriptRead(IScriptableGetter* pScript, void* pBaseInst) const;
        };
 
        //*************************************************************************
 
        typedef cScriptableProp cScriptableMethod;      
 
#ifndef CSCRIPT_PROP_HELP
#define CSCRIPT_PROP_HELP(c)            c       
#endif
 
        // define cScriptableProp props and methods that must be implemented manually via s_PropGet or s_Invoke
#define CSCRIPT_PROP_IMP(a,b,c)                 { { #a, { VARTYPE_NoType, 0, 0 } }, b, PLEVEL_GM, PLEVEL_GM,  CSCRIPT_PROP_HELP(c), false, &sm_ScriptInterfaceDef }
#define CSCRIPT_METHOD_IMP(a,b,c)               { { #a, { VARTYPE_NoType, 0, 0 } }, b, PLEVEL_GM, PLEVEL_QTY, CSCRIPT_PROP_HELP(c), true,  &sm_ScriptInterfaceDef }
#define CSCRIPT_METHOD_IMP2(a,b,c,d)    { { #a, { VARTYPE_NoType, 0, 0 } }, b, c, PLEVEL_QTY, CSCRIPT_PROP_HELP(d), true,  &sm_ScriptInterfaceDef }
 
#define CSCRIPT_PROP_END                                { { nullptr, { VARTYPE_NoType, 0, 0 } }, 0 }
 
        //*************************************************************************
        // Defined elements about the class. (simple static type, not overloading any other interface)
 
#define CSCRIPT_CLASS_DEF0_N static cScriptableInterfaceDef sm_ScriptInterfaceDef;      // No virtuals.
 
#define CSCRIPT_CLASS_DEF0(TYPE) CSCRIPT_CLASS_DEF0_N virtual cScriptableInterfaceDefPtr _stdcall get_ScriptInterfaceDef() const { return(&sm_ScriptInterfaceDef); }
 
#define CSCRIPT_CLASS_IMP0(TYPE,_PROPS,_METHODS,_HELP) cScriptableInterfaceDef c##TYPE::sm_ScriptInterfaceDef(typeid(c##TYPE),#TYPE,_PROPS,_METHODS,nullptr,CSCRIPT_PROP_HELP(_HELP));
 
        //*************************************************************************
        // Defined elements about the class. (has just one interface)
#define CSCRIPT_CLASS_DEF1(TYPE,_BASETYPE) \
        CSCRIPT_CLASS_DEF0(TYPE) \
        typedef _BASETYPE CSCRIPTABLE_SUPER_t; \
 
#define CSCRIPT_CLASS_IMP1(TYPE,_PROPS,_METHODS,_HELP) \
        cScriptableInterfaceDef c##TYPE::sm_ScriptInterfaceDef(typeid(c##TYPE),#TYPE,_PROPS,_METHODS,&c##TYPE::CSCRIPTABLE_SUPER_t::sm_ScriptInterfaceDef,CSCRIPT_PROP_HELP(_HELP));
 
        //*************************************************************************
        // Defined elements about the class. (complex type with multiple interfaces)
#define CSCRIPT_CLASS_DEF2(TYPE,_BASETYPE) \
        static cScriptableInterfaceTemplate<c##TYPE> sm_ScriptInterfaceDef; \
        typedef _BASETYPE CSCRIPTABLE_SUPER_t; \
        virtual cScriptableInterfaceDefPtr _stdcall get_ScriptInterfaceDef() const \
        { return(&sm_ScriptInterfaceDef); }
 
#define CSCRIPT_CLASS_IMP2(TYPE,_PROPS,_METHODS,_HELP) \
        template class cScriptableInterfaceTemplate<c##TYPE>; \
        cScriptableInterfaceTemplate<c##TYPE> c##TYPE::sm_ScriptInterfaceDef(typeid(c##TYPE),#TYPE,_PROPS,_METHODS,&c##TYPE::CSCRIPTABLE_SUPER_t::sm_ScriptInterfaceDef,CSCRIPT_PROP_HELP(_HELP));
 
        //*************************************************************************
 
        class GRAYLIB_LINK cScriptableInterfaceDef
                : public CObject
        {
        public:
                const TYPEINFO_t& m_TypeInfo;           
                const ATOMCHAR_t* m_pszName;            
                cScriptableInterfaceDef* m_pSubInterface;       
                const char* m_pszHelp;                                  
 
                SCRIPTINTERFACEID_t m_nInterfaceID;
                cArraySortPtrName<const cScriptableProp, ATOMCHAR_t> m_aPropsAll;
                cArraySortPtrName<const cScriptableMethod, ATOMCHAR_t> m_aMethodsAll;
 
                cArraySortPtrHash<const cScriptableProp, ATOMCODE_t> m_aPropsAllHash;
                cArraySortPtrHash<const cScriptableMethod, ATOMCODE_t> m_aMethodsAllHash;
 
                cArraySortVal<SCRIPTINTERFACEID_t> m_aSubInterfacesAll;
 
#if 0
                SCRIPT_METHOD_FUNC* m_pfMethod;
                SCRIPT_PROP_FUNC* m_pfPropGet;
                SCRIPT_PROP_FUNC* m_pfPropSet;
#endif
 
                enum P_TYPE_    
                {
#define cScriptableInterfaceProp(a,b,c) P_##a,
#include "cScriptableInterfaceProps.tbl"
#undef cScriptableInterfaceProp
                        P_QTY,
                };
                static cScriptableProp sm_Props[P_QTY + 1];
                CSCRIPT_CLASS_DEF0(ScriptInterfaceDef); 
 
                UINT m_nInstances;              
 
        protected:
                bool m_bInitInterface;  
 
        private:
                cScriptableProp* m_pProps;                      
        protected:
                SCRIPTPROPID_t m_iPropQty;                      
        private:
                cScriptableMethod* m_pMethods;          
        protected:
                SCRIPTPROPID_t m_iMethodQty;            
 
        private:
                void AddProp(const cScriptableProp* pProp);
                void AddMethod(const cScriptableMethod* pMethod);
 
        public:
                cScriptableInterfaceDef(const TYPEINFO_t& TypeInfo, const ATOMCHAR_t* pszName, cScriptableProp* pProps, cScriptableMethod* pMethods, cScriptableInterfaceDef* pSubInterface, const ATOMCHAR_t* pszHelp);
                virtual ~cScriptableInterfaceDef();
 
                virtual bool isValidCheck() const noexcept; // override
 
                const ATOMCHAR_t* get_Name() const noexcept
                {
                        return m_pszName;
                }
                SCRIPTINTERFACEID_t get_InterfaceID() const noexcept
                {
                        // ASSERT(cScriptableInterfaceMgr::I().IsInterfaceInit());
                        return m_nInterfaceID;
                }
 
                SCRIPTPROPID_t get_MethodQty() const noexcept
                {
                        return m_iMethodQty; //
                }
                virtual cScriptableMethod* GetMethodPtr(SCRIPTPROPID_t index) const noexcept
                {
                        if (IS_INDEX_BAD(index, m_iMethodQty))
                                return nullptr;
                        return &m_pMethods[index];
                }
                virtual SCRIPTPROPID_t GetMethodIndex(const cScriptableMethod* pMethod) const
                {
                        SCRIPTPROPID_t index = (SCRIPTPROPID_t)GET_INDEX_IN((const cScriptableMethod*)m_pMethods, pMethod);
                        ASSERT(IS_INDEX_GOOD(index, SCRIPTPROPINDEX_MAX));
                        return index;
                }
                SCRIPTPROPID_t FindMethodIndex(const ATOMCHAR_t* pszName) const
                {
                        return (SCRIPTPROPID_t)StrT::TableFindHeadSorted(pszName, m_pMethods, m_iMethodQty, sizeof(m_pMethods[0]));
                }
                cScriptableMethod* FindMethodPtrI(const ATOMCHAR_t* pszName) const
                {
                        int index = FindMethodIndex(pszName);
                        if (index < 0)
                                return nullptr;
                        return &m_pMethods[index];
                }
 
                SCRIPTPROPID_t get_PropQty() const
                {
                        return m_iPropQty;      //
                }
                virtual cScriptableProp* GetPropPtr(SCRIPTPROPID_t index) const
                {
                        if (IS_INDEX_BAD(index, m_iPropQty))
                                return nullptr;
                        return &m_pProps[index];
                }
                virtual SCRIPTPROPID_t GetPropIndex(const cScriptableProp* pProp) const
                {
                        SCRIPTPROPID_t index = (SCRIPTPROPID_t)GET_INDEX_IN((const cScriptableProp*)m_pProps, pProp);
                        ASSERT(IS_INDEX_GOOD(index, SCRIPTPROPINDEX_MAX));
                        return index;
                }
                SCRIPTPROPID_t FindPropIndex(const ATOMCHAR_t* pszName) const
                {
                        return (SCRIPTPROPID_t)StrT::TableFindHeadSorted(pszName, m_pProps, m_iPropQty, sizeof(m_pProps[0]));
                }
                cScriptableProp* FindPropPtrI(const ATOMCHAR_t* pszName) const
                {
                        int index = FindPropIndex(pszName);
                        if (index < 0)
                                return nullptr;
                        return &m_pProps[index];
                }
 
                bool SetMethodPrivLevel(const ATOMCHAR_t* pszMethod, PLEVEL_TYPE ePrivLevel);
 
                bool IsInterfaceInit() const
                {
                        return m_bInitInterface;
                }
 
                HRESULT SerializeOutput(cStreamOutput& out, PLEVEL_TYPE ePrivLevel) const;
 
                virtual void InitScriptInterfaceDef();
 
                void InitSubInterfaces();
                bool HasSubInterface(const cScriptableInterfaceDef* pInterfaceDef) const;
                bool HasInterface(const cScriptableInterfaceDef* pInterfaceDef) const;
                void AddSubInterfaceProps(cScriptableInterfaceDef* pInterface);
 
                void AddSubInterfaces(cScriptableInterfaceDef* pSubInterface);
                const cScriptableMethod* FindMethodStr(const ATOMCHAR_t* pszName) const;
                const cScriptableProp* FindPropStr(const ATOMCHAR_t* pszName) const;
                const cScriptableProp* FindPropOrMethodStr(const ATOMCHAR_t* pszName) const;
 
                const cScriptableMethod* FindMethodHash(ATOMCODE_t nKey) const;
                const cScriptableProp* FindPropHash(ATOMCODE_t nKey) const;
        };
 
        template<class TYPE>
        class cScriptableInterfaceTemplate : public cScriptableInterfaceDef
        {
 
                typedef cScriptableInterfaceDef SUPER_t;
 
        public:
                cScriptableInterfaceTemplate(const TYPEINFO_t& TypeInfo, const ATOMCHAR_t* pszName, cScriptableProp* pProps, cScriptableMethod* pMethods, cScriptableInterfaceDef* pSubInterface, const ATOMCHAR_t* pszHelp)
                        : cScriptableInterfaceDef(TypeInfo, pszName, pProps, pMethods, pSubInterface, pszHelp)
                {
                }
 
                virtual void InitScriptInterfaceDef();
        };
 
        inline SCRIPTPROPID_t cScriptableProp::get_PropIndex() const
        {
                ASSERT(m_pInterfaceDef != nullptr);
                return m_pInterfaceDef->GetPropIndex(this);
        }
        inline SCRIPTPROPID_t cScriptableProp::get_MethodIndex() const
        {
                ASSERT(m_pInterfaceDef != nullptr);
                return m_pInterfaceDef->GetMethodIndex(this);
        }
 
        //*************************************************************************
 
        class GRAYLIB_LINK cScriptableInterfaceMgr : public cSingleton<cScriptableInterfaceMgr>
        {
 
                friend class cScriptableInterfaceDef;
                friend class cSingleton<cScriptableInterfaceMgr>;
                CHEAPOBJECT_IMPL;
 
        private:
                ITERATE_t m_nInitInterfaces;    // was InitInterfaces() called yet? how many times? SCRIPTINTERFACEID_t
                cArrayPtr<cScriptableInterfaceDef> m_aInterfaceDefs;
 
        protected:
                cScriptableInterfaceMgr();
                ~cScriptableInterfaceMgr();
 
        public:
                inline cScriptableInterfaceDefPtr GetInterfaceDef(SCRIPTINTERFACEID_t nInterfaceID) const
                {
                        if (!m_aInterfaceDefs.IsValidIndex(nInterfaceID))
                                return nullptr;
                        return m_aInterfaceDefs[nInterfaceID];
                }
 
                static void GRAYCALL InitInterfaces();
                void InitInterfaceDefs();
 
                bool isInitInterfaces() const
                {
                        return(m_nInitInterfaces > 0);
                }
 
                bool SetMethodPrivLevel(const ATOMCHAR_t* pszMethod, PLEVEL_TYPE ePrivLevel);
 
                SCRIPTINTERFACEID_t AddInterfaceDef(cScriptableInterfaceDef* pScriptInterface);
                bool RemoveInterfaceDef(cScriptableInterfaceDef* pScriptInterface);
 
                cScriptableInterfaceDefPtr FindInterfaceDef(const ATOMCHAR_t* pszName) const;
 
                void UpdateInterfaceProp(cScriptableProp* pProp);
                // void AddInterfaceProp( cScriptableInterfaceDef* pScriptInterface, cScriptableProp* pProp );
 
                UNITTEST_FRIEND(cScriptableInterface);
        };
}
 
#define CSCRIPT_PROP(_CLASS,_PROP)                      (_CLASS::sm_Props[_CLASS::P_##_PROP])
#define CSCRIPT_PROP_NAME(_CLASS,_PROP)         (CSCRIPT_PROP(_CLASS,_PROP).m_a.m_pszKey)
#define CSCRIPT_PROP_NAMEA(_CLASS,_PROP)        (CSCRIPT_PROP(_CLASS,_PROP).get_NamePropA())
 
#define CSCRIPT_METHOD(_CLASS,_PROP)            (_CLASS::sm_Methods[_CLASS::M_##_PROP])
#define CSCRIPT_METHOD_NAME(_CLASS,_PROP)       (CSCRIPT_METHOD(_CLASS,_PROP).m_a.m_pszKey)
#define CSCRIPT_METHOD_NAMEA(_CLASS,_PROP)      (CSCRIPT_METHOD(_CLASS,_PROP).get_NamePropA())
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
namespace Gray
{
        template class GRAYLIB_LINK cArrayPtr<GrayLib::cScriptableInterfaceDef>;
        template class GRAYLIB_LINK cArraySorted<GrayLib::SCRIPTINTERFACEID_t, GrayLib::SCRIPTINTERFACEID_t, GrayLib::SCRIPTINTERFACEID_t>;
}
#endif
 
#endif // _INC_cScriptableInterface_H