cXmlDocument.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cXmlDocument_H
#define _INC_cXmlDocument_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cXml.h"
#include "GrayCore/include/CList.h"
#include "GrayCore/include/cNonCopyable.h"
#include "GrayCore/include/cTextPos.h"
#include "GrayCore/include/cStream.h"
 
namespace GrayLib
{
        class cXmlContainer;
        class cXmlReader;
        struct IXmlVisitor;     // OnVisit
 
        // forward declare XMLNODE_TYPE types.
#define cXmlNodeTypeDEF(a,b,c) class cXml##a;
#include "cXmlNodeTypes.tbl"
#undef cXmlNodeTypeDEF
 
        class GRAYLIB_LINK cXmlNode : public cListNodeT<cXmlNode>, public cXml, protected cNonCopyable
        {
 
        protected:
                const XMLNODE_TYPE m_eNodeType;
                cXmlString m_sValue;            
                void* m_pUserData;                      
 
        public:
                cTextPos m_Pos;                 
 
        protected:
                cXmlNode(XMLNODE_TYPE eNodeType, cXmlString sValue = "");
 
                virtual void SetCopy(const cXmlNode& n);
 
        public:
                virtual ~cXmlNode();
 
                XMLNODE_TYPE get_Type() const
                {
                        return m_eNodeType;
                }
                bool isType(XMLNODE_TYPE eType) const
                {
                        return m_eNodeType == eType;
                }
 
                void put_UserData(void* pUserData)
                {
                        m_pUserData = pUserData;
                }
                void* get_UserData() const
                {
                        return m_pUserData;
                }
 
                virtual void SetClear();
 
                void put_Value(cXmlString sValue)
                {
                        m_sValue = sValue;
                }
                const cXmlString& get_Value() const
                {
                        return m_sValue;
                }
 
                HRESULT QueryValueInt(int* piValue) const;
 
                HRESULT QueryValueDouble(double* pdValue) const;
 
                int get_ValueInt() const;                       
                double get_ValueDouble() const;         
 
                void put_ValueInt(int iValue);                  
                void put_ValueDouble(double dValue);            
 
                cXmlDocument* get_Document() const;
 
                cXmlNode* GetPreviousSibling(const char* pszValue) const;
 
                cXmlNode* GetNextSiblingX(const char* pszValue) const;
 
                cXmlElement* get_NextSiblingElement() const;
 
                cXmlElement* GetNextSiblingElement(const char* pszValue) const;
 
                virtual cXmlContainer* ToContainer()
                {
                        return nullptr;
                }
 
#if 1
#define cXmlNodeTypeIMPL(a,b) \
        virtual cXml##a* To##a() { return b; } \
        virtual const cXml##a* To##a() const { return b; }
 
#define cXmlNodeTypeDEF(a,b,c) cXmlNodeTypeIMPL(a,nullptr)
#include "cXmlNodeTypes.tbl"
#undef cXmlNodeTypeDEF
 
#else
#define cXmlNodeTypeIMPL(a,b)
#endif
 
                virtual cXmlNode* Clone() const = 0;
 
                virtual HRESULT SetParseNode(cXmlReader& rReader) = 0;
                HRESULT SetParse(const char* pszData, CXML_ENCODING_TYPE eEncoding = CXML_ENCODING_UNKNOWN);
 
                virtual HRESULT Print(cStreamOutput& rOut, int nDepth = 0) const = 0;
                static HRESULT PrintDepth(cStreamOutput& rOut, int nDepth);
 
                //
                virtual bool OnVisit(IXmlVisitor* pVisitor) const = 0;
 
 
                ITERATE_t get_Row() const
                {
                        return m_Pos.get_Line1();
                }
                StrLen_t get_Column() const
                {
                        return m_Pos.get_Column1();
                }
        };
 
        class GRAYLIB_LINK cXmlComment : public cXmlNode
        {
 
        public:
                cXmlComment() : cXmlNode(cXmlNode::XMLNODE_Comment)
                {
                }
                cXmlComment(cXmlString sValue) : cXmlNode(cXmlNode::XMLNODE_Comment, sValue)
                {
                }
                cXmlComment(const cXmlComment&);
 
                void operator=(const cXmlComment& rCopy)
                {
                        SetClear();
                        SetCopy(rCopy);
                }
 
                virtual ~cXmlComment()
                {}
 
                virtual cXmlNode* Clone() const;
 
                // Attribute parsing starts: at the ! of the !--
                // returns: next char past '>'
                virtual HRESULT SetParseNode(cXmlReader& rReader);
 
                // Write this Comment to a cStreamOutput stream.
                virtual HRESULT Print(cStreamOutput& rOut, int nDepth = 0) const;
 
                virtual bool OnVisit(IXmlVisitor* visitor) const;
 
                cXmlNodeTypeIMPL(Comment, this);
        };
 
        class GRAYLIB_LINK cXmlText : public cXmlNode
        {
 
                friend class cXmlElement;
                typedef cXmlNode SUPER_t;
 
        private:
                bool m_bCDATA;                  
 
        protected:
                virtual void SetCopy(const cXmlText& n);
                virtual void SetClear()
                {
                        m_bCDATA = false;
                        SUPER_t::SetClear();
                }
 
                // [internal use]
                bool isBlank() const;   
 
        public:
                cXmlText(cXmlString sValue = "", bool bCDATA = false)
                        : cXmlNode(cXmlNode::XMLNODE_Text, sValue)
                        , m_bCDATA(bCDATA)
                {
                }
                virtual ~cXmlText()
                {}
 
                cXmlText(const cXmlText& rCopy)
                        : cXmlNode(cXmlNode::XMLNODE_Text)
                {
                        SetCopy(rCopy);
                }
 
                void operator=(const cXmlText& rCopy)
                {
                        SetClear();
                        SetCopy(rCopy);
                }
 
                bool isCDATA() const
                {
                        return m_bCDATA;
                }
                void put_CDATA(bool bCDATA)
                {
                        m_bCDATA = bCDATA;
                }
 
                virtual cXmlNode* Clone() const;
 
                virtual HRESULT SetParseNode(cXmlReader& rReader);
 
                virtual HRESULT Print(cStreamOutput& rOut, int nDepth = 0) const;
 
                virtual bool OnVisit(IXmlVisitor* content) const;
 
                cXmlNodeTypeIMPL(Text, this);
        };
 
        class GRAYLIB_LINK cXmlDeclaration : public cXmlNode
        {
 
                typedef cXmlNode SUPER_t;
 
        public:
                static const char k_pszVersion[];
                static const char k_pszEncoding[];
                static const char k_pszStandalone[];
 
        private:
                cXmlString m_sEncoding;
                cXmlString m_sStandalone;
 
        protected:
                virtual void SetCopy(const cXmlDeclaration& n);
                virtual void SetClear()
                {
                        m_sEncoding = "";
                        m_sStandalone = "";
                        SUPER_t::SetClear();
                }
 
        public:
                cXmlDeclaration(cXmlString sVersion = "1.0", cXmlString sEncoding = "", cXmlString sStandalone = "");
 
                cXmlDeclaration(const cXmlDeclaration& rCopy);
                void operator=(const cXmlDeclaration& rCopy)
                {
                        SetClear();
                        SetCopy(rCopy);
                }
 
                virtual ~cXmlDeclaration()
                {}
 
                const cXmlString& get_Version() const
                {
                        return m_sValue;
                }
                const cXmlString& get_Encoding() const
                {
                        return m_sEncoding;
                }
                const cXmlString& get_Standalone() const
                {
                        return m_sStandalone;
                }
 
                CXML_ENCODING_TYPE get_EncodingEnum() const;
 
                virtual cXmlNode* Clone() const;
 
                virtual HRESULT SetParseNode(cXmlReader& rReader);
 
                cXmlString get_PrintStr() const;
                virtual HRESULT Print(cStreamOutput& rOut, int nDepth = 0) const
                {
                        UNREFERENCED_PARAMETER(nDepth);
                        return rOut.WriteString(get_PrintStr());
                }
 
                virtual bool OnVisit(IXmlVisitor* visitor) const;
 
                cXmlNodeTypeIMPL(Declaration, this);
        };
 
        class GRAYLIB_LINK cXmlUnknown : public cXmlNode
        {
 
        public:
                cXmlUnknown(cXmlString sValue = "") : cXmlNode(cXmlNode::XMLNODE_Unknown, sValue)
                {}
                virtual ~cXmlUnknown()
                {}
 
                cXmlUnknown(const cXmlUnknown& rCopy) : cXmlNode(cXmlNode::XMLNODE_Unknown)
                {
                        SetCopy(rCopy);
                }
                void operator=(const cXmlUnknown& rCopy)
                {
                        SetClear();
                        SetCopy(rCopy);
                }
 
                virtual cXmlNode* Clone() const;
 
                virtual HRESULT SetParseNode(cXmlReader& rReader);
 
                virtual HRESULT Print(cStreamOutput& rOut, int nDepth = 0) const;
 
                virtual bool OnVisit(IXmlVisitor* content) const;
 
                cXmlNodeTypeIMPL(Unknown, this);
        };
 
        class GRAYLIB_LINK cXmlContainer : public cListT<cXmlNode>, public cXml
        {
 
        public:
                virtual ~cXmlContainer()
                {
                        DisposeAll();
                }
 
                virtual cXmlNode* ToNode() = 0;
 
                cXmlNode* GetChildFirst(const char* value) const;                       
                cXmlNode* GetChildLast(const char* value) const;                        
 
 
                cXmlNode* IterateChildren(const char* value, const cXmlNode* previous) const;
 
                HRESULT LinkChildEnd(cXmlNode* addThis);
                void SetCopyChildren(const cXmlContainer& cont);
 
                cXmlNode* InsertChildEnd(const cXmlNode& addThis);
 
                cXmlNode* InsertChildAfter(cXmlNode* afterThis, const cXmlNode& addThis);
 
                cXmlNode* InsertChildBefore(cXmlNode* beforeThis, const cXmlNode& addThis);
 
                bool RemoveChild(cXmlNode* removeThis);
 
                cXmlElement* get_FirstChildElement() const;
 
                cXmlElement* GetFirstChildElement(const char* pszValue) const;
        };
 
        class GRAYLIB_LINK cXmlElement : public cXmlNode, public cXmlContainer
        {
 
                typedef cXmlNode SUPER_t;
 
        public:
                cXmlAttributeSet m_Attributes;          
 
        protected:
                virtual void SetCopy(const cXmlElement& n);
                virtual void SetClear();
 
        public:
                cXmlElement(cXmlString sValue);
                cXmlElement(const cXmlElement& rCopy);
                virtual ~cXmlElement();
 
                void operator=(const cXmlElement& rCopy)
                {
                        SetClear();
                        SetCopy(rCopy);
                }
 
                // Convenience function for easy access to the text inside an element. Although easy
                // and concise, GetText() is limited compared to getting the cXmlText child
                // and accessing it directly.
                //
                // If the first child of 'this' is a cXmlText, the GetText()
                // returns the character string of the Text node, else null is returned.
                //
                // This is a convenient method for getting the text of simple contained text:
                //@verbatim
                //<foo>This is text</foo>
                // const char* str = fooElement->GetText();
                //@endverbatim
                //
                //'str' will be a pointer to "This is text".
                //
                // Note that this function can be misleading. If the element foo was created from
                // this XML:
                //@verbatim
                //<foo><b>This is text</b></foo>
                //@endverbatim
                //
                // then the value of str would be null. The first child node isn't a text node, it is
                // another element. From this XML:
                //@verbatim
                //<foo>This is <b>text</b></foo>
                //@endverbatim
                // GetText() will return "This is ".
                //
                // WARNING: GetText() accesses a child node - don't become confused with the
                // similarly named cXmlHandle::Text() and cXmlNode::ToText() which are
                // safe type casts on the referenced node.
                //
                const char* get_Text() const;
 
                virtual cXmlNode* Clone() const;
 
                virtual HRESULT SetParseNode(cXmlReader& rReader);
 
                virtual HRESULT Print(cStreamOutput& rOut, int nDepth = 0) const;
 
                virtual bool OnVisit(IXmlVisitor* visitor) const;
 
                virtual cXmlContainer* ToContainer()
                {
                        return this;
                }
                virtual cXmlNode* ToNode()
                {
                        return this;
                }
                cXmlNodeTypeIMPL(Element, this);
        };
 
        class GRAYLIB_LINK cXmlDocument : public cXmlNode, public cXmlContainer
        {
 
                typedef cXmlNode SUPER_t;
 
        private:
                bool m_bUseMicrosoftBOM;                
 
        private:
                virtual void SetCopy(const cXmlDocument& n);
 
        public:
                cXmlDocument();
                cXmlDocument(const cXmlDocument& rCopy);
 
                virtual ~cXmlDocument()
                {}
 
                void operator=(const cXmlDocument& rCopy)
                {
                        SetClear();
                        SetCopy(rCopy);
                }
 
                HRESULT LoadFile(cStreamInput& stmIn);
                HRESULT LoadFile(const FILECHAR_t* pszFilename);
 
                HRESULT SaveFile(cStreamOutput& rOut) const;
                HRESULT SaveFile(const FILECHAR_t* pszFilename) const;
 
                virtual void SetClear();
                virtual cXmlContainer* ToContainer()
                {
                        return this;
                }
                virtual cXmlNode* ToNode()
                {
                        return this;
                }
 
                virtual cXmlNode* Clone() const;
 
                virtual HRESULT SetParseNode(cXmlReader& rReader);
 
                virtual HRESULT Print(cStreamOutput& rOut, int nDepth = 0) const;
 
                virtual bool OnVisit(IXmlVisitor* content) const;
 
                cXmlNodeTypeIMPL(Document, this);
        };
 
#undef cXmlNodeTypeIMPL
 
};
 
#endif // _INC_cXml_H