fsCXml.h

Go to the documentation of this file.

/********************************************************************
*
*       Created:        16/5/2012   16:59
*
*       File:           fsCXml.h
*
*       Author:         Mick Waites
*       
*       Purpose:        Xml parsing. Sourced from IwGame.
*
*********************************************************************/
 
#ifndef fsCXmlhdr
#define fsCXmlhdr
 
#include <cstring>
 
#include <fsCore/src/debug/fsAssert.h>
#include <fsCore/src/fsCUniqueId.h>
 
#include "fsStr.h"
#include "fsCXmlFileReader.h"
 
#include <list>
 
class fsCResourceName;
 
struct fsXmlAttribute;
struct fsXmlNode;
 
//
//
//
// Type definitions provided for ease of code reading
//
//
//
typedef std::list<fsXmlAttribute*> fsXmlAttributeList;
typedef std::list<fsXmlNode*> fsXmlNodeList;
typedef std::list<fsStr*> fsXmlStringList;
typedef std::list<int> fsXmlIntList;
typedef std::list<float> fsXmlFloatList;
typedef std::list<bool> fsXmlBoolList;
 
//
//
//
// General tools used by all CIwGameXml classes
//
//
//
class fsXmlTools
{
public:
        static int GetFirstWhitespaceIndex(char* pMem, int len);
};
 
//
//
//
// An Xml attribute, e.g. <Something attribute="some value" />
//
//
//
struct fsXmlAttribute
{
public:
        bool Managed; // Managed attributes are managed by the pools system and should not be deleted
        fsStr Name; // Attributes name
        fsStr Value; // Attributes value
 
public:
        fsXmlAttribute() : Managed(true)
        {
        }
 
        ~fsXmlAttribute()
        {
        }
 
        void Clear()
        {
                Name = "";
                Value = "";
        }
 
        void setName(const char* pName)
        {
                Name.copy(pName, 0, std::strlen(pName));
        }
 
        void setName(char* pName, int len)
        {
                Name.copy(pName, 0, len);
        }
 
        fsStr& getName() { return Name; }
 
        void setValue(const char* pValue)
        {
                Value.copy(pValue, 0, std::strlen(pValue));
                Value.hTMLCodesReplace();
        }
 
        void setValue(char* pValue, int len)
        {
                Value.copy(pValue, 0, len);
                Value.hTMLCodesReplace();
        }
 
        // Single attribute element getters
        fsStr& GetValue() { return Value; }
        int GetValueAsInt() const;
        //      float                           GetValueAsFloat() const;
        //      bool                            GetValueAsBool() const;
        //      bool                            GetValueAsPoint(fsPoint &point);
        //      bool                            GetValueAsPoint3(CIwFVec3 &point);
        //      bool                            GetValueAsPoint4(CIwFVec4 &point);
        //      bool                            GetValueAsColour(CIwColour &colour);
        //      bool                            GetValueAsRect(CIwRect &rect);
 
        // List attribute element getters (generates a list from comma separated attribute data
        fsXmlStringList* GetValueAsList();
};
 
//
//
//
// An Xml node, e.g. <XmlNode></XmlNode>
//
//
//
struct fsXmlNode
{
public:
        typedef std::list<fsXmlNode*>::iterator _Iterator;
        typedef std::list<fsXmlAttribute*>::iterator _AttribIterator;
        _Iterator begin() { return Children.begin(); }
        _Iterator end() { return Children.end(); }
        _AttribIterator attribs_begin() { return Attributes.begin(); }
        _AttribIterator attribs_end() { return Attributes.end(); }
 
public:
        bool Managed; // Managec nodes are managed by the pools system and should not be deleted
        fsStr Name; // Node name
        fsStr Value; // Node value
        bool HasValue; // Determines if value is valid
        fsXmlAttributeList Attributes; // List of attributes associated with this node
        fsXmlNode* Parent; // Parent node
        fsXmlNodeList Children; // List of children nodes
 
public:
        fsXmlNode() : Managed(true), HasValue(false), Parent(nullptr)
        {
        }
 
        ~fsXmlNode();
 
        void Clear()
        {
                Name = "";
                Value = "";
                Attributes.clear();
                Parent = nullptr;
                Children.clear();
                HasValue = false;
        }
 
        void AddChild(fsXmlNode* node)
        {
                node->Parent = this;
                Children.push_back(node);
        }
 
        void AddAttribute(fsXmlAttribute* attribute);
        void AddAttribute(fsStr& name, fsStr& value);
        void AddAttribute(fsStr& name, const char* value);
        void UpdateAttribute(fsStr& name, const char* value);
 
        void SetName(const char* name)
        {
                Name.copy((char*)name, 0, std::strlen(name));
        }
 
        void SetName(const char* name, int len)
        {
                Name.copy((char*)name, 0, len);
        }
 
        void SetValue(const char* value)
        {
                Value.copy((char*)value, 0, std::strlen(value));
                Value.hTMLCodesReplace();
                HasValue = true;
        }
 
        void SetValue(const char* value, int len)
        {
                Value.copy((char*)value, 0, len);
                Value.hTMLCodesReplace();
                HasValue = true;
        }
 
        const fsStr& GetName() const { return Name; }
 
        // Single value getters (data between tags)
        const fsStr& GetValue() const { return Value; }
        int GetValueAsInt() const;
        //      float                                   GetValueAsFloat() const;
        //      bool                                    GetValueAsBool() const;
 
        // Print attributes / tree (DEBUG)
        void PrintAttributes();
        void PrintTree(int level = 0);
 
        // Get first child node
        fsXmlNode* GetFirstNode();
        // Get first occurrence of a node in this node and all children
        fsXmlNode* GetFirstNamedNode(const char* pNodeName, unsigned int pNameHash);
        // Get all occurrences of a node in this node and all children
        void GetNamedNodes(const char* pNodeName, unsigned int pNameHash, fsXmlNodeList* pNodes);
 
        // Gets attribute count
        int GetAttributeCount() const { return Attributes.size(); }
        // Gets the named attribute
        fsXmlAttribute* GetAttribute(const char* name);
        // Gets the Nth attribute
        fsXmlAttribute* GetAttribute(int index);
 
        // Save XML file
        //      int                                             SaveAttributes(std::shared_ptr<fsIFile> file);
        //      int                                             SaveTree(std::shared_ptr<fsIFile> file, int level = 0);
        //      int                                             Save(const char* filename);
 
        // Tag / attribute case chnage (does not change the case of attribute values)
        void ToLower(bool recursive);
        void ToUpper(bool recursive);
 
        // Tree cloning
        void Copy(fsXmlNode* copy);
        fsXmlNode* Clone(fsXmlNode* parent);
        fsXmlNode* CloneTree(fsXmlNode* parent);
};
 
enum eVpXmlParserError
{
        eVpXmlParserError_None,
        eVpXmlParserError_NoTagFound,
        eVpXmlParserError_FileError,
        eVpXmlParserError_MissingEndTag,
        eVpXmlParserError_MissingEndComment,
        eVpXmlParserError_MismatchedEndTag,
        eVpXmlParserError_MissingEquals,
        eVpXmlParserError_MissingValue,
        eVpXmlParserError_MissingClosingQuote,
        eVpXmlParserError_InvalidTag,
        eVpXmlParserError_InvalidComment,
        eVpXmlParserError_PreParseError,
        eVpXmlParserError_InvalidPools,
};
 
struct fsXmlTagMarker
{
        int Start;
        int Length;
 
        void Clear()
        {
                Start = 0;
                Length = 0;
        }
};
 
//
//
//
// The Xml parser
//
//
//
class fsXmlParser
{
public:
 
private:
        fsStr m_Encoding; // Encoding type
        fsStr m_Version; // XML version
        fsCXmlFileReader* m_pDataInput; // Input stream
        fsXmlNode* m_pRoot; // Root node
        fsXmlTagMarker* Marker;
        int MarkerCount;
 
        std::list<fsXmlNode*>::iterator RemoveNodeFromList(std::list<fsXmlNode*>& list,
                                                           const std::list<fsXmlNode*>::iterator& it);
public:
        fsXmlParser() : m_pDataInput(nullptr), m_pRoot(nullptr), Marker(nullptr), MarkerCount(0)
        {
        }
 
        virtual ~fsXmlParser()
        {
                if (m_pDataInput != nullptr)
                        delete m_pDataInput;
        }
 
        void SetEncoding(const char* encoding) { m_Encoding = encoding; }
        const fsStr& GetEncoding() const { return m_Encoding; }
        void SetVersion(const char* version) { m_Version = version; }
        const fsStr& GetVersion() const { return m_Version; }
 
        static fsXmlNode* AllocNode()
        {
                if (NodePool == nullptr)
                        return new fsXmlNode();
                if (NextFreePoolNodeIndex >= (MaxPoolNodes - 1))
                {
                        fsAssert(false, "Error: Ran out of nodes, allocate more");
                        return nullptr;
                }
                fsXmlNode* node = NodePool + NextFreePoolNodeIndex++;
                node->Clear();
 
                return node;
        }
 
        static fsXmlTagMarker* AllocTag()
        {
                if (TagPool == nullptr)
                        return new fsXmlTagMarker();
                if (NextFreePoolTagIndex >= (MaxPoolTags - 1))
                {
                        fsAssert(false, "Error: Ran out of tag markers, allocate more");
                        return nullptr;
                }
                fsXmlTagMarker* tag = TagPool + NextFreePoolTagIndex++;
                tag->Clear();
 
                return tag;
        }
 
        static fsXmlAttribute* AllocAttribute()
        {
                if (AttributePool == nullptr)
                        return new fsXmlAttribute();
                if (NextFreePoolAttributeIndex >= (MaxPoolAttributes - 1))
                {
                        fsAssert(false, "Error: Ran out of attributes, allocate more");
                        return nullptr;
                }
                fsXmlAttribute* attribute = AttributePool + NextFreePoolAttributeIndex++;
                attribute->Clear();
 
                return attribute;
        }
 
        // Parse the supplied file
        eVpXmlParserError Parse(const fsCResourceName& pFilename);
 
        // Parse the supplied memory buffer
        eVpXmlParserError Parse(fsCXmlFileReader* pData); // This class becomes owner of CDataInput object
 
        // Return XML error string
        const char* GetErrorString(eVpXmlParserError error) const;
 
        // Get root node (note that root node is '.' and not the first XML tag)
        fsXmlNode* GetRoot()
        {
                return m_pRoot;
        }
 
        // Get first occurrence of a node in this node and all children
        fsXmlNode* GetFirstNamedNode(fsXmlNode* parent, const char* node_name)
        {
                if (parent == nullptr)
                        parent = GetRoot();
 
                int hash = fsCUniqueId::idCalculate(node_name);
                if (parent != nullptr)
                        return parent->GetFirstNamedNode(node_name, hash);
                if (m_pRoot != nullptr)
                        return m_pRoot->GetFirstNamedNode(node_name, hash);
 
                return nullptr;
        }
 
        // Get all occurrences of a node in this node and all children (caller is responsible for cleaning up list)
        // Pass NULL as pNodeName to return all nodes
        fsXmlNodeList* GetNamedNodes(fsXmlNode* parent, const char* node_name)
        {
                if (parent == nullptr)
                        parent = GetRoot();
 
                int hash = fsCUniqueId::idCalculate(node_name);
                fsXmlNodeList* pNodes = new fsXmlNodeList;
                if (parent != nullptr)
                        parent->GetNamedNodes(node_name, hash, pNodes);
                else if (m_pRoot != nullptr)
                        m_pRoot->GetNamedNodes(node_name, hash, pNodes);
 
                return pNodes;
        }
 
private:
        eVpXmlParserError ParseXMLHeader();
        eVpXmlParserError ParseAttributes(const char* data, int count, fsXmlNode* node);
        bool PreParse();
        eVpXmlParserError Parse(fsXmlNode* parent);
 
        eVpXmlParserError ParseAttributes(fsXmlNode* node);
        eVpXmlParserError Parse(fsXmlNode* pParent, int range, int& num_tags_found);
        const char* GetCloseTagName(fsXmlNode* node) const;
        void ShowError(eVpXmlParserError error, int pos) const;
 
        int GetNextWord(const char* data, int& offset);
        int GetNextQuotedWord(const char* data, int& offset);
 
        // Tag and node pooling
public:
        static fsXmlTagMarker* TagPool; // Used to separate tags from the raw XML file
        static int NextFreePoolTagIndex;
        static int MaxPoolTags;
        static fsXmlNode* NodePool; // Xml nodes pool
        static int NextFreePoolNodeIndex; // Bext free node index in nodes pool
        static int MaxPoolNodes; // Maximum available nodes in the nodes pool
        static fsXmlAttribute* AttributePool; // Xml attribute pool
        static int NextFreePoolAttributeIndex; // Bext free attribute index in nodes pool
        static int MaxPoolAttributes; // Maximum available attributes in the attributes pool
public:
        static void PoolsInit(int node_pool_size = 2048, int tag_pool_size = 2048, int attribute_pool_size = 4096)
        {
                NodePool = new fsXmlNode[node_pool_size]();
                MaxPoolNodes = node_pool_size;
                NextFreePoolNodeIndex = 0;
                TagPool = new fsXmlTagMarker[tag_pool_size]();
                MaxPoolTags = tag_pool_size;
                NextFreePoolTagIndex = 0;
                AttributePool = new fsXmlAttribute[attribute_pool_size]();
                MaxPoolAttributes = attribute_pool_size;
                NextFreePoolAttributeIndex = 0;
                mPoolsSize = node_pool_size;
        }
 
        static void PoolsDestroy()
        {
                if (TagPool != nullptr)
                {
                        delete []TagPool;
                        TagPool = nullptr;
                }
                if (NodePool != nullptr)
                {
                        delete []NodePool;
                        NodePool = nullptr;
                }
                if (AttributePool != nullptr)
                {
                        delete []AttributePool;
                        AttributePool = nullptr;
                }
        }
 
        static void PoolsReset()
        {
                NextFreePoolNodeIndex = 0;
                NextFreePoolTagIndex = 0;
                NextFreePoolAttributeIndex = 0;
        }
 
        static fsS32 PoolsSizeGet()
        {
                return mPoolsSize;
        }
 
        static fsS32 mPoolsSize;
};
 
#endif