XML.h

Go to the documentation of this file.

/*
www.sourceforge.net/projects/tinyxml
Original code (2.0 and earlier )copyright (c) 2000-2002 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 __LDK_XML_H__
#define __LDK_XML_H__

#ifdef _MSC_VER
#pragma warning( disable : 4530 )
#pragma warning( disable : 4786 )
#endif

#include "LDK/VFileSystem.h"
#include "LDK/String.h"

#ifdef LDKXML_USE_STL
#include <iostream>
#define LDKXML_STRING    LDK::String
#define LDKXML_ISTREAM   std::istream
#define LDKXML_OSTREAM   std::ostream
#else
#define LDKXML_STRING    LDK::String
#define LDKXML_OSTREAM   XmlOutStream
#endif //LDKXML_USE_STL

//#include <ctype.h>
//#include <stdio.h>
//#include <stdlib.h>
//#include <string.h>
//#include <assert.h>

//TODO: make sure this code is safe to use in a thread local fashion

#define LDKXML_LOG VFileSystem::stdOut()->printf

namespace LDK
{

/*
   XmlOutStream is an emulation of std::ostream. It is based on String.
   Only the operators that we need for TinyXML have been developped.
*/
class LDK_API XmlOutStream : public String
{
public :
    XmlOutStream () : String () {}

    // XmlOutStream << operator. Maps to String::append
    XmlOutStream & operator << (const char * in)
    {
        append (in);
        return (* this);
    }

    // XmlOutStream << operator. Maps to String::append
    XmlOutStream & operator << (const String & in)
    {
        append (in . c_str ());
        return (* this);
    }
} ;


class LDK_API XmlDocument;
class LDK_API XmlElement;
class LDK_API XmlComment;
class LDK_API XmlUnknown;
class LDK_API XmlAttribute;
class LDK_API XmlText;
class LDK_API XmlDeclaration;
class LDK_API XmlParsingData;

const int LDKXML_MAJOR_VERSION = 2;
const int LDKXML_MINOR_VERSION = 3;
const int LDKXML_PATCH_VERSION = 4;

/*  Internal structure for tracking location of items
    in the XML file.
*/
struct LDK_API XmlCursor
{
    XmlCursor()       { Clear(); }
    void Clear()        { row = col = -1; }

    int row;    // 0 based.
    int col;    // 0 based.
};


// Only used by Attribute::Query functions
enum
{
    LDKXML_SUCCESS,
    LDKXML_NO_ATTRIBUTE,
    LDKXML_WRONG_TYPE
};


// Used by the parsing routines.
enum XmlEncoding
{
    LDKXML_ENCODING_UNKNOWN,
    LDKXML_ENCODING_UTF8,
    LDKXML_ENCODING_LEGACY
};

const extern LDK_API XmlEncoding LDKXML_DEFAULT_ENCODING;

class LDK_API XmlBase
{
    friend class LDK_API XmlNode;
    friend class LDK_API XmlElement;
    friend class LDK_API XmlDocument;

public:
    XmlBase() :   userData(0) {}
    virtual ~XmlBase()                    {}

    virtual void Print( SmartFile f, int depth ) const = 0;

    static void SetCondenseWhiteSpace( bool condense )      { condenseWhiteSpace = condense; }

    static bool IsWhiteSpaceCondensed()                     { return condenseWhiteSpace; }

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

    void  SetUserData( void* user )         { userData = user; }
    void* GetUserData()                     { return userData; }

    // Table that returs, for a given lead byte, the total number of bytes
    // in the UTF-8 sequence.
    static const int utf8ByteTable[256];

    virtual const char* Parse(  const char* p,
                                XmlParsingData* data,
                                XmlEncoding encoding /*= LDKXML_ENCODING_UNKNOWN */ ) = 0;

    enum
    {
        LDKXML_NO_ERROR = 0,
        LDKXML_ERROR,
        LDKXML_ERROR_OPENING_FILE,
        LDKXML_ERROR_OUT_OF_MEMORY,
        LDKXML_ERROR_PARSING_ELEMENT,
        LDKXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
        LDKXML_ERROR_READING_ELEMENT_VALUE,
        LDKXML_ERROR_READING_ATTRIBUTES,
        LDKXML_ERROR_PARSING_EMPTY,
        LDKXML_ERROR_READING_END_TAG,
        LDKXML_ERROR_PARSING_UNKNOWN,
        LDKXML_ERROR_PARSING_COMMENT,
        LDKXML_ERROR_PARSING_DECLARATION,
        LDKXML_ERROR_DOCUMENT_EMPTY,
        LDKXML_ERROR_EMBEDDED_NULL,

        LDKXML_ERROR_STRING_COUNT
    };

protected:

    static const char*  SkipWhiteSpace( const char*, XmlEncoding encoding );
    inline static bool  IsWhiteSpace( char c )
    {
        return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );
    }

    virtual void StreamOut (LDKXML_OSTREAM *) const = 0;

    #ifdef LDKXML_USE_STL
        static bool StreamWhiteSpace( LDKXML_ISTREAM * in, LDKXML_STRING * tag );
        static bool StreamTo( LDKXML_ISTREAM * in, int character, LDKXML_STRING * tag );
    #endif

    /*  Reads an XML name into the string provided. Returns
        a pointer just past the last character of the name,
        or 0 if the function has an error.
    */
    static const char* ReadName( const char* p, LDKXML_STRING* name, XmlEncoding encoding );

    /*  Reads text. Returns a pointer past the given end tag.
        Wickedly complex options, but it keeps the (sensitive) code in one place.
    */
    static const char* ReadText(    const char* in,             // where to start
                                    LDKXML_STRING* text,         // the string read
                                    bool ignoreWhiteSpace,      // whether to keep the white space
                                    const char* endTag,         // what ends this text
                                    bool ignoreCase,            // whether to ignore case in the end tag
                                    XmlEncoding encoding );   // the current encoding

    // If an entity has been found, transform it into a character.
    static const char* GetEntity( const char* in, char* value, int* length, XmlEncoding encoding );

    // Get a character, while interpreting entities.
    // The length can be from 0 to 4 bytes.
    inline static const char* GetChar( const char* p, char* _value, int* length, XmlEncoding encoding )
    {
        assert( p );
        if ( encoding == LDKXML_ENCODING_UTF8 )
        {
            *length = utf8ByteTable[ *((unsigned char*)p) ];
            assert( *length >= 0 && *length < 5 );
        }
        else
        {
            *length = 1;
        }

        if ( *length == 1 )
        {
            if ( *p == '&' )
                return GetEntity( p, _value, length, encoding );
            *_value = *p;
            return p+1;
        }
        else if ( *length )
        {
            strncpy( _value, p, *length );
            return p + (*length);
        }
        else
        {
            // Not valid text.
            return 0;
        }
    }

    // Puts a string to a stream, expanding entities as it goes.
    // Note this should not contian the '<', '>', etc, or they will be transformed into entities!
    static void PutString( const LDKXML_STRING& str, LDKXML_OSTREAM* out );

    static void PutString( const LDKXML_STRING& str, LDKXML_STRING* out );

    // Return true if the next characters in the stream are any of the endTag sequences.
    // Ignore case only works for english, and should only be relied on when comparing
    // to Engilish words: StringEqual( p, "version", true ) is fine.
    static bool StringEqual(    const char* p,
                                const char* endTag,
                                bool ignoreCase,
                                XmlEncoding encoding );

    static const char* errorString[ LDKXML_ERROR_STRING_COUNT ];

    XmlCursor location;

    void*           userData;

    // None of these methods are reliable for any language except English.
    // Good for approximation, not great for accuracy.
    static int IsAlpha( unsigned char anyByte, XmlEncoding encoding );
    static int IsAlphaNum( unsigned char anyByte, XmlEncoding encoding );
    inline static int ToLower( int v, XmlEncoding encoding )
    {
        if ( encoding == LDKXML_ENCODING_UTF8 )
        {
            if ( v < 128 ) return tolower( v );
            return v;
        }
        else
        {
            return tolower( v );
        }
    }
    static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );

private:
    XmlBase( const XmlBase& );              // not implemented.
    void operator=( const XmlBase& base );    // not allowed.

    struct Entity
    {
        const char*     str;
        unsigned int    strLength;
        char            chr;
    };
    enum
    {
        NUM_ENTITY = 5,
        MAX_ENTITY_LENGTH = 6

    };
    static Entity entity[ NUM_ENTITY ];
    static bool condenseWhiteSpace;
};


class LDK_API XmlNode : public XmlBase
{
    friend class LDK_API XmlDocument;
    friend class LDK_API XmlElement;

public:
    #ifdef LDKXML_USE_STL

        friend std::istream& operator >> (std::istream& in, XmlNode& base);

        friend std::ostream& operator<< (std::ostream& out, const XmlNode& base);

        friend String& operator<< (String& out, const XmlNode& base );

    #else
        // Used internally, not part of the public API.
        friend LDKXML_OSTREAM& operator<< (LDKXML_OSTREAM& out, const XmlNode& base);
    #endif

    enum NodeType
    {
        DOCUMENT,
        ELEMENT,
        COMMENT,
        UNKNOWN,
        TEXT,
        DECLARATION,
        TYPECOUNT
    };

    virtual ~XmlNode();

    const char * Value() const { return value.c_str (); }

    void SetValue(const char * _value) { value = _value;}


    void SetValue( const String& _value )
    {
        value = _value;
    }


    void Clear();

    XmlNode* Parent()                         { return parent; }
    const XmlNode* Parent() const             { return parent; }

    const XmlNode* FirstChild()   const   { return firstChild; }      
    XmlNode* FirstChild()                 { return firstChild; }
    const XmlNode* FirstChild( const char * value ) const;            
    XmlNode* FirstChild( const char * value );                        

    const XmlNode* LastChild() const  { return lastChild; }       
    XmlNode* LastChild()  { return lastChild; }
    const XmlNode* LastChild( const char * value ) const;         
    XmlNode* LastChild( const char * value );

    const XmlNode* FirstChild( const String& _value ) const  {   return FirstChild (_value.c_str ());    }   
    XmlNode* FirstChild( const String& _value )              {   return FirstChild (_value.c_str ());    }   
    const XmlNode* LastChild( const String& _value ) const   {   return LastChild (_value.c_str ()); }   
    XmlNode* LastChild( const String& _value )               {   return LastChild (_value.c_str ()); }   

    const XmlNode* IterateChildren( const XmlNode* previous ) const;
    XmlNode* IterateChildren( XmlNode* previous );

    const XmlNode* IterateChildren( const char * value, const XmlNode* previous ) const;
    XmlNode* IterateChildren( const char * value, XmlNode* previous );

    const XmlNode* IterateChildren( const String& _value, const XmlNode* previous ) const  {   return IterateChildren (_value.c_str (), previous); }   
    XmlNode* IterateChildren( const String& _value, XmlNode* previous ) {  return IterateChildren (_value.c_str (), previous); }   

    XmlNode* InsertEndChild( const XmlNode& addThis );


    XmlNode* LinkEndChild( XmlNode* addThis );

    XmlNode* InsertBeforeChild( XmlNode* beforeThis, const XmlNode& addThis );

    XmlNode* InsertAfterChild(  XmlNode* afterThis, const XmlNode& addThis );

    XmlNode* ReplaceChild( XmlNode* replaceThis, const XmlNode& withThis );

    bool RemoveChild( XmlNode* removeThis );

    const XmlNode* PreviousSibling() const            { return prev; }
    XmlNode* PreviousSibling()                        { return prev; }

    const XmlNode* PreviousSibling( const char * ) const;
    XmlNode* PreviousSibling( const char * );

    const XmlNode* PreviousSibling( const String& _value ) const {   return PreviousSibling (_value.c_str ());   }   
    XmlNode* PreviousSibling( const String& _value )             {   return PreviousSibling (_value.c_str ());   }   
    const XmlNode* NextSibling( const String& _value) const      {   return NextSibling (_value.c_str ());   }   
    XmlNode* NextSibling( const String& _value)                  {   return NextSibling (_value.c_str ());   }   

    const XmlNode* NextSibling() const                { return next; }
    XmlNode* NextSibling()                            { return next; }

    const XmlNode* NextSibling( const char * ) const;
    XmlNode* NextSibling( const char * );

    const XmlElement* NextSiblingElement() const;
    XmlElement* NextSiblingElement();

    const XmlElement* NextSiblingElement( const char * ) const;
    XmlElement* NextSiblingElement( const char * );

    const XmlElement* NextSiblingElement( const String& _value) const    {   return NextSiblingElement (_value.c_str ());    }   
    XmlElement* NextSiblingElement( const String& _value)                {   return NextSiblingElement (_value.c_str ());    }   

    const XmlElement* FirstChildElement() const;
    XmlElement* FirstChildElement();

    const XmlElement* FirstChildElement( const char * value ) const;
    XmlElement* FirstChildElement( const char * value );

    const XmlElement* FirstChildElement( const String& _value ) const    {   return FirstChildElement (_value.c_str ()); }   
    XmlElement* FirstChildElement( const String& _value )                {   return FirstChildElement (_value.c_str ()); }   

    virtual int Type() const    { return type; }

    const XmlDocument* GetDocument() const;
    XmlDocument* GetDocument();

    bool NoChildren() const                     { return !firstChild; }

    const XmlDocument* ToDocument()   const       { return ( this && type == DOCUMENT ) ? (const XmlDocument*) this : 0; } 
    const XmlElement*  ToElement() const          { return ( this && type == ELEMENT  ) ? (const XmlElement*)  this : 0; } 
    const XmlComment*  ToComment() const          { return ( this && type == COMMENT  ) ? (const XmlComment*)  this : 0; } 
    const XmlUnknown*  ToUnknown() const          { return ( this && type == UNKNOWN  ) ? (const XmlUnknown*)  this : 0; } 
    const XmlText*       ToText()    const        { return ( this && type == TEXT     ) ? (const XmlText*)     this : 0; } 
    const XmlDeclaration* ToDeclaration() const   { return ( this && type == DECLARATION ) ? (const XmlDeclaration*) this : 0; } 

    XmlDocument* ToDocument()         { return ( this && type == DOCUMENT ) ? (XmlDocument*) this : 0; } 
    XmlElement*  ToElement()          { return ( this && type == ELEMENT  ) ? (XmlElement*)  this : 0; } 
    XmlComment*  ToComment()          { return ( this && type == COMMENT  ) ? (XmlComment*)  this : 0; } 
    XmlUnknown*  ToUnknown()          { return ( this && type == UNKNOWN  ) ? (XmlUnknown*)  this : 0; } 
    XmlText*     ToText()             { return ( this && type == TEXT     ) ? (XmlText*)     this : 0; } 
    XmlDeclaration* ToDeclaration()   { return ( this && type == DECLARATION ) ? (XmlDeclaration*) this : 0; } 

    virtual XmlNode* Clone() const = 0;

protected:
    XmlNode( NodeType _type );

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

    #ifdef LDKXML_USE_STL
        // The real work of the input operator.
        virtual void StreamIn( LDKXML_ISTREAM* in, LDKXML_STRING* tag ) = 0;
    #endif

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

    // Internal Value function returning a LDKXML_STRING
    const LDKXML_STRING& SValue() const  { return value ; }

    XmlNode*      parent;
    NodeType        type;

    XmlNode*      firstChild;
    XmlNode*      lastChild;

    LDKXML_STRING    value;

    XmlNode*      prev;
    XmlNode*      next;

private:
    XmlNode( const XmlNode& );              // not implemented.
    void operator=( const XmlNode& base );    // not allowed.
};


class LDK_API XmlAttribute : public XmlBase
{
    friend class LDK_API XmlAttributeSet;

public:
    XmlAttribute() : XmlBase()
    {
        document = 0;
        prev = next = 0;
    }

    XmlAttribute( const String& _name, const String& _value )
    {
        name = _name;
        value = _value;
        document = 0;
        prev = next = 0;
    }

    XmlAttribute( const char * _name, const char * _value )
    {
        name = _name;
        value = _value;
        document = 0;
        prev = next = 0;
    }

    const char*     Name()  const       { return name.c_str (); }       
    const char*     Value() const       { return value.c_str (); }      
    const int       IntValue() const;                                   
    const double    DoubleValue() const;                                

    int QueryIntValue( int* value ) const;
    int QueryDoubleValue( double* value ) const;

    void SetName( const char* _name )   { name = _name; }               
    void SetValue( const char* _value ) { value = _value; }             

    void SetIntValue( int value );                                      
    void SetDoubleValue( double value );                                


    void SetName( const String& _name )
    {
        name = _name;
    }
    void SetValue( const String& _value )
    {
        value = _value;
    }


    const XmlAttribute* Next() const;
    XmlAttribute* Next();
    const XmlAttribute* Previous() const;
    XmlAttribute* Previous();

    bool operator==( const XmlAttribute& rhs ) const { return rhs.name == name; }
    bool operator<( const XmlAttribute& rhs )  const { return name < rhs.name; }
    bool operator>( const XmlAttribute& rhs )  const { return name > rhs.name; }

    /*  Attribute parsing starts: first letter of the name
                         returns: the next char after the value end quote
    */
    virtual const char* Parse( const char* p, XmlParsingData* data, XmlEncoding encoding );

    // Prints this Attribute to a FILE stream.
    virtual void Print( SmartFile f, int depth ) const;

    virtual void StreamOut( LDKXML_OSTREAM * out ) const;
    // [internal use]
    // Set the document pointer so the attribute can report errors.
    void SetDocument( XmlDocument* doc )  { document = doc; }

private:
    XmlAttribute( const XmlAttribute& );                // not implemented.
    void operator=( const XmlAttribute& base );   // not allowed.

    XmlDocument*  document;   // A pointer back to a document, for error reporting.
    LDKXML_STRING name;
    LDKXML_STRING value;
    XmlAttribute* prev;
    XmlAttribute* next;
};


/*  A class used to manage a group of attributes.
    It is only used internally, both by the ELEMENT and the DECLARATION.

    The set can be changed transparent to the Element and Declaration
    classes that use it, but NOT transparent to the Attribute
    which has to implement a next() and previous() method. Which makes
    it a bit problematic and prevents the use of STL.

    This version is implemented with circular lists because:
        - I like circular lists
        - it demonstrates some independence from the (typical) doubly linked list.
*/
class LDK_API XmlAttributeSet
{
public:
    XmlAttributeSet();
    ~XmlAttributeSet();

    void Add( XmlAttribute* attribute );
    void Remove( XmlAttribute* attribute );

    const XmlAttribute* First()   const   { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
    XmlAttribute* First()                 { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
    const XmlAttribute* Last() const      { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
    XmlAttribute* Last()                  { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }

    const XmlAttribute*   Find( const char * name ) const;
    XmlAttribute* Find( const char * name );

private:
    //*ME:  Because of hidden/disabled copy-construktor in XmlAttribute (sentinel-element),
    //*ME:  this class must be also use a hidden/disabled copy-constructor !!!
    XmlAttributeSet( const XmlAttributeSet& );  // not allowed
    void operator=( const XmlAttributeSet& ); // not allowed (as XmlAttribute)

    XmlAttribute sentinel;
};


class LDK_API XmlElement : public XmlNode
{
public:
    XmlElement (const char * in_value);

    //#ifdef LDKXML_USE_STL
    XmlElement( const String& _value );
    //#endif

    XmlElement( const XmlElement& );

    void operator=( const XmlElement& base );

    virtual ~XmlElement();

    const char* Attribute( const char* name ) const;

    const char* Attribute( const char* name, int* i ) const;

    const char* Attribute( const char* name, double* d ) const;

    int QueryIntAttribute( const char* name, int* value ) const;
    int QueryDoubleAttribute( const char* name, double* value ) const;
    int QueryDoubleAttribute( const char* name, float* value ) const {
        double d;
        int result = QueryDoubleAttribute( name, &d );
        *value = (float)d;
        return result;
    }

    void SetAttribute( const char* name, const char * value );


    const char* Attribute( const String& name ) const              { return Attribute( name.c_str() ); }
    const char* Attribute( const String& name, int* i ) const      { return Attribute( name.c_str(), i ); }
    const char* Attribute( const String& name, double* d ) const   { return Attribute( name.c_str(), d ); }
    int QueryIntAttribute( const String& name, int* value ) const  { return QueryIntAttribute( name.c_str(), value ); }
    int QueryDoubleAttribute( const String& name, double* value ) const { return QueryDoubleAttribute( name.c_str(), value ); }

    void SetAttribute( const String& _name, const String& _value )
    {
        SetAttribute (_name.c_str(), _value.c_str());
    }
    void SetAttribute( const String& _name, int _value )
    {
            SetAttribute (_name.c_str(), _value);
    }


    void SetAttribute( const char * name, int value );

    void SetDoubleAttribute( const char * name, double value );

    void RemoveAttribute( const char * name );

    void RemoveAttribute( const String& name ) {   RemoveAttribute (name.c_str ());    }   


    const XmlAttribute* FirstAttribute() const    { return attributeSet.First(); }        
    XmlAttribute* FirstAttribute()                { return attributeSet.First(); }
    const XmlAttribute* LastAttribute()   const   { return attributeSet.Last(); }     
    XmlAttribute* LastAttribute()                 { return attributeSet.Last(); }

    virtual XmlNode* Clone() const;
    // Print the Element to a FILE stream.
    virtual void Print( SmartFile f, int depth ) const;

    /*  Attribtue parsing starts: next char past '<'
                         returns: next char past '>'
    */
    virtual const char* Parse( const char* p, XmlParsingData* data, XmlEncoding encoding );

protected:

    void CopyTo( XmlElement* target ) const;
    void ClearThis();   // like clear, but initializes 'this' object as well

    // Used to be public [internal use]
    #ifdef LDKXML_USE_STL
        virtual void StreamIn( LDKXML_ISTREAM * in, LDKXML_STRING * tag );
    #endif
    virtual void StreamOut( LDKXML_OSTREAM * out ) const;

    /*  [internal use]
        Reads the "value" of the element -- another element, or text.
        This should terminate with the current end tag.
    */
    const char* ReadValue( const char* in, XmlParsingData* prevData, XmlEncoding encoding );

private:

    XmlAttributeSet attributeSet;
};


class LDK_API XmlComment : public XmlNode
{
public:
    XmlComment() : XmlNode( XmlNode::COMMENT ) {}
    XmlComment( const XmlComment& );
    void operator=( const XmlComment& base );

    virtual ~XmlComment() {}

    virtual XmlNode* Clone() const;
    virtual void Print( SmartFile f, int depth ) const;

    /*  Attribtue parsing starts: at the ! of the !--
                         returns: next char past '>'
    */
    virtual const char* Parse( const char* p, XmlParsingData* data, XmlEncoding encoding );

protected:
    void CopyTo( XmlComment* target ) const;

    // used to be public
    #ifdef LDKXML_USE_STL
        virtual void StreamIn( LDKXML_ISTREAM * in, LDKXML_STRING * tag );
    #endif
    virtual void StreamOut( LDKXML_OSTREAM * out ) const;

private:

};


class LDK_API XmlText : public XmlNode
{
    friend class XmlElement;
public:
    XmlText (const char * initValue) : XmlNode (XmlNode::TEXT)
    {
        SetValue( initValue );
    }
    virtual ~XmlText() {}


    XmlText( const String& initValue ) : XmlNode (XmlNode::TEXT)
    {
        SetValue( initValue.c_str() );
    }


    XmlText( const XmlText& copy ) : XmlNode( XmlNode::TEXT )   { copy.CopyTo( this ); }
    void operator=( const XmlText& base )                             { base.CopyTo( this ); }

    virtual void Print( SmartFile f, int depth ) const;

    virtual const char* Parse( const char* p, XmlParsingData* data, XmlEncoding encoding );

protected :
    virtual XmlNode* Clone() const;
    void CopyTo( XmlText* target ) const;

    virtual void StreamOut ( LDKXML_OSTREAM * out ) const;
    bool Blank() const; // returns true if all white space and new lines
    // [internal use]
    #ifdef LDKXML_USE_STL
        virtual void StreamIn( LDKXML_ISTREAM * in, LDKXML_STRING * tag );
    #endif

private:
};


class LDK_API XmlDeclaration : public XmlNode
{
public:
    XmlDeclaration()   : XmlNode( XmlNode::DECLARATION ) {}


    XmlDeclaration(   const String& _version,
                        const String& _encoding,
                        const String& _standalone );


    XmlDeclaration(   const char* _version,
                        const char* _encoding,
                        const char* _standalone );

    XmlDeclaration( const XmlDeclaration& copy );
    void operator=( const XmlDeclaration& copy );

    virtual ~XmlDeclaration() {}

    const char *Version() const         { return version.c_str (); }
    const char *Encoding() const        { return encoding.c_str (); }
    const char *Standalone() const      { return standalone.c_str (); }

    virtual XmlNode* Clone() const;
    virtual void Print( SmartFile f, int depth ) const;

    virtual const char* Parse( const char* p, XmlParsingData* data, XmlEncoding encoding );

protected:
    void CopyTo( XmlDeclaration* target ) const;
    // used to be public
    #ifdef LDKXML_USE_STL
        virtual void StreamIn( LDKXML_ISTREAM * in, LDKXML_STRING * tag );
    #endif
    virtual void StreamOut ( LDKXML_OSTREAM * out) const;

private:

    LDKXML_STRING version;
    LDKXML_STRING encoding;
    LDKXML_STRING standalone;
};


class LDK_API XmlUnknown : public XmlNode
{
public:
    XmlUnknown() : XmlNode( XmlNode::UNKNOWN )    {}
    virtual ~XmlUnknown() {}

    XmlUnknown( const XmlUnknown& copy ) : XmlNode( XmlNode::UNKNOWN )      { copy.CopyTo( this ); }
    void operator=( const XmlUnknown& copy )                                      { copy.CopyTo( this ); }

    virtual XmlNode* Clone() const;
    virtual void Print( SmartFile f, int depth ) const;

    virtual const char* Parse( const char* p, XmlParsingData* data, XmlEncoding encoding );

protected:
    void CopyTo( XmlUnknown* target ) const;

    #ifdef LDKXML_USE_STL
        virtual void StreamIn( LDKXML_ISTREAM * in, LDKXML_STRING * tag );
    #endif
    virtual void StreamOut ( LDKXML_OSTREAM * out ) const;

private:

};


class LDK_API XmlDocument : public XmlNode
{
public:
    XmlDocument();
    XmlDocument( const char * documentName );


    XmlDocument( const String& documentName );


    XmlDocument( const XmlDocument& copy );
    void operator=( const XmlDocument& copy );

    virtual ~XmlDocument() {}

    bool LoadFile( XmlEncoding encoding = LDKXML_DEFAULT_ENCODING );
    bool SaveFile() const;
    bool LoadFile( const char * filename, XmlEncoding encoding = LDKXML_DEFAULT_ENCODING );
    bool SaveFile( const char * filename ) const;

    bool LoadFile( const String& filename, XmlEncoding encoding = LDKXML_DEFAULT_ENCODING )
    {

        return ( LoadFile( filename.c_str(), encoding ));
    }
    bool SaveFile( const String& filename ) const      
    {

        return ( SaveFile( filename.c_str() ));
    }


    virtual const char* Parse( const char* p, XmlParsingData* data = 0, XmlEncoding encoding = LDKXML_DEFAULT_ENCODING );

    const XmlElement* RootElement() const     { return FirstChildElement(); }
    XmlElement* RootElement()                 { return FirstChildElement(); }

    bool Error() const                      { return error; }

    const char * ErrorDesc() const  { return errorDesc.c_str (); }

    const int ErrorId() const               { return errorId; }

    int ErrorRow()  { return errorLocation.row+1; }
    int ErrorCol()  { return errorLocation.col+1; } 

    void SetTabSize( int _tabsize )     { tabsize = _tabsize; }

    int TabSize() const { return tabsize; }

    void ClearError()                       {   error = false;
                                                errorId = 0;
                                                errorDesc = "";
                                                errorLocation.row = errorLocation.col = 0;
                                                //errorLocation.last = 0;
                                            }

    void Print() const                      { Print( VFileSystem::stdOut(), 0 ); }

    virtual void Print( SmartFile f, int depth = 0 ) const;
    // [internal use]
    void SetError( int err, const char* errorLocation, XmlParsingData* prevData, XmlEncoding encoding );

protected :
    virtual void StreamOut ( LDKXML_OSTREAM * out) const;
    // [internal use]
    virtual XmlNode* Clone() const;
    #ifdef LDKXML_USE_STL
        virtual void StreamIn( LDKXML_ISTREAM * in, LDKXML_STRING * tag );
    #endif

private:
    void CopyTo( XmlDocument* target ) const;

    bool error;
    int  errorId;
    LDKXML_STRING errorDesc;
    int tabsize;
    XmlCursor errorLocation;
};


class LDK_API XmlHandle
{
public:
    XmlHandle( XmlNode* node )                  { this->node = node; }
    XmlHandle( const XmlHandle& ref )           { this->node = ref.node; }
    XmlHandle operator=( const XmlHandle& ref ) { this->node = ref.node; return *this; }

    XmlHandle FirstChild() const;
    XmlHandle FirstChild( const char * value ) const;
    XmlHandle FirstChildElement() const;
    XmlHandle FirstChildElement( const char * value ) const;

    XmlHandle Child( const char* value, int index ) const;
    XmlHandle Child( int index ) const;
    XmlHandle ChildElement( const char* value, int index ) const;
    XmlHandle ChildElement( int index ) const;


    XmlHandle FirstChild( const String& _value ) const               { return FirstChild( _value.c_str() ); }
    XmlHandle FirstChildElement( const String& _value ) const        { return FirstChildElement( _value.c_str() ); }

    XmlHandle Child( const String& _value, int index ) const         { return Child( _value.c_str(), index ); }
    XmlHandle ChildElement( const String& _value, int index ) const  { return ChildElement( _value.c_str(), index ); }


    XmlNode* Node() const         { return node; }
    XmlElement* Element() const   { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
    XmlText* Text() const         { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
    XmlUnknown* Unknown() const           { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }

private:
    XmlNode* node;
};

}//namespace LDK

#ifdef _MSC_VER
#pragma warning( default : 4530 )
#pragma warning( default : 4786 )
#endif

#endif

---