cXObject.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cXObject_H
#define _INC_cXObject_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "IXObject.h"
#include "../Scriptable/cScriptableObj.h"
#include "../Variant/cVarMap.h"
 
#include "GrayCore/include/cHeap.h"
#include "GrayCore/include/cRefPtr.h"
#include "GrayCore/include/cTimeSys.h"
#include "GrayCore/include/cTimeInt.h"
#include "GrayCore/include/cThreadLockRef.h"
#include "GrayCore/include/IUnknown.h"  // __IUnknown_INTERFACE_DEFINED__
 
#ifdef _MSC_VER 
#pragma warning(disable:4250)   // disable "'GrayLib::cXObject': inherits 'Gray::cScriptableObj::Gray::cScriptableObj::s_GetByName' via dominance"
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cXObject);
 
        class GRAYLIB_LINK cScriptableProp;
        typedef cScriptableProp cScriptableMethod;      // Methods are really similar to Props.
        class GRAYLIB_LINK cScriptContext;
        class GRAYLIB_LINK cXObject;
        class GRAYLIB_LINK cXObjDef;
 
#define XOBJ_ROOT       "Root"  // There is usually a SymName object called "Root" cUID::k_ROOT
 
        // cXObjTypeDef
#ifdef _MSC_VER
        enum XOBJTIDX_TYPE;     
#else // __GNUC__
        typedef int XOBJTIDX_TYPE;      
#endif
        const int k_XOBJTIDX_QTY = 128; 
 
        typedef int XOBJ_WEIRD_t;       // Object validation.
        inline XOBJ_WEIRD_t XOBJ_WEIRD_CODE(int _Interface, int _CantFix, int _UniqueTestCode)
        {
                return ((((int)(_Interface)) << 12) | (((int)(_CantFix) << 8)) | ((int)(_UniqueTestCode)));
        }
 
        enum XObjState_TYPE
        {
 
                XObjState_Init,         
                XObjState_Loading,      
 
                XObjState_Disposed,             
                XObjState_Disposing,    
                XObjState_Bad,          
 
                XObjState_Loaded,       
                XObjState_Loaded1,      
                XObjState_Modified,     
                XObjState_QTY,
        };
 
        class GRAYLIB_LINK cXObject
                : public cScriptableObj // also IScriptableObj
                , public IXObject               // also virtual IScriptableObj
                , public cThreadLockableRef     // assume also cRefBase
                , public CObject                // MFC compatible.
                , public cHeapObject    // always heap allocated
        {
 
                typedef cScriptableObj SUPER_t;
 
        public:
                CSCRIPT_CLASS_DEF0(XObject);
 
                enum P_TYPE_
                {
#define cXObjectProp(a,b,c,d) P_##a,
#include "cXObjectProps.tbl"
#undef cXObjectProp
                        P_QTY,
                };
                static cScriptableProp sm_Props[P_QTY + 1];
 
                enum M_TYPE_
                {
#define cXObjectMethod(a,b,c,d) M_##a,
#include "cXObjectMethods.tbl"
#undef cXObjectMethod
                        M_QTY,
                };
                static cScriptableMethod sm_Methods[M_QTY + 1];
 
                // Can be used to override XObjDef m_pBaseDef props
                cVarMap m_TagMap;                       
 
                static ITERATE_t sm_iLoadingCount;              
 
        protected:
                CHEAPOBJECT_IMPL;
                cRefPtr<cXObjDef> m_pBaseDef;   
 
        private:
                UID_t m_nUID;                                   
                XObjState_TYPE m_eObjState;             
                cTimeInt m_timeSaved;                   
 
        public:
                explicit cXObject(UID_t nUID = cUID::k_CLEAR, cXObjDef* pBaseDef = nullptr);
                virtual ~cXObject();
                virtual bool isValidCheck() const noexcept override;
 
                STDMETHOD_(XOBJTID_t, get_XObjTypeId)() const
                {
                        return k_XOBJTID_DEFAULT;
                }
                const ATOMCHAR_t* get_XObjTypeName() const;
 
                virtual int get_BaseRefCount() const
                {
                        return 0;
                }
 
                //***********************************
                // Identify it by UID
                bool isValidUID() const noexcept
                {
                        if (!cMem::IsValidApp(this))
                                return false;
                        return m_nUID != cUID::k_CLEAR ;
                }
 
                UID_t get_UIDValue() const noexcept
                {
                        return m_nUID;
                }
                UID_t get_HashCode() const noexcept
                {
                        return m_nUID;
                }
                STDMETHOD_(HASHCODE_t, get_HashCodeX)() const noexcept override
                {
                        return m_nUID;
                }
 
                void put_UIDValuePrivate(UID_t dwIndex);
                STDMETHOD_(void, put_UIDValue)(UID_t dwIndex);
 
                //***********************************
                STDMETHOD_(cString, get_Name)() const override;
                STDMETHOD(put_Name)(cString sName) 
                {
                        if (!sName.Compare(get_Name())) // always allowed to set to what it already is.
                                return S_OK;
                        return HRESULT_WIN32_C(ERROR_WRITE_FAULT);
                }
                STDMETHOD_(cString, get_NameDeco)() const
                {
                        return get_Name();
                }
 
                //***********************************
                STDMETHOD_(cStringA, get_SymName)() const override;
                STDMETHOD(put_SymName)(cAtomRef aSymName, bool bOverwrite = false);
                HRESULT put_SymName2(cAtomRef aSymName);
 
                //***********************************
                cXObjDef* get_BaseDef() const
                {
                        return(m_pBaseDef);
                }
                virtual bool put_BaseDef(cXObjDef* pDef)
                {
                        m_pBaseDef = pDef;
                        return true;
                }
                STDMETHOD_(cAtomRef, get_BaseSymNameA)() const; 
 
                //***********************************
                virtual cRefPtr<cXObject> get_ContainerObject() const
                {
                        return nullptr;
                }
                virtual cVariant get_ContainerVar() const;
                STDMETHOD(put_ContainerVar)(const cVariant& vVal)
                {
                        UNREFERENCED_REFERENCE(vVal);
                        return E_NOTIMPL;       // not supported i guess.
                }
                bool isMyContainer(const cXObject* pObjParent) const;
 
                //*******************************
                // XObjState_TYPE = init, loading, deleted, bad,
                void InitObjState();    // static objects can be re-used.
                XObjState_TYPE get_ObjState() const noexcept
                {
                        return m_eObjState;
                }
                bool put_ObjState(XObjState_TYPE eObjState);
 
                bool isObjStateLoading() const noexcept
                {
                        return m_eObjState <= XObjState_Loading ;
                }
                bool isObjStateLoading1() const noexcept
                {
                        return m_eObjState <= XObjState_Loading || m_eObjState == XObjState_Loaded1 ;
                }
                bool isObjStateLoaded() const noexcept
                {
                        return m_eObjState >= XObjState_Loaded ;
                }
                bool isObjStateModified() const noexcept
                {
                        return m_eObjState == XObjState_Modified ;
                }
                bool isObjStateDisposed() const noexcept;
                bool isObjStateBad() const noexcept;
 
                STDMETHOD(SetObjStateLoaded)(); 
                void SetObjStateBad();
                void SetObjStateModified();
                void ClearObjStateModified();
 
                const cTimeInt& get_TimeSaved() const noexcept
                {
                        return m_timeSaved;
                }
                void put_TimeSaved(cTimeInt timeSaved)
                {
                        m_timeSaved = timeSaved;
                }
                void UpdateTimeSaved();
 
                //************************************************
                virtual cVarTuplePtr FindTagA(cAtomRef aTagName) const;
                cVarTuplePtr FindTag(const ATOMCHAR_t* pszTagName) const;
                void s_WritePropsTags(IScriptableSetter& Update);
 
                //***********************************
                STDMETHOD(s_PropPut)(const cScriptableProp* pProp, const cVariant& vVal) override;
                STDMETHOD(s_PropGet)(const cScriptableProp* pProp, OUT cVariant& vValRet) override;
                STDMETHOD(s_Invoke)(const cScriptableMethod* pMethod, const cVariant& vArgs, OUT cVariant& vValRet) override;
                STDMETHOD(s_GetByName)(const ATOMCHAR_t* pszPropName, OUT cVariant& rvValRet) override;
                // s_Put // put to m_TagMap
 
                STDMETHOD(s_TagPut)(const ATOMCHAR_t* pszTagName, const cVariant& vValSet);
                STDMETHOD(s_TagGet)(const ATOMCHAR_t* pszTagName, OUT cVariant& vValRet);
                STDMETHOD(s_LoadProps)(IScriptableEnumerator& rProps);
 
                STDMETHOD(s_EventSinkAdd)(cXObjDef* pXObjDef, bool bRemove = false)
                {
                        UNREFERENCED_PARAMETER(pXObjDef);
                        UNREFERENCED_PARAMETER(bRemove);
                        return HRESULT_WIN32_C(ERROR_NOT_SUPPORTED);
                }
 
 
                //*******************************
                cStringA s_PropGetDumpStr(const cScriptableProp* pProp, XOBJ_DUMP_MASK_t uFlags = 0);
                HRESULT s_DumpKeys(cStreamOutput& rout, XOBJ_DUMP_MASK_t uFlags, const cScriptableProp* const* ppProps, ITERATE_t iQty);
                HRESULT s_DumpHelp(cStreamOutput& rout, const cVariant& vArgs);
 
                virtual HRESULT DisposeThis();  
                virtual XOBJ_WEIRD_t IsWeird() const;
                virtual XOBJ_WEIRD_t FixWeird();
                virtual size_t GetHeapStats(OUT ITERATE_t& iAllocCount) const; 
 
 
                IUNKNOWN_DISAMBIG_R(cThreadLockableRef);
                STDMETHOD(QueryInterface)( /* [in] */ const IID& riid, /* [iid_is][out] */ void** ppvObject) override;
        };
 
        typedef cRefPtr<cXObject> cXObjectPtr;
};
#endif // _INC_cXObject_H