00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
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 
00042 #if defined( _DEBUG ) && !defined( DEBUG )
00043 #define DEBUG
00044 #endif
00045 
00046 #ifdef TIXML_USE_STL
00047     #include <string>
00048     #include <iostream>
00049     #include <sstream>
00050     #define TIXML_STRING        std::string
00051 #else
00052     #include "tinystr.h"
00053     #define TIXML_STRING        TiXmlString
00054 #endif
00055 
00056 
00057 
00058 
00059 
00060 #define TIXML_SAFE
00061 
00062 #ifdef TIXML_SAFE
00063     #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
00064         
00065         #define TIXML_SNPRINTF _snprintf_s
00066         #define TIXML_SNSCANF  _snscanf_s
00067         #define TIXML_SSCANF   sscanf_s
00068     #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
00069         
00070         
00071         #define TIXML_SNPRINTF _snprintf
00072         #define TIXML_SNSCANF  _snscanf
00073         #define TIXML_SSCANF   sscanf
00074     #elif defined(__GNUC__) && (__GNUC__ >= 3 )
00075         
00076         
00077         #define TIXML_SNPRINTF snprintf
00078         #define TIXML_SNSCANF  snscanf
00079         #define TIXML_SSCANF   sscanf
00080     #else
00081         #define TIXML_SSCANF   sscanf
00082     #endif
00083 #endif  
00084 
00085 class TiXmlDocument;
00086 class TiXmlElement;
00087 class TiXmlComment;
00088 class TiXmlUnknown;
00089 class TiXmlAttribute;
00090 class TiXmlText;
00091 class TiXmlDeclaration;
00092 class TiXmlParsingData;
00093 
00094 const int TIXML_MAJOR_VERSION = 2;
00095 const int TIXML_MINOR_VERSION = 5;
00096 const int TIXML_PATCH_VERSION = 3;
00097 
00098 
00099 
00100 
00101 struct TiXmlCursor
00102 {
00103     TiXmlCursor()       { Clear(); }
00104     void Clear()        { row = col = -1; }
00105 
00106     int row;    
00107     int col;    
00108 };
00109 
00110 
00129 class TiXmlVisitor
00130 {
00131 public:
00132     virtual ~TiXmlVisitor() {}
00133 
00135     virtual bool VisitEnter( const TiXmlDocument&  )         { return true; }
00137     virtual bool VisitExit( const TiXmlDocument&  )          { return true; }
00138 
00140     virtual bool VisitEnter( const TiXmlElement& , const TiXmlAttribute*  )    { return true; }
00142     virtual bool VisitExit( const TiXmlElement&  )       { return true; }
00143 
00145     virtual bool Visit( const TiXmlDeclaration&  )   { return true; }
00147     virtual bool Visit( const TiXmlText&  )                 { return true; }
00149     virtual bool Visit( const TiXmlComment&  )           { return true; }
00151     virtual bool Visit( const TiXmlUnknown&  )           { return true; }
00152 };
00153 
00154 
00155 enum 
00156 { 
00157     TIXML_SUCCESS,
00158     TIXML_NO_ATTRIBUTE,
00159     TIXML_WRONG_TYPE
00160 };
00161 
00162 
00163 
00164 enum TiXmlEncoding
00165 {
00166     TIXML_ENCODING_UNKNOWN,
00167     TIXML_ENCODING_UTF8,
00168     TIXML_ENCODING_LEGACY
00169 };
00170 
00171 const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
00172 
00195 class TiXmlBase
00196 {
00197     friend class TiXmlNode;
00198     friend class TiXmlElement;
00199     friend class TiXmlDocument;
00200 
00201 public:
00202     TiXmlBase() :   userData(0)     {}
00203     virtual ~TiXmlBase()            {}
00204 
00214     virtual void Print( FILE* cfile, int depth ) const = 0;
00215 
00222     static void SetCondenseWhiteSpace( bool condense )      { condenseWhiteSpace = condense; }
00223 
00225     static bool IsWhiteSpaceCondensed()                     { return condenseWhiteSpace; }
00226 
00245     int Row() const         { return location.row + 1; }
00246     int Column() const      { return location.col + 1; }    
00247 
00248     void  SetUserData( void* user )         { userData = user; }    
00249     void* GetUserData()                     { return userData; }    
00250     const void* GetUserData() const         { return userData; }    
00251 
00252     
00253     
00254     static const int utf8ByteTable[256];
00255 
00256     virtual const char* Parse(  const char* p, 
00257                                 TiXmlParsingData* data, 
00258                                 TiXmlEncoding encoding  ) = 0;
00259 
00263     static void EncodeString( const TIXML_STRING& str, TIXML_STRING* out );
00264 
00265     enum
00266     {
00267         TIXML_NO_ERROR = 0,
00268         TIXML_ERROR,
00269         TIXML_ERROR_OPENING_FILE,
00270         TIXML_ERROR_OUT_OF_MEMORY,
00271         TIXML_ERROR_PARSING_ELEMENT,
00272         TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
00273         TIXML_ERROR_READING_ELEMENT_VALUE,
00274         TIXML_ERROR_READING_ATTRIBUTES,
00275         TIXML_ERROR_PARSING_EMPTY,
00276         TIXML_ERROR_READING_END_TAG,
00277         TIXML_ERROR_PARSING_UNKNOWN,
00278         TIXML_ERROR_PARSING_COMMENT,
00279         TIXML_ERROR_PARSING_DECLARATION,
00280         TIXML_ERROR_DOCUMENT_EMPTY,
00281         TIXML_ERROR_EMBEDDED_NULL,
00282         TIXML_ERROR_PARSING_CDATA,
00283         TIXML_ERROR_DOCUMENT_TOP_ONLY,
00284 
00285         TIXML_ERROR_STRING_COUNT
00286     };
00287 
00288 protected:
00289 
00290     static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding );
00291     inline static bool IsWhiteSpace( char c )       
00292     { 
00293         return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); 
00294     }
00295     inline static bool IsWhiteSpace( int c )
00296     {
00297         if ( c < 256 )
00298             return IsWhiteSpace( (char) c );
00299         return false;   
00300     }
00301 
00302     #ifdef TIXML_USE_STL
00303     static bool StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );
00304     static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag );
00305     #endif
00306 
00307     
00308 
00309 
00310 
00311     static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );
00312 
00313     
00314 
00315 
00316     static const char* ReadText(    const char* in,             
00317                                     TIXML_STRING* text,         
00318                                     bool ignoreWhiteSpace,      
00319                                     const char* endTag,         
00320                                     bool ignoreCase,            
00321                                     TiXmlEncoding encoding );   
00322 
00323     
00324     static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding );
00325 
00326     
00327     
00328     inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
00329     {
00330         assert( p );
00331         if ( encoding == TIXML_ENCODING_UTF8 )
00332         {
00333             *length = utf8ByteTable[ *((const unsigned char*)p) ];
00334             assert( *length >= 0 && *length < 5 );
00335         }
00336         else
00337         {
00338             *length = 1;
00339         }
00340 
00341         if ( *length == 1 )
00342         {
00343             if ( *p == '&' )
00344                 return GetEntity( p, _value, length, encoding );
00345             *_value = *p;
00346             return p+1;
00347         }
00348         else if ( *length )
00349         {
00350             
00351                                                 
00352             for( int i=0; p[i] && i<*length; ++i ) {
00353                 _value[i] = p[i];
00354             }
00355             return p + (*length);
00356         }
00357         else
00358         {
00359             
00360             return 0;
00361         }
00362     }
00363 
00364     
00365     
00366     
00367     static bool StringEqual(    const char* p,
00368                                 const char* endTag,
00369                                 bool ignoreCase,
00370                                 TiXmlEncoding encoding );
00371 
00372     static const char* errorString[ TIXML_ERROR_STRING_COUNT ];
00373 
00374     TiXmlCursor location;
00375 
00377     void*           userData;
00378     
00379     
00380     
00381     static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
00382     static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
00383     inline static int ToLower( int v, TiXmlEncoding encoding )
00384     {
00385         if ( encoding == TIXML_ENCODING_UTF8 )
00386         {
00387             if ( v < 128 ) return tolower( v );
00388             return v;
00389         }
00390         else
00391         {
00392             return tolower( v );
00393         }
00394     }
00395     static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
00396 
00397 private:
00398     TiXmlBase( const TiXmlBase& );              
00399     void operator=( const TiXmlBase& base );    
00400 
00401     struct Entity
00402     {
00403         const char*     str;
00404         unsigned int    strLength;
00405         char            chr;
00406     };
00407     enum
00408     {
00409         NUM_ENTITY = 5,
00410         MAX_ENTITY_LENGTH = 6
00411 
00412     };
00413     static Entity entity[ NUM_ENTITY ];
00414     static bool condenseWhiteSpace;
00415 };
00416 
00417 
00424 class TiXmlNode : public TiXmlBase
00425 {
00426     friend class TiXmlDocument;
00427     friend class TiXmlElement;
00428 
00429 public:
00430     #ifdef TIXML_USE_STL    
00431 
00435         friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
00436 
00453         friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
00454 
00456         friend std::string& operator<< (std::string& out, const TiXmlNode& base );
00457 
00458     #endif
00459 
00463     enum NodeType
00464     {
00465         DOCUMENT,
00466         ELEMENT,
00467         COMMENT,
00468         UNKNOWN,
00469         TEXT,
00470         DECLARATION,
00471         TYPECOUNT
00472     };
00473 
00474     virtual ~TiXmlNode();
00475 
00488     const char *Value() const { return value.c_str (); }
00489 
00490     #ifdef TIXML_USE_STL
00491 
00495     const std::string& ValueStr() const { return value; }
00496     #endif
00497 
00498     const TIXML_STRING& ValueTStr() const { return value; }
00499 
00509     void SetValue(const char * _value) { value = _value;}
00510 
00511     #ifdef TIXML_USE_STL
00513     void SetValue( const std::string& _value )  { value = _value; }
00514     #endif
00515 
00517     void Clear();
00518 
00520     TiXmlNode* Parent()                         { return parent; }
00521     const TiXmlNode* Parent() const             { return parent; }
00522 
00523     const TiXmlNode* FirstChild()   const       { return firstChild; }  
00524     TiXmlNode* FirstChild()                     { return firstChild; }
00525     const TiXmlNode* FirstChild( const char * value ) const;            
00526 
00527     TiXmlNode* FirstChild( const char * _value ) {
00528         
00529         
00530         return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild( _value ));
00531     }
00532     const TiXmlNode* LastChild() const  { return lastChild; }       
00533     TiXmlNode* LastChild()  { return lastChild; }
00534     
00535     const TiXmlNode* LastChild( const char * value ) const;         
00536     TiXmlNode* LastChild( const char * _value ) {
00537         return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild( _value ));
00538     }
00539 
00540     #ifdef TIXML_USE_STL
00541     const TiXmlNode* FirstChild( const std::string& _value ) const  {   return FirstChild (_value.c_str ());    }   
00542     TiXmlNode* FirstChild( const std::string& _value )              {   return FirstChild (_value.c_str ());    }   
00543     const TiXmlNode* LastChild( const std::string& _value ) const   {   return LastChild (_value.c_str ()); }   
00544     TiXmlNode* LastChild( const std::string& _value )               {   return LastChild (_value.c_str ()); }   
00545     #endif
00546 
00563     const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
00564     TiXmlNode* IterateChildren( const TiXmlNode* previous ) {
00565         return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( previous ) );
00566     }
00567 
00569     const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
00570     TiXmlNode* IterateChildren( const char * _value, const TiXmlNode* previous ) {
00571         return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( _value, previous ) );
00572     }
00573 
00574     #ifdef TIXML_USE_STL
00575     const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const  {   return IterateChildren (_value.c_str (), previous); }   
00576     TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) {    return IterateChildren (_value.c_str (), previous); }   
00577     #endif
00578 
00582     TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
00583 
00584 
00594     TiXmlNode* LinkEndChild( TiXmlNode* addThis );
00595 
00599     TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
00600 
00604     TiXmlNode* InsertAfterChild(  TiXmlNode* afterThis, const TiXmlNode& addThis );
00605 
00609     TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
00610 
00612     bool RemoveChild( TiXmlNode* removeThis );
00613 
00615     const TiXmlNode* PreviousSibling() const            { return prev; }
00616     TiXmlNode* PreviousSibling()                        { return prev; }
00617 
00619     const TiXmlNode* PreviousSibling( const char * ) const;
00620     TiXmlNode* PreviousSibling( const char *_prev ) {
00621         return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->PreviousSibling( _prev ) );
00622     }
00623 
00624     #ifdef TIXML_USE_STL
00625     const TiXmlNode* PreviousSibling( const std::string& _value ) const {   return PreviousSibling (_value.c_str ());   }   
00626     TiXmlNode* PreviousSibling( const std::string& _value )             {   return PreviousSibling (_value.c_str ());   }   
00627     const TiXmlNode* NextSibling( const std::string& _value) const      {   return NextSibling (_value.c_str ());   }   
00628     TiXmlNode* NextSibling( const std::string& _value)                  {   return NextSibling (_value.c_str ());   }   
00629     #endif
00630 
00632     const TiXmlNode* NextSibling() const                { return next; }
00633     TiXmlNode* NextSibling()                            { return next; }
00634 
00636     const TiXmlNode* NextSibling( const char * ) const;
00637     TiXmlNode* NextSibling( const char* _next ) {
00638         return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->NextSibling( _next ) );
00639     }
00640 
00645     const TiXmlElement* NextSiblingElement() const;
00646     TiXmlElement* NextSiblingElement() {
00647         return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() );
00648     }
00649 
00654     const TiXmlElement* NextSiblingElement( const char * ) const;
00655     TiXmlElement* NextSiblingElement( const char *_next ) {
00656         return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement( _next ) );
00657     }
00658 
00659     #ifdef TIXML_USE_STL
00660     const TiXmlElement* NextSiblingElement( const std::string& _value) const    {   return NextSiblingElement (_value.c_str ());    }   
00661     TiXmlElement* NextSiblingElement( const std::string& _value)                {   return NextSiblingElement (_value.c_str ());    }   
00662     #endif
00663 
00665     const TiXmlElement* FirstChildElement() const;
00666     TiXmlElement* FirstChildElement() {
00667         return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() );
00668     }
00669 
00671     const TiXmlElement* FirstChildElement( const char * _value ) const;
00672     TiXmlElement* FirstChildElement( const char * _value ) {
00673         return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement( _value ) );
00674     }
00675 
00676     #ifdef TIXML_USE_STL
00677     const TiXmlElement* FirstChildElement( const std::string& _value ) const    {   return FirstChildElement (_value.c_str ()); }   
00678     TiXmlElement* FirstChildElement( const std::string& _value )                {   return FirstChildElement (_value.c_str ()); }   
00679     #endif
00680 
00685     int Type() const    { return type; }
00686 
00690     const TiXmlDocument* GetDocument() const;
00691     TiXmlDocument* GetDocument() {
00692         return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() );
00693     }
00694 
00696     bool NoChildren() const                     { return !firstChild; }
00697 
00698     virtual const TiXmlDocument*    ToDocument()    const { return 0; } 
00699     virtual const TiXmlElement*     ToElement()     const { return 0; } 
00700     virtual const TiXmlComment*     ToComment()     const { return 0; } 
00701     virtual const TiXmlUnknown*     ToUnknown()     const { return 0; } 
00702     virtual const TiXmlText*        ToText()        const { return 0; } 
00703     virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } 
00704 
00705     virtual TiXmlDocument*          ToDocument()    { return 0; } 
00706     virtual TiXmlElement*           ToElement()     { return 0; } 
00707     virtual TiXmlComment*           ToComment()     { return 0; } 
00708     virtual TiXmlUnknown*           ToUnknown()     { return 0; } 
00709     virtual TiXmlText*              ToText()        { return 0; } 
00710     virtual TiXmlDeclaration*       ToDeclaration() { return 0; } 
00711 
00715     virtual TiXmlNode* Clone() const = 0;
00716 
00739     virtual bool Accept( TiXmlVisitor* visitor ) const = 0;
00740 
00741 protected:
00742     TiXmlNode( NodeType _type );
00743 
00744     
00745     
00746     void CopyTo( TiXmlNode* target ) const;
00747 
00748     #ifdef TIXML_USE_STL
00749         
00750     virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;
00751     #endif
00752 
00753     
00754     TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );
00755 
00756     TiXmlNode*      parent;
00757     NodeType        type;
00758 
00759     TiXmlNode*      firstChild;
00760     TiXmlNode*      lastChild;
00761 
00762     TIXML_STRING    value;
00763 
00764     TiXmlNode*      prev;
00765     TiXmlNode*      next;
00766 
00767 private:
00768     TiXmlNode( const TiXmlNode& );              
00769     void operator=( const TiXmlNode& base );    
00770 };
00771 
00772 
00780 class TiXmlAttribute : public TiXmlBase
00781 {
00782     friend class TiXmlAttributeSet;
00783 
00784 public:
00786     TiXmlAttribute() : TiXmlBase()
00787     {
00788         document = 0;
00789         prev = next = 0;
00790     }
00791 
00792     #ifdef TIXML_USE_STL
00794     TiXmlAttribute( const std::string& _name, const std::string& _value )
00795     {
00796         name = _name;
00797         value = _value;
00798         document = 0;
00799         prev = next = 0;
00800     }
00801     #endif
00802 
00804     TiXmlAttribute( const char * _name, const char * _value )
00805     {
00806         name = _name;
00807         value = _value;
00808         document = 0;
00809         prev = next = 0;
00810     }
00811 
00812     const char*     Name()  const       { return name.c_str(); }        
00813     const char*     Value() const       { return value.c_str(); }       
00814     #ifdef TIXML_USE_STL
00815     const std::string& ValueStr() const { return value; }               
00816     #endif
00817     int             IntValue() const;                                   
00818     double          DoubleValue() const;                                
00819 
00820     
00821     const TIXML_STRING& NameTStr() const { return name; }
00822 
00832     int QueryIntValue( int* _value ) const;
00834     int QueryDoubleValue( double* _value ) const;
00835 
00836     void SetName( const char* _name )   { name = _name; }               
00837     void SetValue( const char* _value ) { value = _value; }             
00838 
00839     void SetIntValue( int _value );                                     
00840     void SetDoubleValue( double _value );                               
00841 
00842     #ifdef TIXML_USE_STL
00844     void SetName( const std::string& _name )    { name = _name; }   
00846     void SetValue( const std::string& _value )  { value = _value; }
00847     #endif
00848 
00850     const TiXmlAttribute* Next() const;
00851     TiXmlAttribute* Next() {
00852         return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() ); 
00853     }
00854 
00856     const TiXmlAttribute* Previous() const;
00857     TiXmlAttribute* Previous() {
00858         return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Previous() ); 
00859     }
00860 
00861     bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
00862     bool operator<( const TiXmlAttribute& rhs )  const { return name < rhs.name; }
00863     bool operator>( const TiXmlAttribute& rhs )  const { return name > rhs.name; }
00864 
00865     
00866 
00867 
00868     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
00869 
00870     
00871     virtual void Print( FILE* cfile, int depth ) const {
00872         Print( cfile, depth, 0 );
00873     }
00874     void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
00875 
00876     
00877     
00878     void SetDocument( TiXmlDocument* doc )  { document = doc; }
00879 
00880 private:
00881     TiXmlAttribute( const TiXmlAttribute& );                
00882     void operator=( const TiXmlAttribute& base );   
00883 
00884     TiXmlDocument*  document;   
00885     TIXML_STRING name;
00886     TIXML_STRING value;
00887     TiXmlAttribute* prev;
00888     TiXmlAttribute* next;
00889 };
00890 
00891 
00892 
00893 
00894 
00895 
00896 
00897 
00898 
00899 
00900 
00901 
00902 
00903 
00904 class TiXmlAttributeSet
00905 {
00906 public:
00907     TiXmlAttributeSet();
00908     ~TiXmlAttributeSet();
00909 
00910     void Add( TiXmlAttribute* attribute );
00911     void Remove( TiXmlAttribute* attribute );
00912 
00913     const TiXmlAttribute* First()   const   { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
00914     TiXmlAttribute* First()                 { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
00915     const TiXmlAttribute* Last() const      { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
00916     TiXmlAttribute* Last()                  { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
00917 
00918     const TiXmlAttribute*   Find( const char* _name ) const;
00919     TiXmlAttribute* Find( const char* _name ) {
00920         return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );
00921     }
00922     #ifdef TIXML_USE_STL
00923     const TiXmlAttribute*   Find( const std::string& _name ) const;
00924     TiXmlAttribute* Find( const std::string& _name ) {
00925         return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );
00926     }
00927 
00928     #endif
00929 
00930 private:
00931     
00932     
00933     TiXmlAttributeSet( const TiXmlAttributeSet& );  
00934     void operator=( const TiXmlAttributeSet& ); 
00935 
00936     TiXmlAttribute sentinel;
00937 };
00938 
00939 
00944 class TiXmlElement : public TiXmlNode
00945 {
00946 public:
00948     TiXmlElement (const char * in_value);
00949 
00950     #ifdef TIXML_USE_STL
00952     TiXmlElement( const std::string& _value );
00953     #endif
00954 
00955     TiXmlElement( const TiXmlElement& );
00956 
00957     void operator=( const TiXmlElement& base );
00958 
00959     virtual ~TiXmlElement();
00960 
00964     const char* Attribute( const char* name ) const;
00965 
00972     const char* Attribute( const char* name, int* i ) const;
00973 
00980     const char* Attribute( const char* name, double* d ) const;
00981 
00989     int QueryIntAttribute( const char* name, int* _value ) const;
00991     int QueryDoubleAttribute( const char* name, double* _value ) const;
00993     int QueryFloatAttribute( const char* name, float* _value ) const {
00994         double d;
00995         int result = QueryDoubleAttribute( name, &d );
00996         if ( result == TIXML_SUCCESS ) {
00997             *_value = (float)d;
00998         }
00999         return result;
01000     }
01001 
01002     #ifdef TIXML_USE_STL
01003 
01011     template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const
01012     {
01013         const TiXmlAttribute* node = attributeSet.Find( name );
01014         if ( !node )
01015             return TIXML_NO_ATTRIBUTE;
01016 
01017         std::stringstream sstream( node->ValueStr() );
01018         sstream >> *outValue;
01019         if ( !sstream.fail() )
01020             return TIXML_SUCCESS;
01021         return TIXML_WRONG_TYPE;
01022     }
01023     
01024 
01025 
01026 
01027 
01028 
01029 
01030 
01031 
01032 
01033 
01034 
01035 
01036 
01037 
01038     #endif
01039 
01043     void SetAttribute( const char* name, const char * _value );
01044 
01045     #ifdef TIXML_USE_STL
01046     const std::string* Attribute( const std::string& name ) const;
01047     const std::string* Attribute( const std::string& name, int* i ) const;
01048     const std::string* Attribute( const std::string& name, double* d ) const;
01049     int QueryIntAttribute( const std::string& name, int* _value ) const;
01050     int QueryDoubleAttribute( const std::string& name, double* _value ) const;
01051 
01053     void SetAttribute( const std::string& name, const std::string& _value );
01055     void SetAttribute( const std::string& name, int _value );
01056     #endif
01057 
01061     void SetAttribute( const char * name, int value );
01062 
01066     void SetDoubleAttribute( const char * name, double value );
01067 
01070     void RemoveAttribute( const char * name );
01071     #ifdef TIXML_USE_STL
01072     void RemoveAttribute( const std::string& name ) {   RemoveAttribute (name.c_str ());    }   
01073     #endif
01074 
01075     const TiXmlAttribute* FirstAttribute() const    { return attributeSet.First(); }        
01076     TiXmlAttribute* FirstAttribute()                { return attributeSet.First(); }
01077     const TiXmlAttribute* LastAttribute()   const   { return attributeSet.Last(); }     
01078     TiXmlAttribute* LastAttribute()                 { return attributeSet.Last(); }
01079 
01112     const char* GetText() const;
01113 
01115     virtual TiXmlNode* Clone() const;
01116     
01117     virtual void Print( FILE* cfile, int depth ) const;
01118 
01119     
01120 
01121 
01122     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01123 
01124     virtual const TiXmlElement*     ToElement()     const { return this; } 
01125     virtual TiXmlElement*           ToElement()           { return this; } 
01126 
01129     virtual bool Accept( TiXmlVisitor* visitor ) const;
01130 
01131 protected:
01132 
01133     void CopyTo( TiXmlElement* target ) const;
01134     void ClearThis();   
01135 
01136     
01137     #ifdef TIXML_USE_STL
01138     virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01139     #endif
01140     
01141 
01142 
01143 
01144     const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
01145 
01146 private:
01147 
01148     TiXmlAttributeSet attributeSet;
01149 };
01150 
01151 
01154 class TiXmlComment : public TiXmlNode
01155 {
01156 public:
01158     TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
01160     TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::COMMENT ) {
01161         SetValue( _value );
01162     }
01163     TiXmlComment( const TiXmlComment& );
01164     void operator=( const TiXmlComment& base );
01165 
01166     virtual ~TiXmlComment() {}
01167 
01169     virtual TiXmlNode* Clone() const;
01170     
01171     virtual void Print( FILE* cfile, int depth ) const;
01172 
01173     
01174 
01175 
01176     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01177 
01178     virtual const TiXmlComment*  ToComment() const { return this; } 
01179     virtual TiXmlComment*  ToComment() { return this; } 
01180 
01183     virtual bool Accept( TiXmlVisitor* visitor ) const;
01184 
01185 protected:
01186     void CopyTo( TiXmlComment* target ) const;
01187 
01188     
01189     #ifdef TIXML_USE_STL
01190     virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01191     #endif
01192 
01193 
01194 private:
01195 
01196 };
01197 
01198 
01204 class TiXmlText : public TiXmlNode
01205 {
01206     friend class TiXmlElement;
01207 public:
01212     TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT)
01213     {
01214         SetValue( initValue );
01215         cdata = false;
01216     }
01217     virtual ~TiXmlText() {}
01218 
01219     #ifdef TIXML_USE_STL
01221     TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
01222     {
01223         SetValue( initValue );
01224         cdata = false;
01225     }
01226     #endif
01227 
01228     TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT )   { copy.CopyTo( this ); }
01229     void operator=( const TiXmlText& base )                             { base.CopyTo( this ); }
01230 
01231     
01232     virtual void Print( FILE* cfile, int depth ) const;
01233 
01235     bool CDATA() const              { return cdata; }
01237     void SetCDATA( bool _cdata )    { cdata = _cdata; }
01238 
01239     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01240 
01241     virtual const TiXmlText* ToText() const { return this; } 
01242     virtual TiXmlText*       ToText()       { return this; } 
01243 
01246     virtual bool Accept( TiXmlVisitor* content ) const;
01247 
01248 protected :
01250     virtual TiXmlNode* Clone() const;
01251     void CopyTo( TiXmlText* target ) const;
01252 
01253     bool Blank() const; 
01254     
01255     #ifdef TIXML_USE_STL
01256     virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01257     #endif
01258 
01259 private:
01260     bool cdata;         
01261 };
01262 
01263 
01277 class TiXmlDeclaration : public TiXmlNode
01278 {
01279 public:
01281     TiXmlDeclaration()   : TiXmlNode( TiXmlNode::DECLARATION ) {}
01282 
01283 #ifdef TIXML_USE_STL
01285     TiXmlDeclaration(   const std::string& _version,
01286                         const std::string& _encoding,
01287                         const std::string& _standalone );
01288 #endif
01289 
01291     TiXmlDeclaration(   const char* _version,
01292                         const char* _encoding,
01293                         const char* _standalone );
01294 
01295     TiXmlDeclaration( const TiXmlDeclaration& copy );
01296     void operator=( const TiXmlDeclaration& copy );
01297 
01298     virtual ~TiXmlDeclaration() {}
01299 
01301     const char *Version() const         { return version.c_str (); }
01303     const char *Encoding() const        { return encoding.c_str (); }
01305     const char *Standalone() const      { return standalone.c_str (); }
01306 
01308     virtual TiXmlNode* Clone() const;
01309     
01310     virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
01311     virtual void Print( FILE* cfile, int depth ) const {
01312         Print( cfile, depth, 0 );
01313     }
01314 
01315     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01316 
01317     virtual const TiXmlDeclaration* ToDeclaration() const { return this; } 
01318     virtual TiXmlDeclaration*       ToDeclaration()       { return this; } 
01319 
01322     virtual bool Accept( TiXmlVisitor* visitor ) const;
01323 
01324 protected:
01325     void CopyTo( TiXmlDeclaration* target ) const;
01326     
01327     #ifdef TIXML_USE_STL
01328     virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01329     #endif
01330 
01331 private:
01332 
01333     TIXML_STRING version;
01334     TIXML_STRING encoding;
01335     TIXML_STRING standalone;
01336 };
01337 
01338 
01346 class TiXmlUnknown : public TiXmlNode
01347 {
01348 public:
01349     TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN )    {}
01350     virtual ~TiXmlUnknown() {}
01351 
01352     TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN )      { copy.CopyTo( this ); }
01353     void operator=( const TiXmlUnknown& copy )                                      { copy.CopyTo( this ); }
01354 
01356     virtual TiXmlNode* Clone() const;
01357     
01358     virtual void Print( FILE* cfile, int depth ) const;
01359 
01360     virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01361 
01362     virtual const TiXmlUnknown*     ToUnknown()     const { return this; } 
01363     virtual TiXmlUnknown*           ToUnknown()     { return this; } 
01364 
01367     virtual bool Accept( TiXmlVisitor* content ) const;
01368 
01369 protected:
01370     void CopyTo( TiXmlUnknown* target ) const;
01371 
01372     #ifdef TIXML_USE_STL
01373     virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01374     #endif
01375 
01376 private:
01377 
01378 };
01379 
01380 
01385 class TiXmlDocument : public TiXmlNode
01386 {
01387 public:
01389     TiXmlDocument();
01391     TiXmlDocument( const char * documentName );
01392 
01393     #ifdef TIXML_USE_STL
01395     TiXmlDocument( const std::string& documentName );
01396     #endif
01397 
01398     TiXmlDocument( const TiXmlDocument& copy );
01399     void operator=( const TiXmlDocument& copy );
01400 
01401     virtual ~TiXmlDocument() {}
01402 
01407     bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01409     bool SaveFile() const;
01411     bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01413     bool SaveFile( const char * filename ) const;
01419     bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01421     bool SaveFile( FILE* ) const;
01422 
01423     #ifdef TIXML_USE_STL
01424     bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )           
01425     {
01426 
01427 
01428         return LoadFile( filename.c_str(), encoding );
01429     }
01430     bool SaveFile( const std::string& filename ) const      
01431     {
01432 
01433 
01434         return SaveFile( filename.c_str() );
01435     }
01436     #endif
01437 
01442     virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01443 
01448     const TiXmlElement* RootElement() const     { return FirstChildElement(); }
01449     TiXmlElement* RootElement()                 { return FirstChildElement(); }
01450 
01456     bool Error() const                      { return error; }
01457 
01459     const char * ErrorDesc() const  { return errorDesc.c_str (); }
01460 
01464     int ErrorId()   const               { return errorId; }
01465 
01473     int ErrorRow() const    { return errorLocation.row+1; }
01474     int ErrorCol() const    { return errorLocation.col+1; } 
01475 
01500     void SetTabSize( int _tabsize )     { tabsize = _tabsize; }
01501 
01502     int TabSize() const { return tabsize; }
01503 
01507     void ClearError()                       {   error = false; 
01508                                                 errorId = 0; 
01509                                                 errorDesc = ""; 
01510                                                 errorLocation.row = errorLocation.col = 0; 
01511                                                 
01512                                             }
01513 
01515     void Print() const                      { Print( stdout, 0 ); }
01516 
01517     
01518 
01519 
01520 
01521     
01522 
01524     virtual void Print( FILE* cfile, int depth = 0 ) const;
01525     
01526     void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
01527 
01528     virtual const TiXmlDocument*    ToDocument()    const { return this; } 
01529     virtual TiXmlDocument*          ToDocument()          { return this; } 
01530 
01533     virtual bool Accept( TiXmlVisitor* content ) const;
01534 
01535 protected :
01536     
01537     virtual TiXmlNode* Clone() const;
01538     #ifdef TIXML_USE_STL
01539     virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01540     #endif
01541 
01542 private:
01543     void CopyTo( TiXmlDocument* target ) const;
01544 
01545     bool error;
01546     int  errorId;
01547     TIXML_STRING errorDesc;
01548     int tabsize;
01549     TiXmlCursor errorLocation;
01550     bool useMicrosoftBOM;       
01551 };
01552 
01553 
01634 class TiXmlHandle
01635 {
01636 public:
01638     TiXmlHandle( TiXmlNode* _node )                 { this->node = _node; }
01640     TiXmlHandle( const TiXmlHandle& ref )           { this->node = ref.node; }
01641     TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
01642 
01644     TiXmlHandle FirstChild() const;
01646     TiXmlHandle FirstChild( const char * value ) const;
01648     TiXmlHandle FirstChildElement() const;
01650     TiXmlHandle FirstChildElement( const char * value ) const;
01651 
01655     TiXmlHandle Child( const char* value, int index ) const;
01659     TiXmlHandle Child( int index ) const;
01664     TiXmlHandle ChildElement( const char* value, int index ) const;
01669     TiXmlHandle ChildElement( int index ) const;
01670 
01671     #ifdef TIXML_USE_STL
01672     TiXmlHandle FirstChild( const std::string& _value ) const               { return FirstChild( _value.c_str() ); }
01673     TiXmlHandle FirstChildElement( const std::string& _value ) const        { return FirstChildElement( _value.c_str() ); }
01674 
01675     TiXmlHandle Child( const std::string& _value, int index ) const         { return Child( _value.c_str(), index ); }
01676     TiXmlHandle ChildElement( const std::string& _value, int index ) const  { return ChildElement( _value.c_str(), index ); }
01677     #endif
01678 
01681     TiXmlNode* ToNode() const           { return node; } 
01684     TiXmlElement* ToElement() const     { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
01687     TiXmlText* ToText() const           { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
01690     TiXmlUnknown* ToUnknown() const     { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
01691 
01695     TiXmlNode* Node() const         { return ToNode(); } 
01699     TiXmlElement* Element() const   { return ToElement(); }
01703     TiXmlText* Text() const         { return ToText(); }
01707     TiXmlUnknown* Unknown() const   { return ToUnknown(); }
01708 
01709 private:
01710     TiXmlNode* node;
01711 };
01712 
01713 
01733 class TiXmlPrinter : public TiXmlVisitor
01734 {
01735 public:
01736     TiXmlPrinter() : depth( 0 ), simpleTextPrint( false ),
01737                      buffer(), indent( "    " ), lineBreak( "\n" ) {}
01738 
01739     virtual bool VisitEnter( const TiXmlDocument& doc );
01740     virtual bool VisitExit( const TiXmlDocument& doc );
01741 
01742     virtual bool VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute );
01743     virtual bool VisitExit( const TiXmlElement& element );
01744 
01745     virtual bool Visit( const TiXmlDeclaration& declaration );
01746     virtual bool Visit( const TiXmlText& text );
01747     virtual bool Visit( const TiXmlComment& comment );
01748     virtual bool Visit( const TiXmlUnknown& unknown );
01749 
01753     void SetIndent( const char* _indent )           { indent = _indent ? _indent : "" ; }
01755     const char* Indent()                            { return indent.c_str(); }
01760     void SetLineBreak( const char* _lineBreak )     { lineBreak = _lineBreak ? _lineBreak : ""; }
01762     const char* LineBreak()                         { return lineBreak.c_str(); }
01763 
01767     void SetStreamPrinting()                        { indent = "";
01768                                                       lineBreak = "";
01769                                                     }   
01771     const char* CStr()                              { return buffer.c_str(); }
01773     size_t Size()                                   { return buffer.size(); }
01774 
01775     #ifdef TIXML_USE_STL
01777     const std::string& Str()                        { return buffer; }
01778     #endif
01779 
01780 private:
01781     void DoIndent() {
01782         for( int i=0; i<depth; ++i )
01783             buffer += indent;
01784     }
01785     void DoLineBreak() {
01786         buffer += lineBreak;
01787     }
01788 
01789     int depth;
01790     bool simpleTextPrint;
01791     TIXML_STRING buffer;
01792     TIXML_STRING indent;
01793     TIXML_STRING lineBreak;
01794 };
01795 
01796 
01797 #ifdef _MSC_VER
01798 #pragma warning( pop )
01799 #endif
01800 
01801 #endif
01802