GxSerializer.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class GxSerializeStackNode
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    class GxTemporaryPropertyTable : public GxPropertyTable
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_CLASS(GxTemporaryPropertyTable, GxPropertyTable)
        class GxTemporaryPropartyNode : public GxNode
        {
            //-----------------------------------------------------------
            //-----------------------------------------------------------
        public:
            // new, delete定義
            GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY);
 
        };
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        ~GxTemporaryPropertyTable(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxNode* allocNode(s32 count) override { return GX_NEW GxTemporaryPropartyNode[count]; }
        void freeNode(GxNode* pNode) override { deteleTemporaryNode(&pNode); }
    private:
        void deteleTemporaryNode(GxNode** ppNode);
 
    };
 
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxSerializeStackNode(GxTypedObject* pObject, const GxRtti* pRtti);
    GxSerializeStackNode(GxTypedObject* pObject, GxPropertyTable* pTable);
    ~GxSerializeStackNode(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE GxProperty* getPropertyAt(s32 index) const { return &(*_pPropertyTable)[index]; }
    GxProperty* getTop(void);
    GxProperty* shiftProperty(void);
    GxProperty* getCurrentProperty(void) const { return static_cast<u32>(_propertyTableIndex) >= _pPropertyTable->getCount() ? nullptr : getPropertyAt(_propertyTableIndex); }
    s32 getArrayIndex(void);
    s32 shiftArrayIndex(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxTypedObject*              _pObject;               
    GxTemporaryPropertyTable*   _pPropertyTable;        
    s32                         _propertyTableIndex;    
    s32                         _arrayIndex;            
    s32                         _arrayCount;            
    b32                         _isProcessing;          
    b32                         _useRttiTable;          
 
};
 
//===========================================================================
//===========================================================================
class GxSerializer
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    static GX_CSTR XML_ELEMENT_STRING_ROOT;                         
    static GX_CSTR XML_ELEMENT_STRING_DYNAMIC_ARRAY;                
    static GX_CSTR XML_ELEMENT_STRING_STATIC_ARRAY;                 
 
    static GX_CSTR XML_ATTRIBUTE_STRING_ROOT_NAME;                  
    static GX_CSTR XML_ATTRIBUTE_STRING_ROOT_TYPE;                  
    static GX_CSTR XML_ATTRIBUTE_STRING_ROOT_INDEX;                 
    static GX_CSTR XML_ATTRIBUTE_STRING_OBJECT_COUNT;               
    static GX_CSTR XML_ATTRIBUTE_STRING_ARRAY_NAME;                 
    static GX_CSTR XML_ATTRIBUTE_STRING_ARRAY_COUNT;                
    static GX_CSTR XML_ATTRIBUTE_STRING_PROPERTY_NAME;              
    static GX_CSTR XML_ATTRIBUTE_STRING_CLASS_TYPE;                 
    static GX_CSTR XML_ATTRIBUTE_STRING_CLASS_INDEX;                
    static GX_CSTR XML_ATTRIBUTE_STRING_CLASS_INSTANCE;             
    static GX_CSTR XML_ATTRIBUTE_STRING_CUSTOM_PROPERTY_TYPE;       
    static GX_CSTR XML_ATTRIBUTE_STRING_CUSTOM_PROPERTY_KIND;       
    static GX_CSTR XML_ATTRIBUTE_STRING_CUSTOM_PROPERTY_COUNT;      
    static GX_CSTR XML_ATTRIBUTE_STRING_CUSTOM_PROPERTY_VALUE;      
    static GX_CSTR XML_ATTRIBUTE_STRING_DATA_VALUE;                 
 
    static constexpr u32 XML_ATTRIBUTE_MAX = 8;                         
 
    enum class XML_ELEMENT_TYPE
    {
        ROOT = 0,                               
        DYNAMIC_ARRAY,                          
        STATIC_ARRAY,                           
        CLASSNAME,                              
 
        MAX                                     
    };
 
    enum class XML_ATTRIBUTE_TYPE
    {
        ROOT_NAME = 0,                          
        ROOT_TYPE,                              
        ROOT_INDEX,                             
        OBJECT_COUNT,                           
        ARRAY_NAME,                             
        ARRAY_COUNT,                            
        PROPERTY_NAME,                          
        CLASS_TYPE,                             
        CLASS_INDEX,                            
        CLASS_INSTANCE,                         
        CUSTOM_PROPERTY_NAME,                   
        CUSTOM_PROPERTY_KIND,                   
        CUSTOM_PROPERTY_COUNT,                  
        CUSTOM_PROPERTY_VALUE,                  
        DATA_VALUE,                             
 
        MAX                                     
    };
 
    //===========================================================================
    //===========================================================================
    class GxBinarySerializer
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        static constexpr u32 VERSION = 110;                     
 
    private:
        // ヘッダー
        struct Header
        {
            u32         _version;                           
            u32         _rttiId;                            
            u32         _objectCount;                       
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        GxBinarySerializer(void) {}
 
    public:
        GxBinarySerializer(GxStream* pStream) : _pStream(pStream) { GX_MEMSET(&_header, 0, sizeof(Header)); }
        ~GxBinarySerializer(void) {}
 
    private:
        GxBinarySerializer(const GxBinarySerializer&);
        GX_FORCE_INLINE const GxBinarySerializer& operator=(const GxBinarySerializer&);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
    public:
        b32 read(void* pDst, u32 size);
        b32 read(u8& dst) { u32 temporary; b32 result = read(&temporary, sizeof(temporary)); dst = static_cast<u8>(temporary); return result; }
        b32 read(s8& dst) { u32 temporary; b32 result = read(&temporary, sizeof(temporary)); dst = static_cast<s8>(temporary); return result; }
        b32 read(u16& dst) { u32 temporary; b32 result = read(&temporary, sizeof(temporary)); dst = static_cast<u16>(temporary); return result; }
        b32 read(s16& dst) { u32 temporary; b32 result = read(&temporary, sizeof(temporary)); dst = static_cast<s16>(temporary); return result; }
        b32 read(u32& dst) { u32 temporary; b32 result = read(&temporary, sizeof(temporary)); dst = static_cast<u32>(temporary); return result; }
        b32 read(s32& dst) { u32 temporary; b32 result = read(&temporary, sizeof(temporary)); dst = static_cast<s32>(temporary); return result; }
        b32 read(u64& dst) { return read(&dst, sizeof(dst)); }
        b32 read(s64& dst) { return read(&dst, sizeof(dst)); }
        b32 read(u128& dst) { return read(&dst, sizeof(dst)); }
        b32 read(s128& dst) { return read(&dst, sizeof(dst)); }
        b32 read(b32& dst) { u32 temporary; b32 result = read(temporary); dst = (temporary) ? true : false; return result; }
        b32 readHeader(const GxRtti* pRtti, u32* pObjectCount);
        b32 write(const void* pSrc, u32 size);
        b32 write(const u8& src) { u32 temporary = src; return write(&temporary, sizeof(temporary)); }
        b32 write(const s8& src) { s32 temporary = src; return write(&temporary, sizeof(temporary)); }
        b32 write(const u16& src) { u32 temporary = src; return write(&temporary, sizeof(temporary)); }
        b32 write(const s16& src) { s32 temporary = src; return write(&temporary, sizeof(temporary)); }
        b32 write(const u32& src) { u32 temporary = src; return write(&temporary, sizeof(temporary)); }
        b32 write(const s32& src) { s32 temporary = src; return write(&temporary, sizeof(temporary)); }
        b32 write(const u64& src) { return write(&src, sizeof(src)); }
        b32 write(const s64& src) { return write(&src, sizeof(src)); }
        b32 write(const u128& src) { return write(&src, sizeof(src)); }
        b32 write(const s128& src) { return write(&src, sizeof(src)); }
        b32 write(const b32& src) { u32 temporary = src._boolean; return write(temporary); }
        b32 writeHeader(const GxRtti* pRtti, u32 objectCount);
        b32 writePropertyId(const GxProperty* pProperty = nullptr);
        b32 writeRttiId(const GxRtti* pRtti = nullptr);
        b32 isFileEnd(void) const { GX_ASSERT(_pStream, "_pStream not initialize!!"); return _pStream->isEnd(); }
        s32 getRemainSize(void) const { GX_ASSERT(_pStream, "_pStream not initialize!!"); return _pStream->getRemainSize(); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        GxStream* _pStream;                         
        Header  _header;                            
 
    };
 
    //===========================================================================
    //===========================================================================
    class GxObjectNode : public GxClassBaseReference
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_CLASS(GxObjectNode, GxClassBaseReference)
        // GxClassBaseReference継承クラス用禁止宣言
        GX_PROHIBIT_CLASS_BASE_REFERENCE(GxObjectNode)
        // new, delete定義
        GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY)
 
    public:
        static constexpr s32 ARRAY_ELEMENT_INDEX_VALUE = -2;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        GxObjectNode(void) : _pObject(nullptr), _pObjectRtti(nullptr), _pPropertyTable(nullptr), _pProperty(nullptr), _pOwner(nullptr), _pObjectInstance(nullptr) {}
 
    public:
        GxObjectNode(void* pObject, const GxRtti* pObjectRtti, GxPropertyTable* pPropertyTable, GxProperty* pProperty, void* pOwner, u32 arrayIndex, b32 isHavingInstance, s32 objectIndex)
            : _pObject(pObject)
            , _pObjectRtti(pObjectRtti)
            , _pPropertyTable(pPropertyTable)
            , _pProperty(pProperty)
            , _pOwner(pOwner)
            , _arrayIndex(arrayIndex)
            , _arrayCount(0)
            , _isHavingInstance(isHavingInstance)
            , _objectIndex(objectIndex)
            , _pObjectInstance(nullptr)
        {}
 
        b32 operator==(const GxObjectNode& node) const;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        b32           isPointerType(void) const;
        constexpr void setObject(void* pObject) { _pObject = pObject; }
        constexpr void* getObject(void) const { return _pObject; }
        constexpr void setObjectRtti(const GxRtti* pObjectRtti) { _pObjectRtti = pObjectRtti; }
        GX_FORCE_INLINE const GxRtti* getObjectRtti(void) const { return _pObjectRtti; }
        constexpr GxPropertyTable* getPropertyTable(void) { return _pPropertyTable; }
        constexpr void setProperty(GxProperty* pProperty) { _pProperty = pProperty; }
        constexpr GxProperty* getProperty(void) const { return _pProperty; }
        constexpr void setOwner(void* pOwner) { _pOwner = pOwner; }
        constexpr void* getOwner(void) const { return _pOwner; }
        constexpr u32 getArrayIndex(void) const { return _arrayIndex; }
        constexpr u32 incrementArrayIndex(void) { return ++_arrayIndex; }
        constexpr void setArrayCount(u32 count) { _arrayCount = count; }
        constexpr u32 getArrayCount(void) const { return _arrayCount; }
        constexpr void setObjectIndex(s32 objectIndex) { _objectIndex = objectIndex; }
        constexpr s32 getObjectIndex(void) const { return _objectIndex; }
        GX_FORCE_INLINE b32 isHavingInstance(void) const { return _isHavingInstance; }
        GX_FORCE_INLINE void setHavingInstance(b32 flag) { _isHavingInstance = flag; }
        constexpr void setObjectInstance(GxObjectNode* pObjectInstance) { _pObjectInstance = pObjectInstance; }
        constexpr GxObjectNode* getObjectInstance(void) const { return _pObjectInstance; }
        GX_FORCE_INLINE b32 isArrayElement(void) const { return (_objectIndex == ARRAY_ELEMENT_INDEX_VALUE); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        void*               _pObject;           
        const GxRtti*       _pObjectRtti;       
        GxPropertyTable*    _pPropertyTable;    
        GxProperty*         _pProperty;         
        void*               _pOwner;            
        u32                 _arrayIndex;        
        u32                 _arrayCount;        
        b32                 _isHavingInstance;  
        s32                 _objectIndex;       
        GxObjectNode*       _pObjectInstance;   
 
    };
 
    //===========================================================================
    //===========================================================================
    class GxObjectTree : public GxTree
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // Rtti定義
        GX_RTTI_CLASS(GxObjectTree, GxTree)
        // GxClassBase継承クラス用禁止宣言
        GX_PROHIBIT_CLASS_BASE(GxObjectTree)
        // new, delete定義
        GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY)
 
        
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxObjectTree(void);
        ~GxObjectTree(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        void initializeForSerialize(GxTypedObject* pObject, const GxRtti* pRtti, GxPropertyTable* pPropertyTable, b32 isDifference);
        void initializeForDeserialize(GxTypedObject* pObject, const GxRtti* pRtti, GxPropertyTable* pPropertyTable);
 
        b32  createObjectList(u32 objectListCount);
 
        void setObjectInstancePointer(void);
 
        void addRoot(GxTypedObject* pObject, const GxRtti* pRtti, GxPropertyTable* pPropertyTable);
        void addChild(GxTypedObject* pObject, const GxRtti* pRtti, GxPropertyTable* pPropertyTable, GxProperty* pProperty, GxTypedObject* pOwner, u32 arrayIndex, b32 isHavingInstance, s32 objectIndex);
 
    private:
        b32 addPropertyObject(GxTypedObject* pOwner, const GxRtti* pOwnerRtti, GxPropertyTable* pPropertyTable, b32 isDifference = false, GxTypedObject* pDefaultObject = nullptr);
        b32 checkCurrentNodeInstance(void);
 
        GxTree::GxNode* findObjectNode(const GxObjectNode* pNode);
        GxTree::GxNode* findObjectNode(s32 objectIndex);
 
        void setObjectNodeIndex(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        constexpr GxTree::GxNode* getCurrentNode(void) { return _pCurrent; }
        constexpr void            setCurrentNode(GxTree::GxNode* pNode) { _pCurrent = pNode; }
        GX_FORCE_INLINE void      setCurrentNodeToParent(void) { _pCurrent = _pCurrent->getParent(); }
        GX_FORCE_INLINE void      setCurrentNodeToChild(void) { _pCurrent = _pCurrent->getChild(); }
        constexpr u32             getObjectIndexCount(void) const { return _objectIndexCount; }
        constexpr void            setObjectList(void* pObject, u32 objectIndex) { _ppObjectList[objectIndex] = pObject; }
        constexpr void* getObjectList(u32 objectIndex) { return _ppObjectList[objectIndex]; }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        GxTree::GxNode* _pCurrent;                      
        void** _ppObjectList;                           
        u32                     _objectListCount;       
        u32                     _objectIndexCount;      
 
    };
 
    // コピー禁止
    GX_PROHIBIT_COPY(GxSerializer)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
public:
    GxSerializer(void);
    ~GxSerializer(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
#if GX_DEVELOP
    b32 serializeXml(GxStream& stream, GxTypedObject* pObject, const GxRtti& rtti, b32 isDifference = false);
    b32 serializeXml(GxStream& stream, GxTypedObject* pObject, GxPropertyTable& propertyTable, b32 isDifference = false);
    b32 serializeJson(GxStream& stream, GxTypedObject* pObject, const GxRtti& rtti, b32 isCompress = false, b32 useRtti = true, b32 isDifference = false);
    b32 serializeJson(GxStream& stream, GxTypedObject* pObject, GxPropertyTable& propertyTable, b32 isDifference = false);
 
    b32 deserializeXml(GxStream& stream, GxTypedObject* pObject, const GxRtti& rtti, b32 isCreatePointerObject = true);
    b32 deserializeXml(GxStream& stream, GxTypedObject* pObject, GxPropertyTable& propertyTable, b32 isCreatePointerObject = true);
    void registerFallbackFunction(GxProperty::PROPERTY_FUNCTION_FROM_STRING pFunction);
    b32 deserializeJson(GxStream& stream, GxTypedObject* pObject, const GxRtti& rtti, b32 isCreatePointerObject = true);
    b32 deserializeJson(GxStream& stream, GxTypedObject* pObject, GxPropertyTable& propertyTable, b32 isCreatePointerObject = true);
#endif  // GX_DEVELOP
    b32 serializeBinary(GxStream& stream, GxTypedObject* pObject, const GxRtti& rtti, b32 isDifference = false);
    b32 serializeBinary(GxStream& stream, GxTypedObject* pObject, GxPropertyTable& propertyTable, b32 isDifference = false);
    b32 deserializeBinary(GxStream& stream, GxTypedObject* pObject, const GxRtti& rtti);
    b32 deserializeBinary(GxStream& stream, GxTypedObject* pObject, GxPropertyTable& propertyTable);
 
private:
#if GX_DEVELOP
    b32 serializeObjectXml(GxTypedObject* pObject, GxPropertyTable* pPropertyTable, b32 isDifference = false, GxTypedObject* pDefaultObject = nullptr);
    b32 serializeObjectJson(GxTypedObject* pObject, GxPropertyTable* pPropertyTable, GxJson* pJson, GxJson::GxJsonObject* pCurrentObject, b32 useRtti = true, b32 isDifference = false, GxTypedObject* pDefaultObject = nullptr);
    b32 deserializeObjectXml(GxTypedObject* pObject, GxPropertyTable* pPropertyTable);
    b32 deserializeObjectJson(GxTypedObject* pObject, GxPropertyTable* pPropertyTable, const GxJson::GxJsonNode& rootJsonNode);
    b32 checkDeserializeObjectBinary(GxTypedObject* pObject, GxPropertyTable* pPropertyTable);
#endif  // GX_DEVELOP
    b32 serializeObjectBinary(GxTypedObject* pObject, GxPropertyTable* pPropertyTable, b32 isDifference = false);
    b32 deserializeObjectBinary(GxTypedObject* pObject, GxPropertyTable* pPropertyTable);
 
    b32 initializeBinary(GxStream& stream);
    void terminateBinary(void);
 
#if GX_DEVELOP
    b32 initializeXmlParser(GxStream& stream);
    void terminateXmlParser(void);
    b32 initializeXMLWriter(GxStream& stream);
    void terminateXMLWriter(void);
 
    b32 registerTreeObjectProperty(GxTypedObject* pObject, const GxRtti& rtti); 
 
    static void GX_XML_CDECL callbackStartElement(void* pUserData, GX_CSTR elementName, GX_CSTR* ppAttributes);
    static void GX_XML_CDECL callbackEndElement(void* pUserData, GX_CSTR elementName);
 
    static b32 isElementType(GX_CSTR elementTag, XML_ELEMENT_TYPE xmlElementType);
    static b32 isAttributeType(GX_CSTR attributeTag, XML_ATTRIBUTE_TYPE xmlAttributeType);
 
    GX_CSTR getRootObjectName(void) const;
    GX_CSTR getStartElementAttribute(GX_CSTR* ppAttributes, XML_ATTRIBUTE_TYPE type, u32 paramIndex = 0);
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    b32                     _isFailed;                                              
    u32                     _depthFailed;                                           
    b32                     _isCreatePointerObject;                                 
    GxObjectTree*           _pObjectTree;                                           
 
    GxBinarySerializer*     _pBinarySerializer;                                     
 
#if GX_DEVELOP
    GxXmlParser*            _pXmlParser;                                            
    GxXmlWriter*            _pXmlWriter;                                            
    s32                     _startElementAttributeIndex[static_cast<s32>(XML_ATTRIBUTE_TYPE::MAX)]; 
    GxProperty::PROPERTY_FUNCTION_FROM_STRING  _pFallbackFunction;                  
#endif  // GX_DEVELOP
 
};
 
GX_CORE_NAMESPACE_END()