Note that this function can be misleading. If the element foo was created from		this XML:		@verbatim		<foo><b>This is text</b></foo> 		@endverbatim		then the value of str would be null. The first child node isn't a text node, it is		another element. From this XML:		@verbatim		<foo>This is <b>text</b></foo> 		@endverbatim		GetText() will return "This is ".		WARNING: GetText() accesses a child node - don't become confused with the 				 similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are 				 safe type casts on the referenced node.	*/	const char* GetText() const;	/// 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 );	virtual const TiXmlElement*     ToElement()     const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	virtual TiXmlElement*           ToElement()	          { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	/** Walk the XML tree visiting this node and all of its children. 	*/	virtual bool Accept( TiXmlVisitor* visitor ) const;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( std::istream * in, TIXML_STRING * tag );	#endif	/*	[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 ) {}	/// Construct a comment from text.	TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::COMMENT ) {		SetValue( _value );	}	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 );	virtual const TiXmlComment*  ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	virtual TiXmlComment*  ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	/** Walk the XML tree visiting this node and all of its children. 	*/	virtual bool Accept( TiXmlVisitor* visitor ) const;protected:	void CopyTo( TiXmlComment* target ) const;	// used to be public	#ifdef TIXML_USE_STL	virtual void StreamIn( std::istream * in, TIXML_STRING * tag );	#endif//	virtual void StreamOut( TIXML_OSTREAM * out ) const;private:};/** XML text. A text node can have 2 ways to output the next. "normal" output 	and CDATA. It will default to the mode it was parsed from the XML file and	you generally want to leave it alone, but you can change the output mode with 	SetCDATA() and query it with CDATA().*/class TiXmlText : public TiXmlNode{	friend class TiXmlElement;public:	/** Constructor for text element. By default, it is treated as 		normal, encoded text. If you want it be output as a CDATA text		element, set the parameter _cdata to 'true'	*/	TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT)	{		SetValue( initValue );		cdata = false;	}	virtual ~TiXmlText() {}	#ifdef TIXML_USE_STL	/// Constructor.	TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)	{		SetValue( initValue );		cdata = false;	}	#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;	/// Queries whether this represents text using a CDATA section.	bool CDATA() const				{ return cdata; }	/// Turns on or off a CDATA representation of text.	void SetCDATA( bool _cdata )	{ cdata = _cdata; }	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );	virtual const TiXmlText* ToText() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	virtual TiXmlText*       ToText()       { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	/** Walk the XML tree visiting this node and all of its children. 	*/	virtual bool Accept( TiXmlVisitor* content ) const;protected :	///  [internal use] Creates a new Element and returns it.	virtual TiXmlNode* Clone() const;	void CopyTo( TiXmlText* target ) const;	bool Blank() const;	// returns true if all white space and new lines	// [internal use]	#ifdef TIXML_USE_STL	virtual void StreamIn( std::istream * in, TIXML_STRING * tag );	#endifprivate:	bool cdata;			// true if this should be input and output as a CDATA style text element};/** 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 (); }	/// Encoding. Will return an empty string if none was found.	const char *Encoding() const		{ return encoding.c_str (); }	/// Is this a standalone document?	const char *Standalone() const		{ return standalone.c_str (); }	/// Creates a copy of this Declaration and returns it.	virtual TiXmlNode* Clone() const;	// Print this declaration to a FILE stream.	virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;	virtual void Print( FILE* cfile, int depth ) const {		Print( cfile, depth, 0 );	}	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );	virtual const TiXmlDeclaration* ToDeclaration() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	virtual TiXmlDeclaration*       ToDeclaration()       { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	/** Walk the XML tree visiting this node and all of its children. 	*/	virtual bool Accept( TiXmlVisitor* visitor ) const;protected:	void CopyTo( TiXmlDeclaration* target ) const;	// used to be public	#ifdef TIXML_USE_STL	virtual void StreamIn( std::istream * in, TIXML_STRING * tag );	#endifprivate:	TIXML_STRING version;	TIXML_STRING encoding;	TIXML_STRING standalone;};/** Any tag that tinyXml doesn't recognize is saved as an	unknown. It is a tag of text, but should not be modified.	It will be written back to the XML, unchanged, when the file	is saved.	DTD tags get thrown into TiXmlUnknowns.*/class TiXmlUnknown : public TiXmlNode{public:	TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN )	{}	virtual ~TiXmlUnknown() {}	TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN )		{ copy.CopyTo( this ); }	void operator=( const TiXmlUnknown& copy )										{ copy.CopyTo( this ); }	/// Creates a copy of this Unknown and returns it.	virtual TiXmlNode* Clone() const;	// Print this Unknown to a FILE stream.	virtual void Print( FILE* cfile, int depth ) const;	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );	virtual const TiXmlUnknown*     ToUnknown()     const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	virtual TiXmlUnknown*           ToUnknown()	    { return this; } ///< Cast to a more defined type. Will return null not of the requested type.	/** Walk the XML tree visiting this node and all of its children. 	*/	virtual bool Accept( TiXmlVisitor* content ) const;protected:	void CopyTo( TiXmlUnknown* target ) const;	#ifdef TIXML_USE_STL	virtual void StreamIn( std::istream * in, TIXML_STRING * tag );	#endifprivate:};/** Always the top level node. A document binds together all the	XML pieces. It can be saved, loaded, and printed to the screen.	The 'value' of a document node is the xml file name.*/class TiXmlDocument : public TiXmlNode{public:	/// Create an empty document, that has no name.	TiXmlDocument();	/// Create a document with a name. The name of the document is also the filename of the xml.	TiXmlDocument( const char * documentName );	#ifdef TIXML_USE_STL	/// Constructor.	TiXmlDocument( const std::string& documentName );	#endif	TiXmlDocument( const TiXmlDocument& copy );	void operator=( const TiXmlDocument& copy );	virtual ~TiXmlDocument() {}	/** Load a file using the current document value.		Returns true if successful. Will delete any existing		document data before loading.	*/	bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );	/// Save a file using the current document value. Returns true if successful.	bool SaveFile() const;	/// Load a file using the given filename. Returns true if successful.	bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );	/// Save a file using the given filename. Returns true if successful.	bool SaveFile( const char * filename ) const;	/** Load a file using the given FILE*. Returns true if successful. Note that this method		doesn't stream - the entire object pointed at by the FILE*		will be interpreted as an XML file. TinyXML doesn't stream in XML from the current		file location. Streaming may be added in the future.	*/	bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );	/// Save a file using the given FILE*. Returns true if successful.	bool SaveFile( FILE* ) const;	#ifdef TIXML_USE_STL	bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )			///< STL std::string version.	{//		StringToBuffer f( filename );//		return ( f.buffer && LoadFile( f.buffer, encoding ));		return LoadFile( filename.c_str(), encoding );	}	bool SaveFile( const std::string& filename ) const		///< STL std::string version.	{//		StringToBuffer f( filename );//		return ( f.buffer && SaveFile( f.buffer ));		return SaveFile( filename.c_str() );	}	#endif	/** Parse the given null terminated block of xml data. Passing in an encoding to this		method (either TIXML_ENCODING_LEGACY or TIXML_ENCODING_UTF8 will force TinyXml		to use that encoding, regardless of what TinyXml might otherwise try to detect.	*/	virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );	/** Get the root element -- the only top level element -- of the document.		In well formed XML, there should only be one. TinyXml is tolerant of		multiple elements at the document level.	*/	const TiXmlElement* RootElement() const		{ return FirstChildElement(); }	TiXmlElement* RootElement()					{ return FirstChildElement(); }