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
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129 class TiXmlVisitor
00130 {
00131 public:
00132 virtual ~TiXmlVisitor() {}
00133
00134
00135 virtual bool VisitEnter( const TiXmlDocument& ) { return true; }
00136
00137 virtual bool VisitExit( const TiXmlDocument& ) { return true; }
00138
00139
00140 virtual bool VisitEnter( const TiXmlElement& , const TiXmlAttribute* ) { return true; }
00141
00142 virtual bool VisitExit( const TiXmlElement& ) { return true; }
00143
00144
00145 virtual bool Visit( const TiXmlDeclaration& ) { return true; }
00146
00147 virtual bool Visit( const TiXmlText& ) { return true; }
00148
00149 virtual bool Visit( const TiXmlComment& ) { return true; }
00150
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
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
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
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214 virtual void Print( FILE* cfile, int depth ) const = 0;
00215
00216
00217
00218
00219
00220
00221
00222 static void SetCondenseWhiteSpace( bool condense ) { condenseWhiteSpace = condense; }
00223
00224
00225 static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; }
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
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
00260
00261
00262
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
00376
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
00418
00419
00420
00421
00422
00423
00424 class TiXmlNode : public TiXmlBase
00425 {
00426 friend class TiXmlDocument;
00427 friend class TiXmlElement;
00428
00429 public:
00430 #ifdef TIXML_USE_STL
00431
00432
00433
00434
00435 friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453 friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
00454
00455
00456 friend std::string& operator<< (std::string& out, const TiXmlNode& base );
00457
00458 #endif
00459
00460
00461
00462
00463 enum NodeType
00464 {
00465 DOCUMENT,
00466 ELEMENT,
00467 COMMENT,
00468 UNKNOWN,
00469 TEXT,
00470 DECLARATION,
00471 TYPECOUNT
00472 };
00473
00474 virtual ~TiXmlNode();
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488 const char *Value() const { return value.c_str (); }
00489
00490 #ifdef TIXML_USE_STL
00491
00492
00493
00494
00495 const std::string& ValueStr() const { return value; }
00496 #endif
00497
00498 const TIXML_STRING& ValueTStr() const { return value; }
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509 void SetValue(const char * _value) { value = _value;}
00510
00511 #ifdef TIXML_USE_STL
00512
00513 void SetValue( const std::string& _value ) { value = _value; }
00514 #endif
00515
00516
00517 void Clear();
00518
00519
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
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
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
00568
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
00579
00580
00581
00582 TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594 TiXmlNode* LinkEndChild( TiXmlNode* addThis );
00595
00596
00597
00598
00599 TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
00600
00601
00602
00603
00604 TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis );
00605
00606
00607
00608
00609 TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
00610
00611
00612 bool RemoveChild( TiXmlNode* removeThis );
00613
00614
00615 const TiXmlNode* PreviousSibling() const { return prev; }
00616 TiXmlNode* PreviousSibling() { return prev; }
00617
00618
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
00631
00632 const TiXmlNode* NextSibling() const { return next; }
00633 TiXmlNode* NextSibling() { return next; }
00634
00635
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
00641
00642
00643
00644
00645 const TiXmlElement* NextSiblingElement() const;
00646 TiXmlElement* NextSiblingElement() {
00647 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() );
00648 }
00649
00650
00651
00652
00653
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
00664
00665 const TiXmlElement* FirstChildElement() const;
00666 TiXmlElement* FirstChildElement() {
00667 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() );
00668 }
00669
00670
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
00681
00682
00683
00684
00685 int Type() const { return type; }
00686
00687
00688
00689
00690 const TiXmlDocument* GetDocument() const;
00691 TiXmlDocument* GetDocument() {
00692 return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() );
00693 }
00694
00695
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
00712
00713
00714
00715 virtual TiXmlNode* Clone() const = 0;
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739 virtual bool Accept( TiXmlVisitor* visitor ) const = 0;
00740
00741 void CopyTo( TiXmlNode* target ) const;
00742 protected:
00743 TiXmlNode( NodeType _type );
00744
00745
00746
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
00773
00774
00775
00776
00777
00778
00779
00780 class TiXmlAttribute : public TiXmlBase
00781 {
00782 friend class TiXmlAttributeSet;
00783
00784 public:
00785
00786 TiXmlAttribute() : TiXmlBase()
00787 {
00788 document = 0;
00789 prev = next = 0;
00790 }
00791
00792 #ifdef TIXML_USE_STL
00793
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
00803
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
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832 int QueryIntValue( int* _value ) const;
00833
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
00843
00844 void SetName( const std::string& _name ) { name = _name; }
00845
00846 void SetValue( const std::string& _value ) { value = _value; }
00847 #endif
00848
00849
00850 const TiXmlAttribute* Next() const;
00851 TiXmlAttribute* Next() {
00852 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() );
00853 }
00854
00855
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
00940
00941
00942
00943
00944 class TiXmlElement : public TiXmlNode
00945 {
00946 public:
00947
00948 TiXmlElement (const char * in_value);
00949
00950 #ifdef TIXML_USE_STL
00951
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
00961
00962
00963
00964 const char* Attribute( const char* name ) const;
00965
00966
00967
00968
00969
00970
00971
00972 const char* Attribute( const char* name, int* i ) const;
00973
00974
00975
00976
00977
00978
00979
00980 const char* Attribute( const char* name, double* d ) const;
00981
00982
00983
00984
00985
00986
00987
00988
00989 int QueryIntAttribute( const char* name, int* _value ) const;
00990
00991 int QueryDoubleAttribute( const char* name, double* _value ) const;
00992
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
01004
01005
01006
01007
01008
01009
01010
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
01040
01041
01042
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
01052
01053 void SetAttribute( const std::string& name, const std::string& _value );
01054
01055 void SetAttribute( const std::string& name, int _value );
01056 #endif
01057
01058
01059
01060
01061 void SetAttribute( const char * name, int value );
01062
01063
01064
01065
01066 void SetDoubleAttribute( const char * name, double value );
01067
01068
01069
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
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098
01099
01100
01101
01102
01103
01104
01105
01106
01107
01108
01109
01110
01111
01112 const char* GetText() const;
01113
01114
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
01127
01128
01129 virtual bool Accept( TiXmlVisitor* visitor ) const;
01130
01131 void CopyTo( TiXmlElement* target ) const;
01132 protected:
01133
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
01152
01153
01154 class TiXmlComment : public TiXmlNode
01155 {
01156 public:
01157
01158 TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
01159
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
01168
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
01181
01182
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
01199
01200
01201
01202
01203
01204 class TiXmlText : public TiXmlNode
01205 {
01206 friend class TiXmlElement;
01207 public:
01208
01209
01210
01211
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
01220
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
01234
01235 bool CDATA() const { return cdata; }
01236
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
01244
01245
01246 virtual bool Accept( TiXmlVisitor* content ) const;
01247
01248 protected :
01249
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
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277 class TiXmlDeclaration : public TiXmlNode
01278 {
01279 public:
01280
01281 TiXmlDeclaration() : TiXmlNode( TiXmlNode::DECLARATION ) {}
01282
01283 #ifdef TIXML_USE_STL
01284
01285 TiXmlDeclaration( const std::string& _version,
01286 const std::string& _encoding,
01287 const std::string& _standalone );
01288 #endif
01289
01290
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
01300
01301 const char *Version() const { return version.c_str (); }
01302
01303 const char *Encoding() const { return encoding.c_str (); }
01304
01305 const char *Standalone() const { return standalone.c_str (); }
01306
01307
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
01320
01321
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
01339
01340
01341
01342
01343
01344
01345
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
01355
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
01365
01366
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
01381
01382
01383
01384
01385 class TiXmlDocument : public TiXmlNode
01386 {
01387 public:
01388
01389 TiXmlDocument();
01390
01391 TiXmlDocument( const char * documentName );
01392
01393 #ifdef TIXML_USE_STL
01394
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
01403
01404
01405
01406
01407 bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01408
01409 bool SaveFile() const;
01410
01411 bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01412
01413 bool SaveFile( const char * filename ) const;
01414
01415
01416
01417
01418
01419 bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01420
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
01438
01439
01440
01441
01442 virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01443
01444
01445
01446
01447
01448 const TiXmlElement* RootElement() const { return FirstChildElement(); }
01449 TiXmlElement* RootElement() { return FirstChildElement(); }
01450
01451
01452
01453
01454
01455
01456 bool Error() const { return error; }
01457
01458
01459 const char * ErrorDesc() const { return errorDesc.c_str (); }
01460
01461
01462
01463
01464 int ErrorId() const { return errorId; }
01465
01466
01467
01468
01469
01470
01471
01472
01473 int ErrorRow() const { return errorLocation.row+1; }
01474 int ErrorCol() const { return errorLocation.col+1; }
01475
01476
01477
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499
01500 void SetTabSize( int _tabsize ) { tabsize = _tabsize; }
01501
01502 int TabSize() const { return tabsize; }
01503
01504
01505
01506
01507 void ClearError() { error = false;
01508 errorId = 0;
01509 errorDesc = "";
01510 errorLocation.row = errorLocation.col = 0;
01511
01512 }
01513
01514
01515 void Print() const { Print( stdout, 0 ); }
01516
01517
01518
01519
01520
01521
01522
01523
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
01531
01532
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
01554
01555
01556
01557
01558
01559
01560
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570
01571
01572
01573
01574
01575
01576
01577
01578
01579
01580
01581
01582
01583
01584
01585
01586
01587
01588
01589
01590
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601
01602
01603
01604
01605
01606
01607
01608
01609
01610
01611
01612
01613
01614
01615
01616
01617
01618
01619
01620
01621
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634 class TiXmlHandle
01635 {
01636 public:
01637
01638 TiXmlHandle( TiXmlNode* _node ) { this->node = _node; }
01639
01640 TiXmlHandle( const TiXmlHandle& ref ) { this->node = ref.node; }
01641 TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
01642
01643
01644 TiXmlHandle FirstChild() const;
01645
01646 TiXmlHandle FirstChild( const char * value ) const;
01647
01648 TiXmlHandle FirstChildElement() const;
01649
01650 TiXmlHandle FirstChildElement( const char * value ) const;
01651
01652
01653
01654
01655 TiXmlHandle Child( const char* value, int index ) const;
01656
01657
01658
01659 TiXmlHandle Child( int index ) const;
01660
01661
01662
01663
01664 TiXmlHandle ChildElement( const char* value, int index ) const;
01665
01666
01667
01668
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
01679
01680
01681 TiXmlNode* ToNode() const { return node; }
01682
01683
01684 TiXmlElement* ToElement() const { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
01685
01686
01687 TiXmlText* ToText() const { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
01688
01689
01690 TiXmlUnknown* ToUnknown() const { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
01691
01692
01693
01694
01695 TiXmlNode* Node() const { return ToNode(); }
01696
01697
01698
01699 TiXmlElement* Element() const { return ToElement(); }
01700
01701
01702
01703 TiXmlText* Text() const { return ToText(); }
01704
01705
01706
01707 TiXmlUnknown* Unknown() const { return ToUnknown(); }
01708
01709 private:
01710 TiXmlNode* node;
01711 };
01712
01713
01714
01715
01716
01717
01718
01719
01720
01721
01722
01723
01724
01725
01726
01727
01728
01729
01730
01731
01732
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
01750
01751
01752
01753 void SetIndent( const char* _indent ) { indent = _indent ? _indent : "" ; }
01754
01755 const char* Indent() { return indent.c_str(); }
01756
01757
01758
01759
01760 void SetLineBreak( const char* _lineBreak ) { lineBreak = _lineBreak ? _lineBreak : ""; }
01761
01762 const char* LineBreak() { return lineBreak.c_str(); }
01763
01764
01765
01766
01767 void SetStreamPrinting() { indent = "";
01768 lineBreak = "";
01769 }
01770
01771 const char* CStr() { return buffer.c_str(); }
01772
01773 size_t Size() { return buffer.size(); }
01774
01775 #ifdef TIXML_USE_STL
01776
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