XObject.h

// CXObject.h: interface for the CXObject class.
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(CXOBJECT_INCLUDE_H)
#define CXOBJECT_INCLUDE_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
BEGIN_MOOTOOLS_NAMESPACE
 
    void ReleaseXRuntimeObject();
 
    class CXArchive;
    class CXObject;
 
    // temporary 
    typedef const CXRuntimeClass * CXRuntimeClassPtr;
    typedef const CXObject * CXObjectPtr;
    struct DLL_TOOLSFUNCTION CXRuntimeClass
    {
        typedef enum
        {
            FLAGS_NOT_SERIALIZABLE          = 0x10000000,
            FLAGS_SUPPORT_OLD_VERSION       = 0x20000000,
            FLAGS_RESERVED_FLAGS = 0xFF000000,
        } RUNTIMECLASS_FLAGS;
 
        // Attributes
        LPCSTR className;
        const size_t classSizeof;
        const unsigned int classVersion;
        const CXRuntimeClassPtr baseClass;
        CXObject* (*pfnCreateObject)(); // NULL => abstract class, allow to create an object using it's runtime class
 
    public:
        // dynamic name lookup and creation
        static CXObject* CreateObject(LPCSTR lpszClassName);
 
        // Operations
        CXObject *CreateObject() const;
        bool IsDerivedFrom(CXRuntimeClassPtr pBaseClass) const;
        static bool DeclareRuntimeClass(CXRuntimeClassPtr runtimeClass);
 
        // Serialization
#ifndef MOOTOOLS_NO_ARCHIVE_SUPPORT
        bool IsSerializable() const;
        void Save(CXArchive& ar) const;
        static CXRuntimeClassPtr Load(CXArchive& ar, unsigned int& version);
#endif // !MOOTOOLS_NO_ARCHIVE_SUPPORT
 
    #if defined(_DEBUG)
        void Dump() const;
    #endif
    };
 
    class DLL_TOOLSFUNCTION NOVTABLE CXObject
    {
        friend CXRuntimeClass;
 
    public:
        virtual ~CXObject();
 
        virtual CXRuntimeClassPtr GetRuntimeClassDescriptor() const;
        virtual void Serialize(CXArchive& ar);
        bool IsKindOf(const CXRuntimeClassPtr runtimeClass) const;
 
    #if defined(_DEBUG)
        virtual void Dump() const;
    #endif
 
        static const CXRuntimeClass classCreatorCXObject;
        static const CXRuntimeClassPtr GetThisRuntimeClassDescriptor();
 
    protected:
        CXObject();
 
        // Disable the copy constructor and assignment by default
        CXObject(const CXObject& objectSrc);
        void operator=(const CXObject& objectSrc);
    };
 
 
    inline CXObject::CXObject()
    {
    }
 
    #define IS_XRUNTIMECLASS_FLAG_SET(version, flag, set) (!!(version & flag) == set)
    #define GET_XRUNTIMECLASS_VERSION(version) (version & ~CXRuntimeClass::FLAGS_RESERVED_FLAGS)
    #define XOBJECT_VERSIONABLE (CXRuntimeClass::FLAGS_SUPPORT_OLD_VERSION)
    #define XASSERT_KINDOF(class_name, object) \
        XASSERT((object)->IsKindOf(XRUNTIME_CLASS(class_name)))
 
    // calling object::GetThisRuntimeClassDescriptor() instead accessing object::classCreator##object avoid delay load problems
    #define XRUNTIME_CLASS(object) (object::GetThisRuntimeClassDescriptor())
    #define DECLARE_XRUNTIMECLASS(object) \
        public: \
            static const CXRuntimeClass classCreator##object; \
            static const CXRuntimeClassPtr GetThisRuntimeClassDescriptor(); \
            virtual CXRuntimeClassPtr GetRuntimeClassDescriptor() const \
            { \
                return XRUNTIME_CLASS(object); \
            }
 
    #define DECLARE_DYNCREATE_XRUNTIMECLASS(object) \
        DECLARE_XRUNTIMECLASS(object) \
        static CXObject *CreateObject();
    #define DECLARE_SERIAL_XRUNTIMECLASS(object) \
        DECLARE_XRUNTIMECLASS(object) \
        static CXObject *CreateObject();
 
 
    #define IMPLEMENT_XRUNTIMECLASS(object, baseObject, serializeVersion, createObject) \
            const CXRuntimeClass object::classCreator##object =   \
            { #object, sizeof(object), serializeVersion, &baseObject::classCreator##baseObject, createObject}; \
            const bool classDeclared##object = CXRuntimeClass::DeclareRuntimeClass(&object::classCreator##object);
 
    #define IMPLEMENT_DYNAMIC_XOBJECT(object, baseObject) \
            const CXRuntimeClassPtr object::GetThisRuntimeClassDescriptor() { return &object::classCreator##object; } \
            IMPLEMENT_XRUNTIMECLASS(object, baseObject, CXRuntimeClass::FLAGS_NOT_SERIALIZABLE, NULL)
 
    #define IMPLEMENT_DYNCREATE_XOBJECT(object, baseObject) \
            CXObject *object::CreateObject() \
            { \
                return xNew(object); \
            } \
            const CXRuntimeClassPtr object::GetThisRuntimeClassDescriptor() { return &object::classCreator##object; } \
            IMPLEMENT_XRUNTIMECLASS(object, baseObject, CXRuntimeClass::FLAGS_NOT_SERIALIZABLE, object::CreateObject)
 
    #define IMPLEMENT_SERIAL_XOBJECT(object, baseObject, serializeVersion) \
            CXObject *object::CreateObject() \
            { \
                return xNew(object); \
            } \
            const CXRuntimeClassPtr object::GetThisRuntimeClassDescriptor() { return &object::classCreator##object; } \
            IMPLEMENT_XRUNTIMECLASS(object, baseObject, serializeVersion, object::CreateObject) 
    
    #define DECLARE_DYNAMIC_XOBJECT DECLARE_XRUNTIMECLASS
    #define DECLARE_DYNCREATE_XOBJECT DECLARE_DYNCREATE_XRUNTIMECLASS
    #define DECLARE_SERIAL_XOBJECT DECLARE_SERIAL_XRUNTIMECLASS
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(CXOBJECT_INCLUDE_H)