void SetIntValue( int value );										///< Set the value from an integer.#ifndef NO_FPU		void SetDoubleValue( double value );								///< Set the value from a double.#endif    #ifdef TIXML_USE_STL	/// STL std::string form.	void SetName( const std::string& _name )		{			StringToBuffer buf( _name );		SetName ( buf.buffer ? buf.buffer : "error" );		}	/// STL std::string form.		void SetValue( const std::string& _value )		{			StringToBuffer buf( _value );		SetValue( buf.buffer ? buf.buffer : "error" );		}	#endif	/// Get the next sibling attribute in the DOM. Returns null at end.	TiXmlAttribute* Next() const;	/// Get the previous sibling attribute in the DOM. Returns null at beginning.	TiXmlAttribute* Previous() const;	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;	virtual void StreamOut( TIXML_OSTREAM * out ) 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 );	TiXmlAttribute* First() const	{ return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }	TiXmlAttribute* Last()  const	{ return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }	TiXmlAttribute*	Find( const char * name ) const;		// [RC] NEW	TiXmlAttribute*	Find( const char * name, bool casefree ) const;private:	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;		// [RC] NEW	/** Case insensitive attribute match	*/	const char* Attribute( const char* name, bool casefree ) 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;	#ifndef NO_FPU	/** 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;#endif	/** 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;#ifndef NO_FPU	/// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().	int QueryDoubleAttribute( const char* name, double* value ) const;#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 char* Attribute( const std::string& name ) const				{ return Attribute( name.c_str() ); }	const char* Attribute( const std::string& name, int* i ) const		{ return Attribute( name.c_str(), i ); }#ifndef NO_FPU		const char* Attribute( const std::string& name, double* d ) const	{ return Attribute( name.c_str(), d ); }#endif	int QueryIntAttribute( const std::string& name, int* value ) const	{ return QueryIntAttribute( name.c_str(), value ); }#ifndef NO_FPU	int QueryDoubleAttribute( const std::string& name, double* value ) const { return QueryDoubleAttribute( name.c_str(), value ); }#endif	/// STL std::string form.	void SetAttribute( const std::string& name, const std::string& _value )		{			StringToBuffer n( name );		StringToBuffer v( _value );		if ( n.buffer && v.buffer )			SetAttribute (n.buffer, v.buffer );		}		///< STL std::string form.	void SetAttribute( const std::string& name, int _value )		{			StringToBuffer n( name );		if ( n.buffer )			SetAttribute (n.buffer, _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 );#ifndef NO_FPU	/** 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 );#endif	/** 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	TiXmlAttribute* FirstAttribute() const	{ return attributeSet.First(); }		///< Access the first attribute in this element.	TiXmlAttribute* LastAttribute()	const 	{ return attributeSet.Last(); }		///< Access the last attribute in this element.	/// Creates a new Element and returns it - the returned element is a copy.	virtual TiXmlNode* Clone() const;	// Print the Element to a FILE stream.	virtual void Print( FILE* cfile, int depth ) const;	/*	Attribtue parsing starts: next char past '<'						 returns: next char past '>'	*/	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );protected:	void CopyTo( TiXmlElement* target ) const;	void ClearThis();	// like clear, but initializes 'this' object as well	// Used to be public [internal use]	#ifdef TIXML_USE_STL	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );	#endif	virtual void StreamOut( TIXML_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, TiXmlParsingData* prevData, TiXmlEncoding encoding );private:	TiXmlAttributeSet attributeSet;};/**	An XML comment.*/class TiXmlComment : public TiXmlNode{public:	/// Constructs an empty comment.	TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}	TiXmlComment( const TiXmlComment& );	void operator=( const TiXmlComment& base );	virtual ~TiXmlComment()	{}	/// Returns a copy of this Comment.	virtual TiXmlNode* Clone() const;	/// Write this Comment to a FILE stream.	virtual void Print( FILE* cfile, int depth ) const;	/*	Attribtue parsing starts: at the ! of the !--						 returns: next char past '>'	*/	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );protected:	void CopyTo( TiXmlComment* target ) const;	// used to be public	#ifdef TIXML_USE_STL	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );	#endif	virtual void StreamOut( TIXML_OSTREAM * out ) const;private:};/** XML text. Contained in an element.*/class TiXmlText : public TiXmlNode{	friend class TiXmlElement;public:	/// Constructor.	TiXmlText (const char * initValue) : TiXmlNode (TiXmlNode::TEXT)	{		SetValue( initValue );	}	virtual ~TiXmlText() {}	#ifdef TIXML_USE_STL	/// Constructor.	TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)	{		SetValue( initValue );	}	#endif	TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT )	{ copy.CopyTo( this ); }	void operator=( const TiXmlText& base )							 	{ base.CopyTo( this ); }	/// Write this text object to a FILE stream.	virtual void Print( FILE* cfile, int depth ) const;	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );protected :	///  [internal use] Creates a new Element and returns it.	virtual TiXmlNode* Clone() const;	void CopyTo( TiXmlText* target ) const;	virtual void StreamOut ( TIXML_OSTREAM * out ) const;	bool Blank() const;	// returns true if all white space and new lines	// [internal use]	#ifdef TIXML_USE_STL	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );	#endifprivate:};/** In correct XML the declaration is the first entry in the file.	@verbatim		<?xml version="1.0" standalone="yes"?>	@endverbatim	TinyXml will happily read or write files without a declaration,	however. There are 3 possible attributes to the declaration:	version, encoding, and standalone.	Note: In this version of the code, the attributes are	handled as special cases, not generic attributes, simply	because there can only be at most 3 and they are always the same.*/class TiXmlDeclaration : public TiXmlNode{public:	/// Construct an empty declaration.	TiXmlDeclaration()   : TiXmlNode( TiXmlNode::DECLARATION ) {}#ifdef TIXML_USE_STL	/// Constructor.	TiXmlDeclaration(	const std::string& _version,						const std::string& _encoding,						const std::string& _standalone );#endif	/// Construct.	TiXmlDeclaration(	const char* _version,						const char* _encoding,						const char* _standalone );	TiXmlDeclaration( const TiXmlDeclaration& copy );	void operator=( const TiXmlDeclaration& copy );	virtual ~TiXmlDeclaration()	{}	/// Version. Will return an empty string if none was found.	const char *Version() const			{ return version.c_str (); }