GxXml.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#if GX_DEVELOP
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
#if defined(_MSC_EXTENSIONS) // expat_external.h 参照
#define GX_XML_CDECL __cdecl
#else //_MSC_EXTENSIONS
#define GX_XML_CDECL
#endif // !_MSC_EXTENSIONS
 
typedef void (GX_XML_CDECL* GxXmlStartElementHandler)   (void* userData, GX_CSTR name, GX_CSTR* pAttribute);
typedef void (GX_XML_CDECL* GxXmlEndElementHandler)     (void* userData, GX_CSTR name);
typedef void (GX_XML_CDECL* GxXmlCharacterDataHandler)  (void* userData, GX_CSTR name, s32 len);
 
struct GxXmlMemoryHandlingSuite
{
    void *(*mallocFunction)(size_t size);
    void *(*reallocFunction)(void* pointer, size_t size);
    void (*freeFunction)(void* pointer);
};
 
//===========================================================================
//===========================================================================
class GxXmlParser : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxXmlParser, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxXmlParser)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
    
    static constexpr u32 STRING_LENGTH = GxFile::FILE_PATH_MAX;
 
protected:
    enum class STATE
    {
        NONE = 0,                                   
        START_ELEMENT,                              
        CHARACTER_DATA,                             
        END_ELEMENT                                 
    };
 
protected:
    class GxLocalAllocator
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    protected:
        GxLocalAllocator(void);
    public:
        GxLocalAllocator(GxLocalAllocator* pPrevious, u32 size);
        ~GxLocalAllocator(void);
 
    private:
        GxLocalAllocator(const GxLocalAllocator&);
        GX_FORCE_INLINE const GxLocalAllocator& operator=(const GxLocalAllocator&);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        void* allocateMemory(u32 size);
        constexpr void  freeMemory(void* /*pAddress*/) {}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    private:
        GxLocalAllocator*   _pNext;                     
        void*               _pBuffer;                   
        void*               _pFree;                     
        u32                 _size;                      
 
    };
 
public:
    class GxAttribute
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxAttribute(void) : _name(nullptr), _value(nullptr) {}
        ~GxAttribute(void) {}
 
    private:
        GxAttribute(const GxAttribute&);
        GX_FORCE_INLINE const GxAttribute& operator=(const GxAttribute&);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GX_CSTR getName(void) const;
        void    setName(GX_CSTR name);
        GX_STR  getValue(void);
        GX_CSTR getValue(void) const;
        void    setValue(GX_CSTR value, u32 stringEncode);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    private:
        GX_STR              _name;                          
        GX_STR              _value;                         
 
    };
 
    //===========================================================================
    //===========================================================================
    class GxElement
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        static constexpr u32 ATTRIUBUTE_MAX = 6;                
        static constexpr u32 ELEMENT_NAME_LENGTH_MAX = 32;      
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GxElement(void) : _name(nullptr), _attributeNum(0) { GX_MEMSET(_pAttribute, 0, sizeof(_pAttribute)); }
        ~GxElement(void) {}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GX_CSTR getName(void) const;
        void    setName(GX_CSTR name);
        u32     getAttributeNum(void) const;
        const GxAttribute* getAttribute(u32 index) const;
        const GxAttribute* getAttribute(GX_CSTR name) const;
        GX_CSTR getAttributeValue(GX_CSTR name) const;
        void    addAttribute(GX_CSTR name, GX_CSTR value, u32 stringEncode);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    private:
        GX_STR              _name;                          
        u32                 _attributeNum;                  
        GxAttribute* _pAttribute[ATTRIUBUTE_MAX];           
 
    };
 
    //===========================================================================
    //===========================================================================
    class GxNode
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GxNode(void) : _pChild(nullptr)
            , _pParent(nullptr)
            , _pNext(nullptr)
            , _pPrevious(nullptr)
            , _string(nullptr)
        {}
        ~GxNode(void) {}
 
    private:
        GxNode(const GxElement&);
        GX_FORCE_INLINE const GxNode& operator=(const GxNode&);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        constexpr GxNode* getChild(void) const { return _pChild; }
        constexpr void setChild(GxNode* pChild) { _pChild = pChild; }
        constexpr GxNode* getParent(void)   const { return _pParent; }
        constexpr void setParent(GxNode* pParent) { _pParent = pParent; }
        constexpr GxNode* getNext(void) const { return _pNext; }
        constexpr void setNext(GxNode* pNext) { _pNext = pNext; }
        constexpr GxNode* getPrevious(void) const { return _pPrevious; }
        constexpr void setPrevious(GxNode* pPrevious) { _pPrevious = pPrevious; }
        GX_FORCE_INLINE GxElement* getElement(void) { return &_element; }
        GX_FORCE_INLINE const GxElement* getElement(void) const { return &_element; }
        GX_FORCE_INLINE void setElement(const GxElement& element) { _element = element; }
        constexpr GX_CSTR getString(void) const { return _string; }
        void       setString(GX_CSTR string, u32 length);
        GxNode* addChild(void);
        GxNode* addNext(void);
        const GxNode* findNode(GX_CSTR elementName, b32 isSkipTopNode = false)      const;
        const GxNode* findNodeChild(GX_CSTR elementName, b32 isSkipTopNode = false, b32 isSkipNextNode = false) const;
        const GxNode* findNodeNext(GX_CSTR elementName, b32 isSkipTopNode = false)  const;
        const GxNode* findNode(GX_CSTR elementName, GX_CSTR attribute, GX_CSTR value, b32 isSkipTopNode = false)        const;
        const GxNode* findNodeChild(GX_CSTR elementName, GX_CSTR attribute, GX_CSTR value, b32 isSkipTopNode = false)   const;
        const GxNode* findNodeNext(GX_CSTR elementName, GX_CSTR attribute, GX_CSTR value, b32 isSkipTopNode = false)    const;
        u32      countNode(GX_CSTR elementName, GX_CSTR attribute, GX_CSTR value)       const;
        u32      countNodeChild(GX_CSTR elementName, GX_CSTR attribute, GX_CSTR value)  const;
        u32      countNodeNext(GX_CSTR elementName, GX_CSTR attribute, GX_CSTR value)   const;
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    private:
        GxNode*     _pChild;                            
        GxNode*     _pParent;                           
        GxNode*     _pNext;                             
        GxNode*     _pPrevious;                         
        GxElement   _element;                           
        GX_STR      _string;                            
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxXmlParser(void);
    ~GxXmlParser(void) override { terminate(); }
 
    b32 initialize(GxStream& stream);
    void terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void addStartElement(GX_CSTR elementName);
    void addAttribute(GX_CSTR attribute, GX_CSTR value);
    void addValue(GX_CSTR value, u32 length = 0);
    void addEndElement(void);
 
    void setDefaultHandler(void);
    void setUserHandler(void* pUserData, GxXmlStartElementHandler startElementHandler, GxXmlEndElementHandler endElementHandler, GxXmlCharacterDataHandler characterDataHandler);
    void read(void);
 
protected:
    GX_FORCE_INLINE static void* xmlMalloc(size_t size) { return GX_ALLOCATE_MEMORY(getGxAllocatorList(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP), static_cast<u32>(size)); }
    GX_FORCE_INLINE static void  xmlFree(void* pAddress) { GX_SAFE_FREE_MEMORY(pAddress); }
    GX_FORCE_INLINE static void* xmlRealloc(void* pAddress, size_t size) { return GX_REALLOC_MEMORY(pAddress, static_cast<u32>(size)); }
 
private:
    static void GX_XML_CDECL callbackStartElement(void* pUserData, GX_CSTR elementName, GX_CSTR* pAttributes);
    static void GX_XML_CDECL callbackEndElement(void* pUserData, GX_CSTR elementName);
    static void GX_XML_CDECL callbackCharacterData(void* pUserData, GX_CSTR data, s32 length);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GxNode* getRootNode(void) const { return _pRootNode; }
    constexpr u32 getDepth(void) const { return _depth; }
    
#if defined(GX_THREAD_LOCAL_STORAGE)
    static constexpr void setActiveAllocator(GxLocalAllocator* pLocalAllocator) { _pActiveAllocator = pLocalAllocator; }
    GX_FORCE_INLINE static GxLocalAllocator* getActiveAllocator(void)   { return _pActiveAllocator; }
#else //GX_THREAD_LOCAL_STORAGE
    GX_FORCE_INLINE static const void setActiveAllocator(GxLocalAllocator* pLocalAllocator) { _pActiveAllocator[GxThread::getCurrentThread()->getIndex()] = pLocalAllocator; }
    GX_FORCE_INLINE static GxLocalAllocator* getActiveAllocator(void) { return _pActiveAllocator[GxThread::getCurrentThread()->getIndex()]; }
#endif // !GX_THREAD_LOCAL_STORAGE
    constexpr void setStringEncode(u32 encode) { _stringEncode = encode; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    void*                                   _pParser;                   
    void*                                   _pUserData;                 
    GxXmlStartElementHandler                _pUserStartElementHandler;  
    GxXmlEndElementHandler                  _pUserEndElementHandler;    
    GxXmlCharacterDataHandler               _pUserCharacterDataHandler; 
    GxNode*                                 _pRootNode;                 
    GxNode*                                 _pCurrentNode;              
    GxStream*                               _pStream;                   
    u32                                     _depth;                     
 
private:
    static const GxXmlMemoryHandlingSuite _xmlFunctions;                
#if defined(GX_THREAD_LOCAL_STORAGE)
    static GX_THREAD_LOCAL_STORAGE GxLocalAllocator* _pActiveAllocator; 
#else //GX_THREAD_LOCAL_STORAGE
    static GxLocalAllocator* _pActiveAllocator[GxThread::THREAD_MAX];   
#endif // !GX_THREAD_LOCAL_STORAGE
 
    GxLocalAllocator*                       _pLocalAllocator;           
    GxLocalAllocator*                       _pOldAllocator;             
    u32                                     _stringEncode;              
 
};
 
//===========================================================================
//===========================================================================
class GxXmlWriter : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxXmlWriter, GxClassBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxXmlWriter)
 
protected:
    enum class STATE
    {
        NONE = 0,                                   
        DECLARATION,                                
        START_ELEMENT,                              
        VALUE,                                      
        END_ELEMENT                                 
    };
 
    static constexpr u32 ELEMENT_ARRAY_RESERVE_SIZE = GxMath::VALUE_4K;     
 
    static GX_CSTR XML_DECLARATION_STRING;                  
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxXmlWriter(void);
    ~GxXmlWriter(void) override { terminate(); }
 
    b32 initialize(GxStream& stream, b32 isWriteBOM = false);
    void terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 writeXmlDeclaration(void);
    b32 writeStartElement(GX_CSTR elementName);
    b32 writeAttribute(GX_CSTR attributeName, GX_CSTR value);
    b32 writeValue(GX_CSTR value, u32 length = 0);
    b32 writeEndElement(void);
 
protected:
    b32 writeXmlBOM(void);
    b32 writeXmlTabs(void);
    b32 writeXmlSpace(void);
    b32 writeXmlReturn(void);
    b32 writeXmlString(GX_CSTR string);
    b32 writeXmlStartElementTop(void);
    b32 writeXmlStartElementEnd(void);
    b32 writeXmlStartElementEndForOnlyStartElement(void);
    b32 writeXmlEndElementTop(void);
    b32 writeXmlEndElementEnd(void);
    b32 writeXmlAttributeValueStart(void);
    b32 writeXmlAttributeValueEnd(void);
    GX_FORCE_INLINE void setWriteXmlTabs(b32 enable) { _isWriteXmlTabs = enable; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr void setStringEncode(u32 encode) { _stringEncode = encode; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxStreamWriter*             _pStreamWriter;             
    GxArray                     _elementArray;              
    STATE                       _state;                     
    u32                         _depth;                     
    b32                         _isWriteXmlTabs;            
    u32                         _stringEncode;              
 
};
 
GX_CORE_NAMESPACE_END()
 
#endif  // GX_DEVELOP