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 );    }    /// 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 );    /** 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.    // [internal use] Creates a new Element and returs it.    virtual TiXmlNode* Clone() const;    // [internal use]    virtual void Print( FILE* cfile, int depth ) const;protected:    // 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]        Attribtue parsing starts: next char past '<'                         returns: next char past '>'    */    virtual const char* Parse( const char* p );    /*	[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 );private:    TiXmlAttributeSet attributeSet;};/**	An XML comment.*/class TiXmlComment : public TiXmlNode {public:    /// Constructs an empty comment.    TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {    }    virtual ~TiXmlComment() {    }    // [internal use] Creates a new Element and returs it.    virtual TiXmlNode* Clone() const;    // [internal use]    virtual void Print( FILE* cfile, int depth ) const;protected:    // 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;    /*	[internal use]        Attribtue parsing starts: at the ! of the !--                         returns: next char past '>'    */    virtual const char* Parse( const char* p );};/** 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    // [internal use]    virtual void Print( FILE* cfile, int depth ) const;protected :    // [internal use] Creates a new Element and returns it.    virtual TiXmlNode* Clone() const;    virtual void StreamOut ( TIXML_OSTREAM * out ) const;    // [internal use]    bool Blank() const; // returns true if all white space and new lines    /*	[internal use]            Attribtue parsing starts: First char of the text                             returns: next char past '>'        */    virtual const char* Parse( const char* p );    // [internal use]#ifdef TIXML_USE_STL    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );#endif};/** 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 )    : TiXmlNode( TiXmlNode::DECLARATION ) {        version = _version;        encoding = _encoding;        standalone = _standalone;    }#endif    /// Construct.    TiXmlDeclaration( const char * _version,                      const char * _encoding,                      const char * _standalone );    virtual ~TiXmlDeclaration() {    }    /// Version. Will return empty if none was found.    const char * Version() const {        return version.c_str ();    }    /// Encoding. Will return empty 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 ();    }    // [internal use] Creates a new Element and returs it.    virtual TiXmlNode* Clone() const;    // [internal use]    virtual void Print( FILE* cfile, int depth ) const;protected:    // 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;    //	[internal use]    //	Attribtue parsing starts: next char past '<'    //					 returns: next char past '>'    virtual const char* Parse( const char* p );private:    TIXML_STRING version;    TIXML_STRING encoding;    TIXML_STRING standalone;};/** Any tag that tinyXml doesn't recognize is save 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.*/class TiXmlUnknown : public TiXmlNode {public:    TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN ) {    }    virtual ~TiXmlUnknown() {    }    // [internal use]    virtual TiXmlNode* Clone() const;    // [internal use]    virtual void Print( FILE* cfile, int depth ) const;protected:    // 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;    /*	[internal use]        Attribute parsing starts: First char of the text                         returns: next char past '>'    */    virtual const char* Parse( const char* p );};/** 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 ) :    TiXmlNode( TiXmlNode::DOCUMENT ) {        value = documentName;        error = false;    }#endif    virtual ~TiXmlDocument() {    }    /** Load a file using the current document value.        Returns true if successful. Will delete any existing        document data before loading.    */    bool LoadFile();    /// 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 );    /// Save a file using the given filename. Returns true if successful.    bool SaveFile( const char * filename ) const;#ifdef TIXML_USE_STL    bool LoadFile( const std::string& filename )            ///< STL std::string version. {        StringToBuffer f( filename );        return( f.buffer && LoadFile( f.buffer ));    }    bool SaveFile( const std::string& filename ) const      ///< STL std::string version.    {        StringToBuffer f( filename );        return( f.buffer && SaveFile( f.buffer ));    }#endif    /// Parse the given null terminated block of xml data.    virtual const char* Parse( const char* p );    /** 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.    */    TiXmlElement* RootElement() const {        return FirstChildElement();    }    /// If, during parsing, a error occurs, Error will be set to true.    bool Error() const {        return error;    }    /// Contains a textual (english) description of the error if one occurs.    const char * ErrorDesc() const {        return errorDesc.c_str ();    }    /** Generally, you probably want the error string ( ErrorDesc() ). But if you            prefer the ErrorId, this function will fetch it.        */    const int ErrorId() const {        return errorId;    }    /// If you have handled the error, it can be reset with this call.    void ClearError() {        error = false; errorId = 0; errorDesc = "";    }    /** Dump the document to standard out. */    void Print() const {        Print( stdout, 0 );    }    // [internal use]    virtual void Print( FILE* cfile, int depth = 0 ) const;    // [internal use]    void SetError( int err ) {        assert( err > 0 && err < TIXML_ERROR_STRING_COUNT );        error   = true;        errorId = err;        /* add errorLine to provide more error information. by zhoujunfeng */        char chErrorLine[24];        sprintf(chErrorLine, "Line %d: ", errorLine);        errorDesc = chErrorLine;        errorDesc += errorString[ errorId ];    }protected :    virtual void StreamOut ( TIXML_OSTREAM * out) const;    // [internal use]    virtual TiXmlNode* Clone() const;#ifdef TIXML_USE_STL    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );#endifprivate:    bool error;    int  errorId;    TIXML_STRING errorDesc;};TiXmlDocument * loadXmlCfgFile( bool exitOnError, char *xmlFileName);}#endif