{

TiXmlCursor() { Clear(); }

void Clear() { row = col = -1; }

int row; // 0 based.

int col; // 0 based.

{

virtual ~TiXmlVisitor() {}

/// Visit a document.

virtual bool VisitEnter( const TiXmlDocument& /*doc*/ ) { return true; }

/// Visit a document.

virtual bool VisitExit( const TiXmlDocument& /*doc*/ ) { return true; }

/// Visit an element.

virtual bool VisitEnter( const TiXmlElement& /*element*/, const TiXmlAttribute* /*firstAttribute*/ ) { return true; }

/// Visit an element.

virtual bool VisitExit( const TiXmlElement& /*element*/ ) { return true; }

/// Visit a declaration

virtual bool Visit( const TiXmlDeclaration& /*declaration*/ ) { return true; }

/// Visit a text node

virtual bool Visit( const TiXmlText& /*text*/ ) { return true; }

/// Visit a comment node

virtual bool Visit( const TiXmlComment& /*comment*/ ) { return true; }

/// Visit an unknown node

virtual bool Visit( const TiXmlUnknown& /*unknown*/ ) { return true; }

{

TIXML_ENCODING_UNKNOWN,

TIXML_ENCODING_UTF8,

TIXML_ENCODING_LEGACY

{

friend class TiXmlNode;

friend class TiXmlElement;

friend class TiXmlDocument;

TiXmlBase() : userData(0) {}

virtual ~TiXmlBase() {}

/** All TinyXml classes can print themselves to a filestream

virtual void Print( FILE* cfile, int depth ) const = 0;

/** The world does not agree on whether white space should be kept or

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

/// Return the current white space setting.

static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; }

/** Return the position, in the original source file, of this node or attribute.

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

int Column() const { return location.col + 1; } ///< See Row()

void SetUserData( void* user ) { userData = user; } ///< Set a pointer to arbitrary user data.

void* GetUserData() { return userData; } ///< Get a pointer to arbitrary user data.

const void* GetUserData() const { return userData; } ///< Get a pointer to arbitrary user data.

// 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,

TiXmlParsingData* data,

TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;

/** Expands entities in a string. Note this should not contian the tag's '<', '>', etc,

static void EncodeString( const TIXML_STRING& str, TIXML_STRING* out );

enum

{

TIXML_NO_ERROR = 0,

TIXML_ERROR,

TIXML_ERROR_OPENING_FILE,

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

};

static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding );

inline static bool IsWhiteSpace( char c )

{

return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );

}

inline static bool IsWhiteSpace( int c )

{

if ( c < 256 )

return IsWhiteSpace( (char) c );

return false; // Again, only truly correct for English/Latin...but usually works.

}

#ifdef TIXML_USE_STL

static bool StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );

static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag );

#endif

/* Reads an XML name into the string provided. Returns

static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );

/* Reads text. Returns a pointer past the given end tag.

static const char* ReadText( const char* in, // where to start

TIXML_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

TiXmlEncoding 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, TiXmlEncoding 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, TiXmlEncoding encoding )

{

assert( p );

if ( encoding == TIXML_ENCODING_UTF8 )

{

*length = utf8ByteTable[ *((const 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 ); // lots of compilers don't like this function (unsafe),

// and the null terminator isn't needed

for( int i=0; p[i] && i<*length; ++i ) {

_value[i] = p[i];

}

return p + (*length);

}

else

{

// Not valid text.

return 0;

}

}

// 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 English words: StringEqual( p, "version", true ) is fine.

static bool StringEqual( const char* p,

const char* endTag,

bool ignoreCase,

TiXmlEncoding encoding );

static const char* errorString[ TIXML_ERROR_STRING_COUNT ];

TiXmlCursor location;

/// Field containing a generic user pointer

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, TiXmlEncoding encoding );

static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );

inline static int ToLower( int v, TiXmlEncoding encoding )

{

if ( encoding == TIXML_ENCODING_UTF8 )

{

if ( v < 128 ) return tolower( v );

return v;

}

else

{

return tolower( v );

}

}

static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );

TiXmlBase( const TiXmlBase& ); // not implemented.

void operator=( const TiXmlBase& 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;

{

friend class TiXmlDocument;

friend class TiXmlElement;

#ifdef TIXML_USE_STL

/** An input stream operator, for every class. Tolerant of newlines and

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

/** An output stream operator, for every class. Note that this outputs

*/

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

/// Appends the XML node or attribute to a std::string.

friend std::string& operator<< (std::string& out, const TiXmlNode& base );

#endif

/** The types of XML nodes supported by TinyXml. (All the

enum NodeType

{

TINYXML_DOCUMENT,

TINYXML_ELEMENT,

TINYXML_COMMENT,

TINYXML_UNKNOWN,

TINYXML_TEXT,

TINYXML_DECLARATION,

TINYXML_TYPECOUNT

};

virtual ~TiXmlNode();

/** The meaning of 'value' changes for the specific type of

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

#ifdef TIXML_USE_STL

/** Return Value() as a std::string. If you only use STL,

const std::string& ValueStr() const { return value; }

#endif

const TIXML_STRING& ValueTStr() const { return value; }

/** Changes the value of the node. Defined as:

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

#ifdef TIXML_USE_STL

/// STL std::string form.

void SetValue( const std::string& _value ) { value = _value; }

#endif

/// Delete all the children of this node. Does not affect 'this'.

void Clear();

/// One step up the DOM.

TiXmlNode* Parent() { return parent; }

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

const TiXmlNode* FirstChild() const { return firstChild; } ///< The first child of this node. Will be null if there are no children.

TiXmlNode* FirstChild() { return firstChild; }

const TiXmlNode* FirstChild( const char * value ) const; ///< The first child of this node with the matching 'value'. Will be null if none found.

/// The first child of this node with the matching 'value'. Will be null if none found.

TiXmlNode* FirstChild( const char * _value ) {

// Call through to the const version - safe since nothing is changed. Exiting syntax: cast this to a const (always safe)

// call the method, cast the return back to non-const.

return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild( _value ));

}

const TiXmlNode* LastChild() const { return lastChild; } /// The last child of this node. Will be null if there are no children.

TiXmlNode* LastChild() { return lastChild; }

const TiXmlNode* LastChild( const char * value ) const; /// The last child of this node matching 'value'. Will be null if there are no children.

TiXmlNode* LastChild( const char * _value ) {

return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild( _value ));

}

#ifdef TIXML_USE_STL

const TiXmlNode* FirstChild( const std::string& _value ) const { return FirstChild (_value.c_str ()); } ///< STL std::string form.

TiXmlNode* FirstChild( const std::string& _value ) { return FirstChild (_value.c_str ()); } ///< STL std::string form.

const TiXmlNode* LastChild( const std::string& _value ) const { return LastChild (_value.c_str ()); } ///< STL std::string form.

TiXmlNode* LastChild( const std::string& _value ) { return LastChild (_value.c_str ()); } ///< STL std::string form.

#endif

/** An alternate way to walk the children of a node.

const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;

TiXmlNode* IterateChildren( const TiXmlNode* previous ) {

return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( previous ) );

}

/// This flavor of IterateChildren searches for children with a particular 'value'

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

TiXmlNode* IterateChildren( const char * _value, const TiXmlNode* previous ) {

return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( _value, previous ) );

}

#ifdef TIXML_USE_STL

const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const { return IterateChildren (_value.c_str (), previous); } ///< STL std::string form.

TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) { return IterateChildren (_value.c_str (), previous); } ///< STL std::string form.

#endif

/** Add a new node related to this. Adds a child past the LastChild.

TiXmlNode* InsertEndChild( const TiXmlNode& addThis );

/** Add a new node related to this. Adds a child past the LastChild.

TiXmlNode* LinkEndChild( TiXmlNode* addThis );

/** Add a new node related to this. Adds a child before the specified child.

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

/** Add a new node related to this. Adds a child after the specified child.

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

/** Replace a child of this node.

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

/// Delete a child of this node.

bool RemoveChild( TiXmlNode* removeThis );

/// Navigate to a sibling node.

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

TiXmlNode* PreviousSibling() { return prev; }

/// Navigate to a sibling node.

const TiXmlNode* PreviousSibling( const char * ) const;

TiXmlNode* PreviousSibling( const char *_prev ) {

return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->PreviousSibling( _prev ) );

}

#ifdef TIXML_USE_STL

const TiXmlNode* PreviousSibling( const std::string& _value ) const { return PreviousSibling (_value.c_str ()); } ///< STL std::string form.

TiXmlNode* PreviousSibling( const std::string& _value ) { return PreviousSibling (_value.c_str ()); } ///< STL std::string form.

const TiXmlNode* NextSibling( const std::string& _value) const { return NextSibling (_value.c_str ()); } ///< STL std::string form.

TiXmlNode* NextSibling( const std::string& _value) { return NextSibling (_value.c_str ()); } ///< STL std::string form.

#endif

/// Navigate to a sibling node.

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

TiXmlNode* NextSibling() { return next; }

/// Navigate to a sibling node with the given 'value'.

const TiXmlNode* NextSibling( const char * ) const;

TiXmlNode* NextSibling( const char* _next ) {

return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->NextSibling( _next ) );

}

/** Convenience function to get through elements.

const TiXmlElement* NextSiblingElement() const;

TiXmlElement* NextSiblingElement() {

return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() );

}

/** Convenience function to get through elements.

const TiXmlElement* NextSiblingElement( const char * ) const;

TiXmlElement* NextSiblingElement( const char *_next ) {

return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement( _next ) );

}

#ifdef TIXML_USE_STL

const TiXmlElement* NextSiblingElement( const std::string& _value) const { return NextSiblingElement (_value.c_str ()); } ///< STL std::string form.

TiXmlElement* NextSiblingElement( const std::string& _value) { return NextSiblingElement (_value.c_str ()); } ///< STL std::string form.

#endif

/// Convenience function to get through elements.

const TiXmlElement* FirstChildElement() const;

TiXmlElement* FirstChildElement() {

return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() );

}

/// Convenience function to get through elements.

const TiXmlElement* FirstChildElement( const char * _value ) const;

TiXmlElement* FirstChildElement( const char * _value ) {

return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement( _value ) );

}

#ifdef TIXML_USE_STL

const TiXmlElement* FirstChildElement( const std::string& _value ) const { return FirstChildElement (_value.c_str ()); } ///< STL std::string form.

TiXmlElement* FirstChildElement( const std::string& _value ) { return FirstChildElement (_value.c_str ()); } ///< STL std::string form.

#endif

/** Query the type (as an enumerated value, above) of this node.

int Type() const { return type; }

/** Return a pointer to the Document this node lives in.

const TiXmlDocument* GetDocument() const;

TiXmlDocument* GetDocument() {

return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() );

}

/// Returns true if this node has no children.

bool NoChildren() const { return !firstChild; }

virtual const TiXmlDocument* ToDocument() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual const TiXmlElement* ToElement() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual const TiXmlComment* ToComment() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual const TiXmlUnknown* ToUnknown() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual const TiXmlText* ToText() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual TiXmlDocument* ToDocument() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual TiXmlElement* ToElement() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual TiXmlComment* ToComment() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual TiXmlUnknown* ToUnknown() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual TiXmlText* ToText() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

virtual TiXmlDeclaration* ToDeclaration() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.

/** Create an exact duplicate of this node and return it. The memory must be deleted

virtual TiXmlNode* Clone() const = 0;

/** Accept a hierchical visit the nodes in the TinyXML DOM. Every node in the

virtual bool Accept( TiXmlVisitor* visitor ) const = 0;

TiXmlNode( NodeType _type );

// Copy to the allocated object. Shared functionality between Clone, Copy constructor,

// and the assignment operator.

void CopyTo( TiXmlNode* target ) const;

#ifdef TIXML_USE_STL

// The real work of the input operator.

virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;

#endif

// Figure out what is at *p, and parse it. Returns null if it is not an xml node.

TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );

TiXmlNode* parent;

NodeType type;

TiXmlNode* firstChild;

TiXmlNode* lastChild;

TIXML_STRING value;

TiXmlNode* prev;

TiXmlNode* next;

TiXmlNode( const TiXmlNode& ); // not implemented.

void operator=( const TiXmlNode& base ); // not allowed.

{

friend class TiXmlAttributeSet;

/// Construct an empty attribute.

TiXmlAttribute() : TiXmlBase()

{

document = 0;

prev = next = 0;

}

#ifdef TIXML_USE_STL

/// std::string constructor.

TiXmlAttribute( const std::string& _name, const std::string& _value )

{

name = _name;

value = _value;

document = 0;

prev = next = 0;

}

#endif

/// Construct an attribute with a name and value.

TiXmlAttribute( const char * _name, const char * _value )

{

name = _name;

value = _value;

document = 0;

prev = next = 0;

}

const char* Name() const { return name.c_str(); } ///< Return the name of this attribute.

const char* Value() const { return value.c_str(); } ///< Return the value of this attribute.

#ifdef TIXML_USE_STL

const std::string& ValueStr() const { return value; } ///< Return the value of this attribute.

#endif

int IntValue() const; ///< Return the value of this attribute, converted to an integer.

double DoubleValue() const; ///< Return the value of this attribute, converted to a double.

// Get the tinyxml string representation

const TIXML_STRING& NameTStr() const { return name; }

/** QueryIntValue examines the value string. It is an alternative to the

int QueryIntValue( int* _value ) const;

/// QueryDoubleValue examines the value string. See QueryIntValue().

int QueryDoubleValue( double* _value ) const;

void SetName( const char* _name ) { name = _name; } ///< Set the name of this attribute.

void SetValue( const char* _value ) { value = _value; } ///< Set the value.

void SetIntValue( int _value ); ///< Set the value from an integer.

void SetDoubleValue( double _value ); ///< Set the value from a double.

#ifdef TIXML_USE_STL

/// STL std::string form.

void SetName( const std::string& _name ) { name = _name; }

/// STL std::string form.

void SetValue( const std::string& _value ) { value = _value; }

#endif

/// Get the next sibling attribute in the DOM. Returns null at end.

const TiXmlAttribute* Next() const;

TiXmlAttribute* Next() {

return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() );

}

/// Get the previous sibling attribute in the DOM. Returns null at beginning.

const TiXmlAttribute* Previous() const;

TiXmlAttribute* Previous() {

return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Previous() );

}

bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }

bool operator<( const TiXmlAttribute& rhs ) const { return name < rhs.name; }

bool operator>( const TiXmlAttribute& rhs ) const { return name > rhs.name; }

/* Attribute parsing starts: first letter of the name

virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );

// Prints this Attribute to a FILE stream.

virtual void Print( FILE* cfile, int depth ) const {

Print( cfile, depth, 0 );

}

void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;

// [internal use]

// Set the document pointer so the attribute can report errors.

void SetDocument( TiXmlDocument* doc ) { document = doc; }

TiXmlAttribute( const TiXmlAttribute& ); // not implemented.

void operator=( const TiXmlAttribute& base ); // not allowed.

TiXmlDocument* document; // A pointer back to a document, for error reporting.

TIXML_STRING name;

TIXML_STRING value;

TiXmlAttribute* prev;

TiXmlAttribute* next;

{

TiXmlAttributeSet();

~TiXmlAttributeSet();

void Add( TiXmlAttribute* attribute );

void Remove( TiXmlAttribute* attribute );

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

TiXmlAttribute* First() { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }

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

TiXmlAttribute* Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }

TiXmlAttribute* Find( const char* _name ) const;

TiXmlAttribute* FindOrCreate( const char* _name );

# ifdef TIXML_USE_STL

TiXmlAttribute* Find( const std::string& _name ) const;

TiXmlAttribute* FindOrCreate( const std::string& _name );

# endif

//*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),

//*ME: this class must be also use a hidden/disabled copy-constructor !!!

TiXmlAttributeSet( const TiXmlAttributeSet& ); // not allowed

void operator=( const TiXmlAttributeSet& ); // not allowed (as TiXmlAttribute)

TiXmlAttribute sentinel;

{

/// Construct an element.

TiXmlElement (const char * in_value);

#ifdef TIXML_USE_STL

/// std::string constructor.

TiXmlElement( const std::string& _value );

#endif

TiXmlElement( const TiXmlElement& );

TiXmlElement& operator=( const TiXmlElement& base );

virtual ~TiXmlElement();

/** Given an attribute name, Attribute() returns the value

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

/** Given an attribute name, Attribute() returns the value

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

/** Given an attribute name, Attribute() returns the value

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

/** QueryIntAttribute examines the attribute - it is an alternative to the

*/

int QueryIntAttribute( const char* name, int* _value ) const;

/// QueryUnsignedAttribute examines the attribute - see QueryIntAttribute().

int QueryUnsignedAttribute( const char* name, unsigned* _value ) const;

/** QueryBoolAttribute examines the attribute - see QueryIntAttribute().

int QueryBoolAttribute( const char* name, bool* _value ) const;

/// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().

int QueryDoubleAttribute( const char* name, double* _value ) const;

/// QueryFloatAttribute examines the attribute - see QueryIntAttribute().

int QueryFloatAttribute( const char* name, float* _value ) const {

double d;

int result = QueryDoubleAttribute( name, &d );

if ( result == TIXML_SUCCESS ) {

*_value = (float)d;