This is essentially a SAX interface for TinyXML. (Note however it doesn't re-parse		the XML for the callbacks, so the performance of TinyXML is unchanged by using this		interface versus any other.)		The interface has been based on ideas from:		- http://www.saxproject.org/		- http://c2.com/cgi/wiki?HierarchicalVisitorPattern 		Which are both good references for "visiting".		An example of using Accept():		@verbatim		TiXmlPrinter printer;		tinyxmlDoc.Accept( &printer );		const char* xmlcstr = printer.CStr();		@endverbatim	*/	virtual bool Accept( TiXmlVisitor* visitor ) const = 0;protected:	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;private:	TiXmlNode( const TiXmlNode& );				// not implemented.	void operator=( const TiXmlNode& base );	// not allowed.};/** An attribute is a name-value pair. Elements have an arbitrary	number of attributes, each with a unique name.	@note The attributes are not TiXmlNodes, since they are not		  part of the tinyXML document object model. There are other		  suggested ways to look at this problem.*/class TiXmlAttribute : public TiXmlBase{	friend class TiXmlAttributeSet;public:	/// 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		IntValue() method with richer error checking.		If the value is an integer, it is stored in 'value' and 		the call returns TIXML_SUCCESS. If it is not		an integer, it returns TIXML_WRONG_TYPE.		A specialized but useful call. Note that for success it returns 0,		which is the opposite of almost all other TinyXml calls.	*/	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						 returns: the next char after the value end quote	*/	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; }private:	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;};/*	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 TiXmlAttributeSet{public:	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; }	const TiXmlAttribute*	Find( const char* _name ) const;	TiXmlAttribute*	Find( const char* _name ) {		return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );	}	#ifdef TIXML_USE_STL	const TiXmlAttribute*	Find( const std::string& _name ) const;	TiXmlAttribute*	Find( const std::string& _name ) {		return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );	}	#endifprivate:	//*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;};/** The element is a container class. It has a value, the element name,	and can contain other elements, text, comments, and unknowns.	Elements also contain an arbitrary number of attributes.*/class TiXmlElement : public TiXmlNode{public:	/// Construct an element.	TiXmlElement (const char * in_value);	#ifdef TIXML_USE_STL	/// std::string constructor.	TiXmlElement( const std::string& _value );	#endif	TiXmlElement( const TiXmlElement& );	void operator=( const TiXmlElement& base );	virtual ~TiXmlElement();	/** Given an attribute name, Attribute() returns the value		for the attribute of that name, or null if none exists.	*/	const char* Attribute( const char* name ) const;	/** Given an attribute name, Attribute() returns the value		for the attribute of that name, or null if none exists.		If the attribute exists and can be converted to an integer,		the integer value will be put in the return 'i', if 'i'		is non-null.	*/	const char* Attribute( const char* name, int* i ) const;	/** Given an attribute name, Attribute() returns the value		for the attribute of that name, or null if none exists.		If the attribute exists and can be converted to an double,		the double value will be put in the return 'd', if 'd'		is non-null.	*/	const char* Attribute( const char* name, double* d ) const;	/** QueryIntAttribute examines the attribute - it is an alternative to the		Attribute() method with richer error checking.		If the attribute is an integer, it is stored in 'value' and 		the call returns TIXML_SUCCESS. If it is not		an integer, it returns TIXML_WRONG_TYPE. If the attribute		does not exist, then TIXML_NO_ATTRIBUTE is returned.	*/		int QueryIntAttribute( const char* name, int* _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;		}		return result;	}    #ifdef TIXML_USE_STL	/** Template form of the attribute query which will try to read the		attribute into the specified type. Very easy, very powerful, but		be careful to make sure to call this with the correct type.		@return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE	*/	template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const	{		const TiXmlAttribute* node = attributeSet.Find( name );		if ( !node )			return TIXML_NO_ATTRIBUTE;		std::stringstream sstream( node->ValueStr() );		sstream >> *outValue;		if ( !sstream.fail() )			return TIXML_SUCCESS;		return TIXML_WRONG_TYPE;	}	#endif	/** Sets an attribute of name to a given value. The attribute		will be created if it does not exist, or changed if it does.	*/	void SetAttribute( const char* name, const char * _value );    #ifdef TIXML_USE_STL	const std::string* Attribute( const std::string& name ) const;	const std::string* Attribute( const std::string& name, int* i ) const;	const std::string* Attribute( const std::string& name, double* d ) const;	int QueryIntAttribute( const std::string& name, int* _value ) const;	int QueryDoubleAttribute( const std::string& name, double* _value ) const;	/// STL std::string form.	void SetAttribute( const std::string& name, const std::string& _value );	///< STL std::string form.	void SetAttribute( const std::string& name, int _value );	#endif	/** Sets an attribute of name to a given value. The attribute		will be created if it does not exist, or changed if it does.	*/	void SetAttribute( const char * name, int value );	/** Sets an attribute of name to a given value. The attribute		will be created if it does not exist, or changed if it does.	*/	void SetDoubleAttribute( const char * name, double value );	/** Deletes an attribute with the given name.	*/	void RemoveAttribute( const char * name );    #ifdef TIXML_USE_STL	void RemoveAttribute( const std::string& name )	{	RemoveAttribute (name.c_str ());	}	///< STL std::string form.	#endif	const TiXmlAttribute* FirstAttribute() const	{ return attributeSet.First(); }		///< Access the first attribute in this element.	TiXmlAttribute* FirstAttribute() 				{ return attributeSet.First(); }	const TiXmlAttribute* LastAttribute()	const 	{ return attributeSet.Last(); }		///< Access the last attribute in this element.	TiXmlAttribute* LastAttribute()					{ return attributeSet.Last(); }	/** Convenience function for easy access to the text inside an element. Although easy		and concise, GetText() is limited compared to getting the TiXmlText child		and accessing it directly.			If the first child of 'this' is a TiXmlText, 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".