spl/xml/XmlNode.h

/*
 *  Much of this code is extracted from the tinyxml project, attributed below.
 */
/*
www.sourceforge.net/projects/tinyxml
Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.

Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.
*/

#ifndef _xmlnode_h
#define _xmlnode_h

#include <spl/Debug.h>
#include <spl/Memory.h>
#include <spl/collection/List.h>
#include <spl/RefCountPtr.h>
#include <spl/RefCountPtrCast.h>
#include <spl/String.h>
#include <spl/io/TextStream.h>
#include <spl/WeakReference.h>
#include <spl/xml/XmlParsingData.h>

class XmlNode;
class XmlDocument;
class XmlElement;
class XmlComment;
class XmlUnknown;
class XmlAttribute;
class XmlText;
class XmlDeclaration;
class XmlNodeList;

typedef RefCountPtr<XmlNode> XmlNodePtr;

typedef RefCountPtrCast<XmlDocument, XmlNode, XmlNodePtr> XmlDocumentPtr;               //< Cast from XmlDocumentPtr to XmlNodePtr.
typedef RefCountPtrCast<XmlElement, XmlNode, XmlNodePtr> XmlElementPtr;                 //< Cast from XmlElementPtr to XmlNodePtr.
typedef RefCountPtrCast<XmlComment, XmlNode, XmlNodePtr> XmlCommentPtr;                 //< Cast from XmlCommentPtr to XmlNodePtr.
typedef RefCountPtrCast<XmlUnknown, XmlNode, XmlNodePtr> XmlUnknownPtr;                 //< Cast from XmlUnknownPtr to XmlNodePtr.
typedef RefCountPtrCast<XmlAttribute, XmlNode, XmlNodePtr> XmlAttributePtr;             //< Cast from XmlAttributePtr to XmlNodePtr.
typedef RefCountPtrCast<XmlText, XmlNode, XmlNodePtr> XmlTextPtr;                               //< Cast from XmlTextPtr to XmlNodePtr.
typedef RefCountPtrCast<XmlDeclaration, XmlNode, XmlNodePtr> XmlDeclarationPtr; //< Cast from XmlDeclarationPtr to XmlNodePtr.

REGISTER_TYPEOF( 489, XmlDocumentPtr );
REGISTER_TYPEOF( 491, XmlElementPtr );
REGISTER_TYPEOF( 492, XmlCommentPtr );
REGISTER_TYPEOF( 494, XmlUnknownPtr );
REGISTER_TYPEOF( 496, XmlAttributePtr );
REGISTER_TYPEOF( 499, XmlTextPtr );
REGISTER_TYPEOF( 500, XmlDeclarationPtr );

typedef WeakReference<XmlNode, XmlNodePtr> XmlNodeRef;                                          //< Weak ref to XmlNode.
typedef WeakReference<XmlDocument, XmlDocumentPtr> XmlDocumentRef;                      //< Weak ref to XmlDocument.
typedef WeakReference<XmlElement, XmlElementPtr> XmlElementRef;                         //< Weak ref to XmlElement.
typedef WeakReference<XmlComment, XmlCommentPtr> XmlCommentRef;                         //<     Weak ref to XmlComment.
typedef WeakReference<XmlUnknown, XmlUnknownPtr> XmlUnknownRef;                         //< Weak ref to XmlUnknown.
typedef WeakReference<XmlAttribute, XmlAttributePtr> XmlAttributeRef;           //< Weak ref to XmlAttribute.
typedef WeakReference<XmlText, XmlTextPtr> XmlTextRef;                                          //< Weak ref to XmlText.
typedef WeakReference<XmlDeclaration, XmlDeclarationPtr> XmlDeclarationRef;     //< Weak ref to XmlDeclaration.

REGISTER_TYPEOF( 502, XmlDocumentRef );
REGISTER_TYPEOF( 504, XmlElementRef );
REGISTER_TYPEOF( 506, XmlCommentRef );
REGISTER_TYPEOF( 508, XmlUnknownRef );
REGISTER_TYPEOF( 510, XmlAttributeRef );
REGISTER_TYPEOF( 512, XmlTextRef );
REGISTER_TYPEOF( 514, XmlDeclarationRef );

class XmlNode : public IMemoryValidate
{
private:
        // copy constructor would probably need to do a deep copy, which undesireable
        inline XmlNode(const XmlNode& pmp) {}
        inline void operator =(const XmlNode& pmp) {}

public:
        enum XmlNodeType
        {
                DOCUMENT,
                ELEMENT,
                COMMENT,
                UNKNOWN,
                TEXT,
                DECLARATION,
                TYPECOUNT,
                ATTRIBUTE
        };

        enum
        {
                TIXML_NO_ERROR = 0,
                TIXML_ERROR,
                TIXML_ERROR_OPENING_FILE,
                TIXML_ERROR_OUT_OF_MEMORY,
                TIXML_ERROR_PARSING_ELEMENT,
                TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
                TIXML_ERROR_READING_ELEMENT_VALUE,
                TIXML_ERROR_READING_ATTRIBUTES,
                TIXML_ERROR_PARSING_EMPTY,
                TIXML_ERROR_READING_END_TAG,
                TIXML_ERROR_PARSING_UNKNOWN,
                TIXML_ERROR_PARSING_COMMENT,
                TIXML_ERROR_PARSING_DECLARATION,
                TIXML_ERROR_DOCUMENT_EMPTY,
                TIXML_ERROR_EMBEDDED_NULL,
                TIXML_ERROR_PARSING_CDATA,
                TIXML_ERROR_DOCUMENT_TOP_ONLY,

                TIXML_ERROR_STRING_COUNT
        };

protected:
        friend class XmlDocument;
        friend class TinyXmlParser;
        friend class XmlElement;
        
        XmlNode*                m_parent;
        XmlNodeType             m_type;

        XmlNodePtr              m_firstChild;
        XmlNodePtr              m_lastChild;

        StringBuffer    m_value;

        XmlNodePtr              m_prev;
        XmlNodePtr              m_next;
                        
        TiXmlCursor m_location;

        XmlNodeRef m_self;

        XmlNode( XmlNodeType _type );

        // Copy to the allocated object. Shared functionality between Clone, Copy constructor,
        // and the assignment operator.
        void CopyTo( XmlNode& target ) const;

        // Figure out what is at *p, and parse it. Returns null if it is not an xml node.
        XmlNodePtr Identify( const char* start, XmlEncoding encoding );

        virtual const char* _Parse(     const char* p, XmlParsingData* data, XmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
                                                          
public:
        class Iterator : public IIterator<XmlNodePtr>
        {
        private:
                List<XmlNodePtr> m_stack;
                XmlNodePtr m_current;
                
        public:
                Iterator(XmlNodePtr root);      //< root is not iterated
                Iterator(const Iterator& iter);
                virtual ~Iterator();
                Iterator& operator =(const Iterator iter);
                
                virtual bool Next();
                virtual bool Prev();

                virtual XmlNodePtr Current();
                virtual XmlNodePtr& CurrentRef();
        };
        
        virtual ~XmlNode();
        
        inline const StringPtr Value() const 
        { 
                return m_value.ToString();
        }

        virtual String Name() const = 0;
        
        inline void SetValue(const String& _value) 
        { 
                m_value = _value;
        }

        void Clear();

        inline XmlNodePtr ParentNode() const
        { 
                return NULL == m_parent ? XmlNodePtr() : m_parent->m_self; 
        }
        
        virtual RefCountPtr<XmlNodeList> ChildNodes() const;

        inline XmlNodePtr FirstChild() const
        {
                return m_firstChild; 
        }
        
        XmlNodePtr FirstChild( const String& value ) const;
        
        inline XmlNodePtr LastChild() const
        { 
                return m_lastChild; 
        }
                
        XmlNodePtr LastChild( const String& value ) const;

        XmlNodePtr Child(int index) const;

        void AppendChild( XmlNodePtr addThis );

        void InsertBefore( XmlNodePtr beforeThis, XmlNodePtr addThis );

        void InsertAfter( XmlNodePtr afterThis, XmlNodePtr addThis );

        void ReplaceChild( XmlNodePtr replaceThis, XmlNodePtr withThis );

        bool RemoveChild( XmlNodePtr removeThis );

        virtual RefCountPtr<XmlNodeList> Decendants();
        
        inline XmlNodePtr PreviousSibling()             
        { 
                return m_prev; 
        }
        
        XmlNodePtr PreviousSibling( const String& );

        inline XmlNodePtr NextSibling()                         
        { 
                return m_next; 
        }
        
        XmlNodePtr NextSibling( const String& );

        XmlElementPtr NextSiblingElement();

        XmlElementPtr NextSiblingElement( const String& );

        XmlElementPtr FirstChildElement();

        XmlElementPtr FirstChildElement( const String& _value );

        inline XmlNodeType NodeType() const     
        { 
                return m_type; 
        }

        XmlDocumentPtr GetDocument();

        inline bool HasChildNodes() const
        { 
                return m_firstChild.IsNotNull(); 
        }
        
        virtual XmlNodePtr Clone() const = 0;

        virtual StringPtr InnerText() const;

        RefCountPtr<XmlNodeList> SelectNodes(const String& xpath);

        XmlNodePtr SelectSingleNode(const String& xpath);

        inline int Row() const                  { return m_location.row + 1; }
        inline int Column() const               { return m_location.col + 1; }  

        virtual XmlDocumentPtr    ToDocument()    const; 
        virtual XmlElementPtr     ToElement()     const; 
        virtual XmlCommentPtr     ToComment()     const; 
        virtual XmlUnknownPtr     ToUnknown()     const; 
        virtual XmlTextPtr        ToText()        const; 
        virtual XmlDeclarationPtr ToDeclaration() const; 

        inline bool IsDocument()    const { return m_type == DOCUMENT; }
        inline bool IsElement()     const { return m_type == ELEMENT; }
        inline bool IsComment()     const { return m_type == COMMENT; }
        inline bool IsUnknown()     const { return m_type == UNKNOWN; }
        inline bool IsText()        const { return m_type == TEXT; }
        inline bool IsDeclaration() const { return m_type == DECLARATION; }
        inline bool IsAttribute() const { return m_type == ATTRIBUTE; }

        inline StringPtr OuterXml() const { return ToString(); }
        virtual StringPtr InnerXml() const;

        virtual StringPtr ToString() const = 0;
        virtual void WriteTo(TextWriter& writer) const = 0;
        
        inline Iterator Begin()
        {
                return Iterator(m_self);
        }

#ifdef DEBUG
        virtual void ValidateMem() const;
        virtual void CheckMem() const;
#endif
};

REGISTER_TYPEOF( 520, XmlNode );

#endif