cXObjMgr.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cXObjMgr_H
#define _INC_cXObjMgr_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cXObjDef.h"
#include "IXObject.h"   // UID_t, cUID::k_ROOT, cUID::k_CLEAR
#include "GrayCore/include/cHashTable.h"
#include "GrayCore/include/cThreadLock.h"
#include "GrayCore/include/cArraySort.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cSingletonPtr.h"
 
namespace GrayLib
{
        class cXObjTypeDef;
 
        template <class TYPE>
        class cArraySortSymName : public cArraySortRef < TYPE, const ATOMCHAR_t* >
        {
                typedef cArraySortRef<TYPE, const ATOMCHAR_t*> SUPER_t;
 
        protected:
                virtual COMPARE_t CompareData(TYPE* pData1, TYPE* pData2) const noexcept
                {
                        ASSERT(pData1 != nullptr);
                        ASSERT(pData2 != nullptr);
                        return StrT::CmpI<ATOMCHAR_t>(pData1->get_SymName(), pData2->get_SymName());
                }
                virtual COMPARE_t CompareKey(const ATOMCHAR_t* key1, TYPE* pObj) const
                {
                        ASSERT(key1 != nullptr);
                        ASSERT(pObj != nullptr);
                        return StrT::CmpI<ATOMCHAR_t>(key1, pObj->get_SymName());
                }
 
        public:
                virtual ~cArraySortSymName()
                {}
                bool RemoveArgKey(TYPE* pBase)
                {
                        if (pBase == nullptr)
                                return false;
                        return SUPER_t::RemoveArgKey(pBase, pBase->get_SymName());
                }
         
        };
        
        MIDL_INTERFACE("0C3E2E71-B93C-11d2-AAD0-006007654325") IXObjModPlugin // compliment IXObjMgr
        {
                IGNORE_WARN_INTERFACE(IXObjModPlugin);
                virtual cXObjectPtr FindByUID(UID_t uid) const = 0;
                virtual HRESULT CreateXObjDef(cXObjDefPtr& rpXObjDefNew, const cXObjTypeDef* pXObjTypeDef, cAtomRef aSymName) = 0;
                // virtual HRESULT CreateXObj()
        };
 
        enum XOBJTYPF_TYPE
        {
                XOBJTYPF_0 = 0,
                XOBJTYPF_SINGLETON = 0x01,      
                XOBJTYPF_DEMANDLOAD = 0x02,     
                XOBJTYPF_PRIVNAME = 0x04,       
                XOBJTYPF_SIMPLE = 0x08,         
                XOBJTYPF_DEPRECATED = 0x10,     
                XOBJTYPF_STATIC = 0x20,         
                XOBJTYPF_NOUID = 0x40,          
                XOBJTYPF_NOPERSIST = 0x80,      
        };
 
        class cXObjTypeDef
        {
 
        public:
                XOBJTID_t m_nXObjTypeId;                                
                const ATOMCHAR_t* m_pszTableName;               
                BYTE m_nXObjFlags;                                              
                const char* m_pszTableSelect;                   
                const char* m_pszDescription;                   
                IXObjModPlugin* m_pXObjModPlugin;               
                cScriptableInterfaceDef* m_pInterfaceDef;       
                XOBJTIDX_TYPE m_eXObjTypeIdx;                   
                cUIDRangeMask m_UIDRange;                               
 
                static const char* k_pszNULL;                   
 
        public:
                bool IsXObjFlags(BYTE nFlags) const noexcept
                {
                        return(m_nXObjFlags & nFlags) ? true : false;
                }
                bool isXObjTypeDemandLoaded() const noexcept
                {
                        return IsXObjFlags(XOBJTYPF_DEMANDLOAD);
                }
                XOBJTID_t get_HashCode() const noexcept
                {
                        // Get FOURCC
                        return m_nXObjTypeId;
                }
        };
 
        class GRAYLIB_LINK cXObjMgr
                : public cSingletonSmart<cXObjMgr>              // cRefBase support refs for IXObjMgr
                , public IXObjMgr
        {
 
                friend class cSingleton<cXObjMgr>;
 
        public:
                enum M_TYPE_
                {
#define cXObjMgrMethod(a,b,c) M_##a,
#include "cXObjMgrMethods.tbl"
#undef cXObjMgrMethod
                        M_QTY,
                };
                static cScriptableMethod sm_Methods[M_QTY + 1];
                CSCRIPT_CLASS_DEF0(cXObjMgr);
 
                static cXObjTypeDef sm_DEFAULT;         
 
                const cObjectSignature<> m_Sig;         
 
                cHashTableRef<cXObject, UID_t, 6> m_XObjHash;           
 
        protected:
                cArraySortSymName<cXObjDef> m_aXObjSymNames;    
                mutable cThreadLockCount m_LockXObj;    
 
                cArrayPtr<cXObjTypeDef> m_aXObjTypeDefs;
 
        public:
                cXObjMgr(cXObjDef* pRoot = nullptr);    // k_ROOT
                virtual ~cXObjMgr();
 
                virtual HRESULT InitXObjMgr(cXObjDef* pRoot);
                virtual void DisposeAllX();
                virtual cXObjectPtr FindByUID(UID_t uid) const;
 
                cXObjectPtr GetAtHash(const cHashIterator& e) const
                {
                        cThreadGuard lock(m_LockXObj);
                        return m_XObjHash.GetAtHash(e);
                }
 
                // cXObjTypeDef
                XOBJTIDX_TYPE FindXObjTypeIdx(const ATOMCHAR_t* pszXObjTypeName) const;
                XOBJTIDX_TYPE FindXObjTypeIdx(XOBJTID_t nXObjTypeId) const;
                cXObjTypeDef* EnumXObjTypeDef(XOBJTIDX_TYPE index) const;
                cXObjTypeDef* FindXObjTypeDef(const ATOMCHAR_t* pszXObjTypeName) const;
                cXObjTypeDef* FindXObjTypeDef(XOBJTID_t nXObjTypeId) const;
 
                const ATOMCHAR_t* FindXObjTypeName(XOBJTID_t nXObjTypeId) const;
                XOBJTID_t FindXObjTypeId(const ATOMCHAR_t* pszXObjTypeName) const;
                bool IsXObjTypeDemandLoaded(XOBJTID_t nXObjTypeId) const;
 
                XOBJTIDX_TYPE RegisterXObjTypeDef(cXObjTypeDef* pXObjTypeDef);
                ITERATE_t UnloadXObjTypeDef(XOBJTID_t nXObjTypeId);
 
                // cXObjDef
                ITERATE_t get_XObjCount() const
                {
                        return m_aXObjSymNames.GetSize();
                }
                cXObjDefPtr FindDefByUID(UID_t rid) const;
 
                HRESULT AddXObjSymName(cXObjDef* pXObjDef);
                bool RemoveXObjSymName(const ATOMCHAR_t* pszSymName);
 
                cXObjDefPtr FindBySymName0(const ATOMCHAR_t* pszSymName) const;
                cXObjDefPtr FindBySymName(const ATOMCHAR_t* pszSymName) const;
                cXObjDefPtr FindBySymNamePartial(const ATOMCHAR_t* pszNamePartial) const;
                cXObjectPtr FindByVar(const cVariant& vID) const;
 
                virtual HRESULT CreateXObjDef(OUT cXObjDefPtr& rpXObjDefNew, const cXObjTypeDef* pXObjTypeDef, cAtomRef aSymName);
                virtual HRESULT CreateXObjDefX(OUT cXObjDefPtr& rpXObjDefNew, const cXObjTypeDef* pXObjTypeDef, cAtomRef aSymName, IScriptableEnumerator* pProps);
 
                virtual HRESULT s_Invoke_GetObjTypes(OUT cVariant& vValRet);
                virtual HRESULT s_Invoke_FindObjects(const cVariant& vArgs, OUT cVariant& vValRet);
                HRESULT s_Invoke_DumpConst(const cVariant& vArgs);
 
                static HRESULT inline CheckValidSignature(UINT32 nGrayLibVer, size_t nSizeofThis)
                {
                        cXObjMgr* pMgr = get_SingleU();
                        if (!cMem::IsValidApp(pMgr))
                        {
                                // Something is wrong. No idea.
                                return HRESULT_WIN32_C(ERROR_INTERNAL_ERROR);
                        }
                        if (nGrayLibVer != _INC_GrayLibBase_H || !pMgr->m_Sig.IsValidSignature(_INC_GrayLibBase_H, nSizeofThis))
                        {
                                // My *Core DLL is not the correct version or packing is incorrect!
                                return HRESULT_WIN32_C(ERROR_PRODUCT_VERSION);
                        }
                        return S_OK;
                }
 
                virtual UID_t MakeUID(XOBJTID_t nXObjTypeId, UIDINDEX_t nIndex);
                HRESULT AssignFreeUID(cXObject* pObj, UIDINDEX_t nIndex);
 
                virtual HRESULT AddXObj(cXObject* pXObj);
                HRESULT AddXObjCheck(cXObject* pXObj, UIDINDEX_t nIndex= k_HASHCODE_CLEAR);
                virtual void RemoveXObj(cXObject* pXObj);
 
                virtual HRESULT AddXObjDef(cXObjDef* pXObjDef);
                HRESULT AddXObjDefCheck(cXObjDef* pXObjDef, UIDINDEX_t nIndex);
                virtual void RemoveXObjDef(cXObjDef* pXObjDef);
 
                // support for IXObjMgr
                STDMETHOD(FindByUID)(UID_t uid, OUT IXObject** ppObj) override;
                STDMETHOD(FindByStr)(const ATOMCHAR_t* pszID, OUT IXObject** ppObj) override;
                STDMETHOD(FindBySymName)(const ATOMCHAR_t* pszSymName, OUT IXObject** ppObj) override;
 
                STDMETHOD(CreateInstance)( /* [unique][in] */ IUnknown *pUnkOuter, const IID& riid, /* [iid_is][out] */ OUT void **ppvObject) override;
                STDMETHOD(LockServer)(BOOL fLock)  override;
 
                STDMETHOD(QueryInterface)( /* [in] */ const IID& riid, /* [iid_is][out] */ OUT void __RPC_FAR* __RPC_FAR* ppvObject) override;
 
                STDMETHOD(s_Invoke)(const cScriptableMethod* pMethod, const cVariant& vArgs, OUT cVariant& vValRet);
 
                UNITTEST_FRIEND(cXObjMgr);
                IUNKNOWN_DISAMBIG_R(cRefBase);
        };
}
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
namespace Gray
{
        template class GRAYLIB_LINK cArrayTyped< cRefPtr<GrayLib::cXObjDef>, GrayLib::cXObjDef* >;
        template class GRAYLIB_LINK cHashTableRef<GrayLib::cXObjDef, GrayLib::UID_t, 6>;
}
#endif
 
#endif // _INC_cXObjMgr_H