Main Page | Class Hierarchy | Class List | File List | Class Members

# tinyxml.h

    00001 /*
    00002 www.sourceforge.net/projects/tinyxml
    00003 Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
    00004
    00005 This software is provided 'as-is', without any express or implied
    00006 warranty. In no event will the authors be held liable for any
    00007 damages arising from the use of this software.
    00008
    00009 Permission is granted to anyone to use this software for any
    00010 purpose, including commercial applications, and to alter it and
    00011 redistribute it freely, subject to the following restrictions:
    00012
    00013 1. The origin of this software must not be misrepresented; you must
    00014 not claim that you wrote the original software. If you use this
    00015 software in a product, an acknowledgment in the product documentation
    00016 would be appreciated but is not required.
    00017
    00018 2. Altered source versions must be plainly marked as such, and
    00019 must not be misrepresented as being the original software.
    00020
    00021 3. This notice may not be removed or altered from any source
    00022 distribution.
    00023 */
    00024
    00025
    00026 #ifndef TINYXML_INCLUDED
    00027 #define TINYXML_INCLUDED
    00028
    00029 #ifdef _MSC_VER
    00030 #pragma warning( push )
    00031 #pragma warning( disable : 4530 )
    00032 #pragma warning( disable : 4786 )
    00033 #endif
    00034
    00035 #include <ctype.h>
    00036 #include <stdio.h>
    00037 #include <stdlib.h>
    00038 #include <string.h>
    00039 #include <assert.h>
    00040
    00041 // Help out windows:
    00042 #if defined( _DEBUG ) && !defined( DEBUG )
    00043 #define DEBUG
    00044 #endif
    00045
    00046 #ifdef TIXML_USE_STL
    00047     #include <string>
    00048     #include <iostream>
    00049     #define TIXML_STRING    std::string
    00050     #define TIXML_ISTREAM   std::istream
    00051     #define TIXML_OSTREAM   std::ostream
    00052 #else
    00053     #include "tinystr.h"
    00054     #define TIXML_STRING    TiXmlString
    00055     #define TIXML_OSTREAM   TiXmlOutStream
    00056 #endif
    00057
    00058 // Deprecated library function hell. Compilers want to use the
    00059 // new safe versions. This probably doesn't fully address the problem,
    00060 // but it gets closer. There are too many compilers for me to fully
    00061 // test. If you get compilation troubles, undefine TIXML_SAFE
    00062
    00063 #define TIXML_SAFE      // TinyXml isn't fully buffer overrun protected, safe code. This is work in progress.
    00064 #ifdef TIXML_SAFE
    00065     #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
    00066         // Microsoft visual studio, version 2005 and higher.
    00067         #define TIXML_SNPRINTF _snprintf_s
    00068         #define TIXML_SNSCANF  _snscanf_s
    00069     #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
    00070         // Microsoft visual studio, version 6 and higher.
    00071         //#pragma message( "Using _sn* functions." )
    00072         #define TIXML_SNPRINTF _snprintf
    00073         #define TIXML_SNSCANF  _snscanf
    00074     #elif defined(__GNUC__) && (__GNUC__ >= 3 )
    00075         // GCC version 3 and higher.s
    00076         //#warning( "Using sn* functions." )
    00077         #define TIXML_SNPRINTF snprintf
    00078         #define TIXML_SNSCANF  snscanf
    00079     #endif
    00080 #endif
    00081
    00082 class TiXmlDocument;
    00083 class TiXmlElement;
    00084 class TiXmlComment;
    00085 class TiXmlUnknown;
    00086 class TiXmlAttribute;
    00087 class TiXmlText;
    00088 class TiXmlDeclaration;
    00089 class TiXmlParsingData;
    00090
    00091 const int TIXML_MAJOR_VERSION = 2;
    00092 const int TIXML_MINOR_VERSION = 4;
    00093 const int TIXML_PATCH_VERSION = 3;
    00094
    00095 /*  Internal structure for tracking location of items
    00096     in the XML file.
    00097 */
    00098 struct TiXmlCursor
    00099 {
    00100     TiXmlCursor()       { Clear(); }
    00101     void Clear()        { row = col = -1; }
    00102
    00103     int row;    // 0 based.
    00104     int col;    // 0 based.
    00105 };
    00106
    00107
    00108 // Only used by Attribute::Query functions
    00109 enum
    00110 {
    00111     TIXML_SUCCESS,
    00112     TIXML_NO_ATTRIBUTE,
    00113     TIXML_WRONG_TYPE
    00114 };
    00115
    00116
    00117 // Used by the parsing routines.
    00118 enum TiXmlEncoding
    00119 {
    00120     TIXML_ENCODING_UNKNOWN,
    00121     TIXML_ENCODING_UTF8,
    00122     TIXML_ENCODING_LEGACY
    00123 };
    00124
    00125 const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
    00126
    00149 class TiXmlBase
    00150 {
    00151     friend class TiXmlNode;
    00152     friend class TiXmlElement;
    00153     friend class TiXmlDocument;
    00154
    00155 public:
    00156     TiXmlBase() :   userData(0) {}
    00157     virtual ~TiXmlBase()                    {}
    00158
    00164     virtual void Print( FILE* cfile, int depth ) const = 0;
    00165
    00172     static void SetCondenseWhiteSpace( bool condense )      { condenseWhiteSpace = condense; }
    00173
    00175     static bool IsWhiteSpaceCondensed()                     { return condenseWhiteSpace; }
    00176
    00195     int Row() const         { return location.row + 1; }
    00196     int Column() const      { return location.col + 1; }
    00197
    00198     void  SetUserData( void* user )         { userData = user; }
    00199     void* GetUserData()                     { return userData; }
    00200
    00201     // Table that returs, for a given lead byte, the total number of bytes
    00202     // in the UTF-8 sequence.
    00203     static const int utf8ByteTable[256];
    00204
    00205     virtual const char* Parse(  const char* p,
    00206                                 TiXmlParsingData* data,
    00207                                 TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
    00208
    00209     enum
    00210     {
    00211         TIXML_NO_ERROR = 0,
    00212         TIXML_ERROR,
    00213         TIXML_ERROR_OPENING_FILE,
    00214         TIXML_ERROR_OUT_OF_MEMORY,
    00215         TIXML_ERROR_PARSING_ELEMENT,
    00216         TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
    00217         TIXML_ERROR_READING_ELEMENT_VALUE,
    00218         TIXML_ERROR_READING_ATTRIBUTES,
    00219         TIXML_ERROR_PARSING_EMPTY,
    00220         TIXML_ERROR_READING_END_TAG,
    00221         TIXML_ERROR_PARSING_UNKNOWN,
    00222         TIXML_ERROR_PARSING_COMMENT,
    00223         TIXML_ERROR_PARSING_DECLARATION,
    00224         TIXML_ERROR_DOCUMENT_EMPTY,
    00225         TIXML_ERROR_EMBEDDED_NULL,
    00226         TIXML_ERROR_PARSING_CDATA,
    00227
    00228         TIXML_ERROR_STRING_COUNT
    00229     };
    00230
    00231 protected:
    00232
    00233     // See STL_STRING_BUG
    00234     // Utility class to overcome a bug.
    00235     class StringToBuffer
    00236     {
    00237       public:
    00238         StringToBuffer( const TIXML_STRING& str );
    00239         ~StringToBuffer();
    00240         char* buffer;
    00241     };
    00242
    00243     static const char*  SkipWhiteSpace( const char*, TiXmlEncoding encoding );
    00244     inline static bool  IsWhiteSpace( char c )
    00245     {
    00246         return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );
    00247     }
    00248     inline static bool  IsWhiteSpace( int c )
    00249     {
    00250         if ( c < 256 )
    00251             return IsWhiteSpace( (char) c );
    00252         return false;   // Again, only truly correct for English/Latin...but usually works.
    00253     }
    00254
    00255     virtual void StreamOut (TIXML_OSTREAM *) const = 0;
    00256
    00257     #ifdef TIXML_USE_STL
    00258         static bool StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag );
    00259         static bool StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag );
    00260     #endif
    00261
    00262     /*  Reads an XML name into the string provided. Returns
    00263         a pointer just past the last character of the name,
    00264         or 0 if the function has an error.
    00265     */
    00266     static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );
    00267
    00268     /*  Reads text. Returns a pointer past the given end tag.
    00269         Wickedly complex options, but it keeps the (sensitive) code in one place.
    00270     */
    00271     static const char* ReadText(    const char* in,             // where to start
    00272                                     TIXML_STRING* text,         // the string read
    00273                                     bool ignoreWhiteSpace,      // whether to keep the white space
    00274                                     const char* endTag,         // what ends this text
    00275                                     bool ignoreCase,            // whether to ignore case in the end tag
    00276                                     TiXmlEncoding encoding );   // the current encoding
    00277
    00278     // If an entity has been found, transform it into a character.
    00279     static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding );
    00280
    00281     // Get a character, while interpreting entities.
    00282     // The length can be from 0 to 4 bytes.
    00283     inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
    00284     {
    00285         assert( p );
    00286         if ( encoding == TIXML_ENCODING_UTF8 )
    00287         {
    00288             *length = utf8ByteTable[ *((unsigned char*)p) ];
    00289             assert( *length >= 0 && *length < 5 );
    00290         }
    00291         else
    00292         {
    00293             *length = 1;
    00294         }
    00295
    00296         if ( *length == 1 )
    00297         {
    00298             if ( *p == '&' )
    00299                 return GetEntity( p, _value, length, encoding );
    00300             *_value = *p;
    00301             return p+1;
    00302         }
    00303         else if ( *length )
    00304         {
    00305             //strncpy( _value, p, *length );    // lots of compilers don't like this function (unsafe),
    00306                                                 // and the null terminator isn't needed
    00307             for( int i=0; p[i] && i<*length; ++i ) {
    00308                 _value[i] = p[i];
    00309             }
    00310             return p + (*length);
    00311         }
    00312         else
    00313         {
    00314             // Not valid text.
    00315             return 0;
    00316         }
    00317     }
    00318
    00319     // Puts a string to a stream, expanding entities as it goes.
    00320     // Note this should not contian the '<', '>', etc, or they will be transformed into entities!
    00321     static void PutString( const TIXML_STRING& str, TIXML_OSTREAM* out );
    00322
    00323     static void PutString( const TIXML_STRING& str, TIXML_STRING* out );
    00324
    00325     // Return true if the next characters in the stream are any of the endTag sequences.
    00326     // Ignore case only works for english, and should only be relied on when comparing
    00327     // to English words: StringEqual( p, "version", true ) is fine.
    00328     static bool StringEqual(    const char* p,
    00329                                 const char* endTag,
    00330                                 bool ignoreCase,
    00331                                 TiXmlEncoding encoding );
    00332
    00333     static const char* errorString[ TIXML_ERROR_STRING_COUNT ];
    00334
    00335     TiXmlCursor location;
    00336
    00338     void*           userData;
    00339
    00340     // None of these methods are reliable for any language except English.
    00341     // Good for approximation, not great for accuracy.
    00342     static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
    00343     static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
    00344     inline static int ToLower( int v, TiXmlEncoding encoding )
    00345     {
    00346         if ( encoding == TIXML_ENCODING_UTF8 )
    00347         {
    00348             if ( v < 128 ) return tolower( v );
    00349             return v;
    00350         }
    00351         else
    00352         {
    00353             return tolower( v );
    00354         }
    00355     }
    00356     static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
    00357
    00358 private:
    00359     TiXmlBase( const TiXmlBase& );              // not implemented.
    00360     void operator=( const TiXmlBase& base );    // not allowed.
    00361
    00362     struct Entity
    00363     {
    00364         const char*     str;
    00365         unsigned int    strLength;
    00366         char            chr;
    00367     };
    00368     enum
    00369     {
    00370         NUM_ENTITY = 5,
    00371         MAX_ENTITY_LENGTH = 6
    00372
    00373     };
    00374     static Entity entity[ NUM_ENTITY ];
    00375     static bool condenseWhiteSpace;
    00376 };
    00377
    00378
    00385 class TiXmlNode : public TiXmlBase
    00386 {
    00387     friend class TiXmlDocument;
    00388     friend class TiXmlElement;
    00389
    00390 public:
    00391     #ifdef TIXML_USE_STL
    00392
    00396         friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
    00397
    00414         friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
    00415
    00417         friend std::string& operator<< (std::string& out, const TiXmlNode& base );
    00418
    00419     #else
    00420         // Used internally, not part of the public API.
    00421         friend TIXML_OSTREAM& operator<< (TIXML_OSTREAM& out, const TiXmlNode& base);
    00422     #endif
    00423
    00427     enum NodeType
    00428     {
    00429         DOCUMENT,
    00430         ELEMENT,
    00431         COMMENT,
    00432         UNKNOWN,
    00433         TEXT,
    00434         DECLARATION,
    00435         TYPECOUNT
    00436     };
    00437
    00438     virtual ~TiXmlNode();
    00439
    00452     const char *Value() const { return value.c_str (); }
    00453
    00454     #ifdef TIXML_USE_STL
    00455
    00459     const std::string& ValueStr() const { return value; }
    00460     #endif
    00461
    00471     void SetValue(const char * _value) { value = _value;}
    00472
    00473     #ifdef TIXML_USE_STL
    00474
    00475     void SetValue( const std::string& _value )  { value = _value; }
    00476     #endif
    00477
    00479     void Clear();
    00480
    00482     TiXmlNode* Parent()                         { return parent; }
    00483     const TiXmlNode* Parent() const             { return parent; }
    00484
    00485     const TiXmlNode* FirstChild()   const   { return firstChild; }
    00486     TiXmlNode* FirstChild()                 { return firstChild; }
    00487     const TiXmlNode* FirstChild( const char * value ) const;
    00488     TiXmlNode* FirstChild( const char * value );
    00489
    00490     const TiXmlNode* LastChild() const  { return lastChild; }
    00491     TiXmlNode* LastChild()  { return lastChild; }
    00492     const TiXmlNode* LastChild( const char * value ) const;
    00493     TiXmlNode* LastChild( const char * value );
    00494
    00495     #ifdef TIXML_USE_STL
    00496     const TiXmlNode* FirstChild( const std::string& _value ) const  {   return FirstChild (_value.c_str ());    }
    00497     TiXmlNode* FirstChild( const std::string& _value )              {   return FirstChild (_value.c_str ());    }
    00498     const TiXmlNode* LastChild( const std::string& _value ) const   {   return LastChild (_value.c_str ()); }
    00499     TiXmlNode* LastChild( const std::string& _value )               {   return LastChild (_value.c_str ()); }
    00500     #endif
    00501
    00518     const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
    00519     TiXmlNode* IterateChildren( TiXmlNode* previous );
    00520
    00522     const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
    00523     TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous );
    00524
    00525     #ifdef TIXML_USE_STL
    00526     const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const  {   return IterateChildren (_value.c_str (), previous); }
    00527     TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) {  return IterateChildren (_value.c_str (), previous); }
    00528     #endif
    00529
    00533     TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
    00534
    00535
    00545     TiXmlNode* LinkEndChild( TiXmlNode* addThis );
    00546
    00550     TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
    00551
    00555     TiXmlNode* InsertAfterChild(  TiXmlNode* afterThis, const TiXmlNode& addThis );
    00556
    00560     TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
    00561
    00563     bool RemoveChild( TiXmlNode* removeThis );
    00564
    00566     const TiXmlNode* PreviousSibling() const            { return prev; }
    00567     TiXmlNode* PreviousSibling()                        { return prev; }
    00568
    00570     const TiXmlNode* PreviousSibling( const char * ) const;
    00571     TiXmlNode* PreviousSibling( const char * );
    00572
    00573     #ifdef TIXML_USE_STL
    00574     const TiXmlNode* PreviousSibling( const std::string& _value ) const {   return PreviousSibling (_value.c_str ());   }
    00575     TiXmlNode* PreviousSibling( const std::string& _value )             {   return PreviousSibling (_value.c_str ());   }
    00576     const TiXmlNode* NextSibling( const std::string& _value) const      {   return NextSibling (_value.c_str ());   }
    00577     TiXmlNode* NextSibling( const std::string& _value)                  {   return NextSibling (_value.c_str ());   }
    00578     #endif
    00579
    00581     const TiXmlNode* NextSibling() const                { return next; }
    00582     TiXmlNode* NextSibling()                            { return next; }
    00583
    00585     const TiXmlNode* NextSibling( const char * ) const;
    00586     TiXmlNode* NextSibling( const char * );
    00587
    00592     const TiXmlElement* NextSiblingElement() const;
    00593     TiXmlElement* NextSiblingElement();
    00594
    00599     const TiXmlElement* NextSiblingElement( const char * ) const;
    00600     TiXmlElement* NextSiblingElement( const char * );
    00601
    00602     #ifdef TIXML_USE_STL
    00603     const TiXmlElement* NextSiblingElement( const std::string& _value) const    {   return NextSiblingElement (_value.c_str ());    }
    00604     TiXmlElement* NextSiblingElement( const std::string& _value)                {   return NextSiblingElement (_value.c_str ());    }
    00605     #endif
    00606
    00608     const TiXmlElement* FirstChildElement() const;
    00609     TiXmlElement* FirstChildElement();
    00610
    00612     const TiXmlElement* FirstChildElement( const char * value ) const;
    00613     TiXmlElement* FirstChildElement( const char * value );
    00614
    00615     #ifdef TIXML_USE_STL
    00616     const TiXmlElement* FirstChildElement( const std::string& _value ) const    {   return FirstChildElement (_value.c_str ()); }
    00617     TiXmlElement* FirstChildElement( const std::string& _value )                {   return FirstChildElement (_value.c_str ()); }
    00618     #endif
    00619
    00624     int Type() const    { return type; }
    00625
    00629     const TiXmlDocument* GetDocument() const;
    00630     TiXmlDocument* GetDocument();
    00631
    00633     bool NoChildren() const                     { return !firstChild; }
    00634
    00635     virtual const TiXmlDocument*    ToDocument()    const { return 0; }
    00636     virtual const TiXmlElement*     ToElement()     const { return 0; }
    00637     virtual const TiXmlComment*     ToComment()     const { return 0; }
    00638     virtual const TiXmlUnknown*     ToUnknown()     const { return 0; }
    00639     virtual const TiXmlText*        ToText()        const { return 0; }
    00640     virtual const TiXmlDeclaration* ToDeclaration() const { return 0; }
    00641
    00642     virtual TiXmlDocument*          ToDocument()    { return 0; }
    00643     virtual TiXmlElement*           ToElement()     { return 0; }
    00644     virtual TiXmlComment*           ToComment()     { return 0; }
    00645     virtual TiXmlUnknown*           ToUnknown()     { return 0; }
    00646     virtual TiXmlText*              ToText()        { return 0; }
    00647     virtual TiXmlDeclaration*       ToDeclaration() { return 0; }
    00648
    00652     virtual TiXmlNode* Clone() const = 0;
    00653
    00654 protected:
    00655     TiXmlNode( NodeType _type );
    00656
    00657     // Copy to the allocated object. Shared functionality between Clone, Copy constructor,
    00658     // and the assignment operator.
    00659     void CopyTo( TiXmlNode* target ) const;
    00660
    00661     #ifdef TIXML_USE_STL
    00662         // The real work of the input operator.
    00663         virtual void StreamIn( TIXML_ISTREAM* in, TIXML_STRING* tag ) = 0;
    00664     #endif
    00665
    00666     // Figure out what is at *p, and parse it. Returns null if it is not an xml node.
    00667     TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );
    00668
    00669     TiXmlNode*      parent;
    00670     NodeType        type;
    00671
    00672     TiXmlNode*      firstChild;
    00673     TiXmlNode*      lastChild;
    00674
    00675     TIXML_STRING    value;
    00676
    00677     TiXmlNode*      prev;
    00678     TiXmlNode*      next;
    00679
    00680 private:
    00681     TiXmlNode( const TiXmlNode& );              // not implemented.
    00682     void operator=( const TiXmlNode& base );    // not allowed.
    00683 };
    00684
    00685
    00693 class TiXmlAttribute : public TiXmlBase
    00694 {
    00695     friend class TiXmlAttributeSet;
    00696
    00697 public:
    00699     TiXmlAttribute() : TiXmlBase()
    00700     {
    00701         document = 0;
    00702         prev = next = 0;
    00703     }
    00704
    00705     #ifdef TIXML_USE_STL
    00706
    00707     TiXmlAttribute( const std::string& _name, const std::string& _value )
    00708     {
    00709         name = _name;
    00710         value = _value;
    00711         document = 0;
    00712         prev = next = 0;
    00713     }
    00714     #endif
    00715
    00717     TiXmlAttribute( const char * _name, const char * _value )
    00718     {
    00719         name = _name;
    00720         value = _value;
    00721         document = 0;
    00722         prev = next = 0;
    00723     }
    00724
    00725     const char*     Name()  const       { return name.c_str (); }
    00726     const char*     Value() const       { return value.c_str (); }
    00727     int             IntValue() const;
    00728     double          DoubleValue() const;
    00729
    00730     // Get the tinyxml string representation
    00731     const TIXML_STRING& NameTStr() const { return name; }
    00732
    00742     int QueryIntValue( int* _value ) const;
    00744     int QueryDoubleValue( double* _value ) const;
    00745
    00746     void SetName( const char* _name )   { name = _name; }
    00747     void SetValue( const char* _value ) { value = _value; }
    00748
    00749     void SetIntValue( int _value );
    00750     void SetDoubleValue( double _value );
    00751
    00752     #ifdef TIXML_USE_STL
    00753
    00754     void SetName( const std::string& _name )    { name = _name; }
    00756     void SetValue( const std::string& _value )  { value = _value; }
    00757     #endif
    00758
    00760     const TiXmlAttribute* Next() const;
    00761     TiXmlAttribute* Next();
    00763     const TiXmlAttribute* Previous() const;
    00764     TiXmlAttribute* Previous();
    00765
    00766     bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
    00767     bool operator<( const TiXmlAttribute& rhs )  const { return name < rhs.name; }
    00768     bool operator>( const TiXmlAttribute& rhs )  const { return name > rhs.name; }
    00769
    00770     /*  Attribute parsing starts: first letter of the name
    00771                          returns: the next char after the value end quote
    00772     */
    00773     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    00774
    00775     // Prints this Attribute to a FILE stream.
    00776     virtual void Print( FILE* cfile, int depth ) const;
    00777
    00778     virtual void StreamOut( TIXML_OSTREAM * out ) const;
    00779     // [internal use]
    00780     // Set the document pointer so the attribute can report errors.
    00781     void SetDocument( TiXmlDocument* doc )  { document = doc; }
    00782
    00783 private:
    00784     TiXmlAttribute( const TiXmlAttribute& );                // not implemented.
    00785     void operator=( const TiXmlAttribute& base );   // not allowed.
    00786
    00787     TiXmlDocument*  document;   // A pointer back to a document, for error reporting.
    00788     TIXML_STRING name;
    00789     TIXML_STRING value;
    00790     TiXmlAttribute* prev;
    00791     TiXmlAttribute* next;
    00792 };
    00793
    00794
    00795 /*  A class used to manage a group of attributes.
    00796     It is only used internally, both by the ELEMENT and the DECLARATION.
    00797
    00798     The set can be changed transparent to the Element and Declaration
    00799     classes that use it, but NOT transparent to the Attribute
    00800     which has to implement a next() and previous() method. Which makes
    00801     it a bit problematic and prevents the use of STL.
    00802
    00803     This version is implemented with circular lists because:
    00804         - I like circular lists
    00805         - it demonstrates some independence from the (typical) doubly linked list.
    00806 */
    00807 class TiXmlAttributeSet
    00808 {
    00809 public:
    00810     TiXmlAttributeSet();
    00811     ~TiXmlAttributeSet();
    00812
    00813     void Add( TiXmlAttribute* attribute );
    00814     void Remove( TiXmlAttribute* attribute );
    00815
    00816     const TiXmlAttribute* First()   const   { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
    00817     TiXmlAttribute* First()                 { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
    00818     const TiXmlAttribute* Last() const      { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
    00819     TiXmlAttribute* Last()                  { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
    00820
    00821     const TiXmlAttribute*   Find( const TIXML_STRING& name ) const;
    00822     TiXmlAttribute* Find( const TIXML_STRING& name );
    00823
    00824 private:
    00825     //*ME:  Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
    00826     //*ME:  this class must be also use a hidden/disabled copy-constructor !!!
    00827     TiXmlAttributeSet( const TiXmlAttributeSet& );  // not allowed
    00828     void operator=( const TiXmlAttributeSet& ); // not allowed (as TiXmlAttribute)
    00829
    00830     TiXmlAttribute sentinel;
    00831 };
    00832
    00833
    00838 class TiXmlElement : public TiXmlNode
    00839 {
    00840 public:
    00842     TiXmlElement (const char * in_value);
    00843
    00844     #ifdef TIXML_USE_STL
    00845
    00846     TiXmlElement( const std::string& _value );
    00847     #endif
    00848
    00849     TiXmlElement( const TiXmlElement& );
    00850
    00851     void operator=( const TiXmlElement& base );
    00852
    00853     virtual ~TiXmlElement();
    00854
    00858     const char* Attribute( const char* name ) const;
    00859
    00866     const char* Attribute( const char* name, int* i ) const;
    00867
    00874     const char* Attribute( const char* name, double* d ) const;
    00875
    00883     int QueryIntAttribute( const char* name, int* _value ) const;
    00885     int QueryDoubleAttribute( const char* name, double* _value ) const;
    00887     int QueryFloatAttribute( const char* name, float* _value ) const {
    00888         double d;
    00889         int result = QueryDoubleAttribute( name, &d );
    00890         if ( result == TIXML_SUCCESS ) {
    00891             *_value = (float)d;
    00892         }
    00893         return result;
    00894     }
    00895
    00899     void SetAttribute( const char* name, const char * _value );
    00900
    00901     #ifdef TIXML_USE_STL
    00902     const char* Attribute( const std::string& name ) const              { return Attribute( name.c_str() ); }
    00903     const char* Attribute( const std::string& name, int* i ) const      { return Attribute( name.c_str(), i ); }
    00904     const char* Attribute( const std::string& name, double* d ) const   { return Attribute( name.c_str(), d ); }
    00905     int QueryIntAttribute( const std::string& name, int* _value ) const { return QueryIntAttribute( name.c_str(), _value ); }
    00906     int QueryDoubleAttribute( const std::string& name, double* _value ) const { return QueryDoubleAttribute( name.c_str(), _value ); }
    00907
    00909     void SetAttribute( const std::string& name, const std::string& _value );
    00911     void SetAttribute( const std::string& name, int _value );
    00912     #endif
    00913
    00917     void SetAttribute( const char * name, int value );
    00918
    00922     void SetDoubleAttribute( const char * name, double value );
    00923
    00926     void RemoveAttribute( const char * name );
    00927     #ifdef TIXML_USE_STL
    00928     void RemoveAttribute( const std::string& name ) {   RemoveAttribute (name.c_str ());    }
    00929     #endif
    00930
    00931     const TiXmlAttribute* FirstAttribute() const    { return attributeSet.First(); }
    00932     TiXmlAttribute* FirstAttribute()                { return attributeSet.First(); }
    00933     const TiXmlAttribute* LastAttribute()   const   { return attributeSet.Last(); }
    00934     TiXmlAttribute* LastAttribute()                 { return attributeSet.Last(); }
    00935
    00968     const char* GetText() const;
    00969
    00971     virtual TiXmlNode* Clone() const;
    00972     // Print the Element to a FILE stream.
    00973     virtual void Print( FILE* cfile, int depth ) const;
    00974
    00975     /*  Attribtue parsing starts: next char past '<'
    00976                          returns: next char past '>'
    00977     */
    00978     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    00979
    00980     virtual const TiXmlElement*     ToElement()     const { return this; }
    00981     virtual TiXmlElement*           ToElement()           { return this; }
    00982
    00983 protected:
    00984
    00985     void CopyTo( TiXmlElement* target ) const;
    00986     void ClearThis();   // like clear, but initializes 'this' object as well
    00987
    00988     // Used to be public [internal use]
    00989     #ifdef TIXML_USE_STL
    00990         virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    00991     #endif
    00992     virtual void StreamOut( TIXML_OSTREAM * out ) const;
    00993
    00994     /*  [internal use]
    00995         Reads the "value" of the element -- another element, or text.
    00996         This should terminate with the current end tag.
    00997     */
    00998     const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
    00999
    01000 private:
    01001
    01002     TiXmlAttributeSet attributeSet;
    01003 };
    01004
    01005
    01008 class TiXmlComment : public TiXmlNode
    01009 {
    01010 public:
    01012     TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
    01013     TiXmlComment( const TiXmlComment& );
    01014     void operator=( const TiXmlComment& base );
    01015
    01016     virtual ~TiXmlComment() {}
    01017
    01019     virtual TiXmlNode* Clone() const;
    01021     virtual void Print( FILE* cfile, int depth ) const;
    01022
    01023     /*  Attribtue parsing starts: at the ! of the !--
    01024                          returns: next char past '>'
    01025     */
    01026     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    01027
    01028     virtual const TiXmlComment*  ToComment() const { return this; }
    01029     virtual TiXmlComment*  ToComment() { return this; }
    01030
    01031 protected:
    01032     void CopyTo( TiXmlComment* target ) const;
    01033
    01034     // used to be public
    01035     #ifdef TIXML_USE_STL
    01036         virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01037     #endif
    01038     virtual void StreamOut( TIXML_OSTREAM * out ) const;
    01039
    01040 private:
    01041
    01042 };
    01043
    01044
    01050 class TiXmlText : public TiXmlNode
    01051 {
    01052     friend class TiXmlElement;
    01053 public:
    01058     TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT)
    01059     {
    01060         SetValue( initValue );
    01061         cdata = false;
    01062     }
    01063     virtual ~TiXmlText() {}
    01064
    01065     #ifdef TIXML_USE_STL
    01066
    01067     TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
    01068     {
    01069         SetValue( initValue );
    01070         cdata = false;
    01071     }
    01072     #endif
    01073
    01074     TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT )   { copy.CopyTo( this ); }
    01075     void operator=( const TiXmlText& base )                             { base.CopyTo( this ); }
    01076
    01078     virtual void Print( FILE* cfile, int depth ) const;
    01079
    01081     bool CDATA()                    { return cdata; }
    01083     void SetCDATA( bool _cdata )    { cdata = _cdata; }
    01084
    01085     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    01086
    01087     virtual const TiXmlText* ToText() const { return this; }
    01088     virtual TiXmlText*       ToText()       { return this; }
    01089
    01090 protected :
    01092     virtual TiXmlNode* Clone() const;
    01093     void CopyTo( TiXmlText* target ) const;
    01094
    01095     virtual void StreamOut ( TIXML_OSTREAM * out ) const;
    01096     bool Blank() const; // returns true if all white space and new lines
    01097     // [internal use]
    01098     #ifdef TIXML_USE_STL
    01099         virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01100     #endif
    01101
    01102 private:
    01103     bool cdata;         // true if this should be input and output as a CDATA style text element
    01104 };
    01105
    01106
    01120 class TiXmlDeclaration : public TiXmlNode
    01121 {
    01122 public:
    01124     TiXmlDeclaration()   : TiXmlNode( TiXmlNode::DECLARATION ) {}
    01125
    01126 #ifdef TIXML_USE_STL
    01127
    01128     TiXmlDeclaration(   const std::string& _version,
    01129                         const std::string& _encoding,
    01130                         const std::string& _standalone );
    01131 #endif
    01132
    01134     TiXmlDeclaration(   const char* _version,
    01135                         const char* _encoding,
    01136                         const char* _standalone );
    01137
    01138     TiXmlDeclaration( const TiXmlDeclaration& copy );
    01139     void operator=( const TiXmlDeclaration& copy );
    01140
    01141     virtual ~TiXmlDeclaration() {}
    01142
    01144     const char *Version() const         { return version.c_str (); }
    01146     const char *Encoding() const        { return encoding.c_str (); }
    01148     const char *Standalone() const      { return standalone.c_str (); }
    01149
    01151     virtual TiXmlNode* Clone() const;
    01153     virtual void Print( FILE* cfile, int depth ) const;
    01154
    01155     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    01156
    01157     virtual const TiXmlDeclaration* ToDeclaration() const { return this; }
    01158     virtual TiXmlDeclaration*       ToDeclaration()       { return this; }
    01159
    01160 protected:
    01161     void CopyTo( TiXmlDeclaration* target ) const;
    01162     // used to be public
    01163     #ifdef TIXML_USE_STL
    01164         virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01165     #endif
    01166     virtual void StreamOut ( TIXML_OSTREAM * out) const;
    01167
    01168 private:
    01169
    01170     TIXML_STRING version;
    01171     TIXML_STRING encoding;
    01172     TIXML_STRING standalone;
    01173 };
    01174
    01175
    01183 class TiXmlUnknown : public TiXmlNode
    01184 {
    01185 public:
    01186     TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN )    {}
    01187     virtual ~TiXmlUnknown() {}
    01188
    01189     TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN )      { copy.CopyTo( this ); }
    01190     void operator=( const TiXmlUnknown& copy )                                      { copy.CopyTo( this ); }
    01191
    01193     virtual TiXmlNode* Clone() const;
    01195     virtual void Print( FILE* cfile, int depth ) const;
    01196
    01197     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    01198
    01199     virtual const TiXmlUnknown*     ToUnknown()     const { return this; }
    01200     virtual TiXmlUnknown*           ToUnknown()     { return this; }
    01201
    01202 protected:
    01203     void CopyTo( TiXmlUnknown* target ) const;
    01204
    01205     #ifdef TIXML_USE_STL
    01206         virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01207     #endif
    01208     virtual void StreamOut ( TIXML_OSTREAM * out ) const;
    01209
    01210 private:
    01211
    01212 };
    01213
    01214
    01219 class TiXmlDocument : public TiXmlNode
    01220 {
    01221 public:
    01223     TiXmlDocument();
    01225     TiXmlDocument( const char * documentName );
    01226
    01227     #ifdef TIXML_USE_STL
    01228
    01229     TiXmlDocument( const std::string& documentName );
    01230     #endif
    01231
    01232     TiXmlDocument( const TiXmlDocument& copy );
    01233     void operator=( const TiXmlDocument& copy );
    01234
    01235     virtual ~TiXmlDocument() {}
    01236
    01241     bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
    01243     bool SaveFile() const;
    01245     bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
    01247     bool SaveFile( const char * filename ) const;
    01253     bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
    01255     bool SaveFile( FILE* ) const;
    01256
    01257     #ifdef TIXML_USE_STL
    01258     bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )
    01259     {
    01260         StringToBuffer f( filename );
    01261         return ( f.buffer && LoadFile( f.buffer, encoding ));
    01262     }
    01263     bool SaveFile( const std::string& filename ) const
    01264     {
    01265         StringToBuffer f( filename );
    01266         return ( f.buffer && SaveFile( f.buffer ));
    01267     }
    01268     #endif
    01269
    01274     virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
    01275
    01280     const TiXmlElement* RootElement() const     { return FirstChildElement(); }
    01281     TiXmlElement* RootElement()                 { return FirstChildElement(); }
    01282
    01288     bool Error() const                      { return error; }
    01289
    01291     const char * ErrorDesc() const  { return errorDesc.c_str (); }
    01292
    01296     int ErrorId()   const               { return errorId; }
    01297
    01305     int ErrorRow()  { return errorLocation.row+1; }
    01306     int ErrorCol()  { return errorLocation.col+1; }
    01307
    01332     void SetTabSize( int _tabsize )     { tabsize = _tabsize; }
    01333
    01334     int TabSize() const { return tabsize; }
    01335
    01339     void ClearError()                       {   error = false;
    01340                                                 errorId = 0;
    01341                                                 errorDesc = "";
    01342                                                 errorLocation.row = errorLocation.col = 0;
    01343                                                 //errorLocation.last = 0;
    01344                                             }
    01345
    01347     void Print() const                      { Print( stdout, 0 ); }
    01348
    01350     virtual void Print( FILE* cfile, int depth = 0 ) const;
    01351     // [internal use]
    01352     void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
    01353
    01354     virtual const TiXmlDocument*    ToDocument()    const { return this; }
    01355     virtual TiXmlDocument*          ToDocument()          { return this; }
    01356
    01357 protected :
    01358     virtual void StreamOut ( TIXML_OSTREAM * out) const;
    01359     // [internal use]
    01360     virtual TiXmlNode* Clone() const;
    01361     #ifdef TIXML_USE_STL
    01362         virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01363     #endif
    01364
    01365 private:
    01366     void CopyTo( TiXmlDocument* target ) const;
    01367
    01368     bool error;
    01369     int  errorId;
    01370     TIXML_STRING errorDesc;
    01371     int tabsize;
    01372     TiXmlCursor errorLocation;
    01373     bool useMicrosoftBOM;       // the UTF-8 BOM were found when read. Note this, and try to write.
    01374 };
    01375
    01376
    01457 class TiXmlHandle
    01458 {
    01459 public:
    01461     TiXmlHandle( TiXmlNode* _node )                 { this->node = _node; }
    01463     TiXmlHandle( const TiXmlHandle& ref )           { this->node = ref.node; }
    01464     TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
    01465
    01467     TiXmlHandle FirstChild() const;
    01469     TiXmlHandle FirstChild( const char * value ) const;
    01471     TiXmlHandle FirstChildElement() const;
    01473     TiXmlHandle FirstChildElement( const char * value ) const;
    01474
    01478     TiXmlHandle Child( const char* value, int index ) const;
    01482     TiXmlHandle Child( int index ) const;
    01487     TiXmlHandle ChildElement( const char* value, int index ) const;
    01492     TiXmlHandle ChildElement( int index ) const;
    01493
    01494     #ifdef TIXML_USE_STL
    01495     TiXmlHandle FirstChild( const std::string& _value ) const               { return FirstChild( _value.c_str() ); }
    01496     TiXmlHandle FirstChildElement( const std::string& _value ) const        { return FirstChildElement( _value.c_str() ); }
    01497
    01498     TiXmlHandle Child( const std::string& _value, int index ) const         { return Child( _value.c_str(), index ); }
    01499     TiXmlHandle ChildElement( const std::string& _value, int index ) const  { return ChildElement( _value.c_str(), index ); }
    01500     #endif
    01501
    01503     TiXmlNode* Node() const         { return node; }
    01505     TiXmlElement* Element() const   { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
    01507     TiXmlText* Text() const         { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
    01509     TiXmlUnknown* Unknown() const           { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
    01510
    01511 private:
    01512     TiXmlNode* node;
    01513 };
    01514
    01515 #ifdef _MSC_VER
    01516 #pragma warning( pop )
    01517 #endif
    01518
    01519 #endif
    01520