tinyxml.h

一个简单的xml解析代码

    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 );
#endif

private:
    bool error;
    int  errorId;
    TIXML_STRING errorDesc;
};

TiXmlDocument * loadXmlCfgFile( bool exitOnError, char *xmlFileName)
;
}
#endif