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( disable : 4530 )
00031 #pragma warning( disable : 4786 )
00032 #endif
00033
00034 #include <ctype.h>
00035 #include <stdio.h>
00036 #include <stdlib.h>
00037 #include <string.h>
00038 #include <assert.h>
00039
00040
00041 #if defined( _DEBUG ) && !defined( DEBUG )
00042 #define DEBUG
00043 #endif
00044
00045 #if defined( DEBUG ) && defined( _MSC_VER )
00046 #include <windows.h>
00047 #define TIXML_LOG OutputDebugString
00048 #else
00049 #define TIXML_LOG printf
00050 #endif
00051
00052 #ifdef TIXML_USE_STL
00053 #include <string>
00054 #include <iostream>
00055 #define TIXML_STRING std::string
00056 #define TIXML_ISTREAM std::istream
00057 #define TIXML_OSTREAM std::ostream
00058 #else
00059 #include "tinystr.h"
00060 #define TIXML_STRING TiXmlString
00061 #define TIXML_OSTREAM TiXmlOutStream
00062 #endif
00063
00064 class TiXmlDocument;
00065 class TiXmlElement;
00066 class TiXmlComment;
00067 class TiXmlUnknown;
00068 class TiXmlAttribute;
00069 class TiXmlText;
00070 class TiXmlDeclaration;
00071 class TiXmlParsingData;
00072
00073 const int TIXML_MAJOR_VERSION = 2;
00074 const int TIXML_MINOR_VERSION = 3;
00075 const int TIXML_PATCH_VERSION = 4;
00076
00077
00078
00079
00080 struct TiXmlCursor
00081 {
00082 TiXmlCursor() { Clear(); }
00083 void Clear() { row = col = -1; }
00084
00085 int row;
00086 int col;
00087 };
00088
00089
00090
00091 enum
00092 {
00093 TIXML_SUCCESS,
00094 TIXML_NO_ATTRIBUTE,
00095 TIXML_WRONG_TYPE
00096 };
00097
00098
00099
00100 enum TiXmlEncoding
00101 {
00102 TIXML_ENCODING_UNKNOWN,
00103 TIXML_ENCODING_UTF8,
00104 TIXML_ENCODING_LEGACY
00105 };
00106
00107 const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
00108
00131 class TiXmlBase
00132 {
00133 friend class TiXmlNode;
00134 friend class TiXmlElement;
00135 friend class TiXmlDocument;
00136
00137 public:
00138 TiXmlBase() : userData(0) {}
00139 virtual ~TiXmlBase() {}
00140
00146 virtual void Print( FILE* cfile, int depth ) const = 0;
00147
00154 static void SetCondenseWhiteSpace( bool condense ) { condenseWhiteSpace = condense; }
00155
00157 static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; }
00158
00177 int Row() const { return location.row + 1; }
00178 int Column() const { return location.col + 1; }
00179
00180 void SetUserData( void* user ) { userData = user; }
00181 void* GetUserData() { return userData; }
00182
00183
00184
00185 static const int utf8ByteTable[256];
00186
00187 virtual const char* Parse( const char* p,
00188 TiXmlParsingData* data,
00189 TiXmlEncoding encoding ) = 0;
00190
00191 enum
00192 {
00193 TIXML_NO_ERROR = 0,
00194 TIXML_ERROR,
00195 TIXML_ERROR_OPENING_FILE,
00196 TIXML_ERROR_OUT_OF_MEMORY,
00197 TIXML_ERROR_PARSING_ELEMENT,
00198 TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
00199 TIXML_ERROR_READING_ELEMENT_VALUE,
00200 TIXML_ERROR_READING_ATTRIBUTES,
00201 TIXML_ERROR_PARSING_EMPTY,
00202 TIXML_ERROR_READING_END_TAG,
00203 TIXML_ERROR_PARSING_UNKNOWN,
00204 TIXML_ERROR_PARSING_COMMENT,
00205 TIXML_ERROR_PARSING_DECLARATION,
00206 TIXML_ERROR_DOCUMENT_EMPTY,
00207 TIXML_ERROR_EMBEDDED_NULL,
00208
00209 TIXML_ERROR_STRING_COUNT
00210 };
00211
00212 protected:
00213
00214
00215
00216 class StringToBuffer
00217 {
00218 public:
00219 StringToBuffer( const TIXML_STRING& str );
00220 ~StringToBuffer();
00221 char* buffer;
00222 };
00223
00224 static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding );
00225 inline static bool IsWhiteSpace( char c )
00226 {
00227 return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );
00228 }
00229
00230 virtual void StreamOut (TIXML_OSTREAM *) const = 0;
00231
00232 #ifdef TIXML_USE_STL
00233 static bool StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag );
00234 static bool StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag );
00235 #endif
00236
00237
00238
00239
00240
00241 static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );
00242
00243
00244
00245
00246 static const char* ReadText( const char* in,
00247 TIXML_STRING* text,
00248 bool ignoreWhiteSpace,
00249 const char* endTag,
00250 bool ignoreCase,
00251 TiXmlEncoding encoding );
00252
00253
00254 static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding );
00255
00256
00257
00258 inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
00259 {
00260 assert( p );
00261 if ( encoding == TIXML_ENCODING_UTF8 )
00262 {
00263 *length = utf8ByteTable[ *((unsigned char*)p) ];
00264 assert( *length >= 0 && *length < 5 );
00265 }
00266 else
00267 {
00268 *length = 1;
00269 }
00270
00271 if ( *length == 1 )
00272 {
00273 if ( *p == '&' )
00274 return GetEntity( p, _value, length, encoding );
00275 *_value = *p;
00276 return p+1;
00277 }
00278 else if ( *length )
00279 {
00280 strncpy( _value, p, *length );
00281 return p + (*length);
00282 }
00283 else
00284 {
00285
00286 return 0;
00287 }
00288 }
00289
00290
00291
00292 static void PutString( const TIXML_STRING& str, TIXML_OSTREAM* out );
00293
00294 static void PutString( const TIXML_STRING& str, TIXML_STRING* out );
00295
00296
00297
00298
00299 static bool StringEqual( const char* p,
00300 const char* endTag,
00301 bool ignoreCase,
00302 TiXmlEncoding encoding );
00303
00304 static const char* errorString[ TIXML_ERROR_STRING_COUNT ];
00305
00306 TiXmlCursor location;
00307
00309 void* userData;
00310
00311
00312
00313 static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
00314 static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
00315 inline static int ToLower( int v, TiXmlEncoding encoding )
00316 {
00317 if ( encoding == TIXML_ENCODING_UTF8 )
00318 {
00319 if ( v < 128 ) return tolower( v );
00320 return v;
00321 }
00322 else
00323 {
00324 return tolower( v );
00325 }
00326 }
00327 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
00328
00329 private:
00330 TiXmlBase( const TiXmlBase& );
00331 void operator=( const TiXmlBase& base );
00332
00333 struct Entity
00334 {
00335 const char* str;
00336 unsigned int strLength;
00337 char chr;
00338 };
00339 enum
00340 {
00341 NUM_ENTITY = 5,
00342 MAX_ENTITY_LENGTH = 6
00343
00344 };
00345 static Entity entity[ NUM_ENTITY ];
00346 static bool condenseWhiteSpace;
00347 };
00348
00349
00356 class TiXmlNode : public TiXmlBase
00357 {
00358 friend class TiXmlDocument;
00359 friend class TiXmlElement;
00360
00361 public:
00362 #ifdef TIXML_USE_STL
00363
00367 friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
00368
00385 friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
00386
00388 friend std::string& operator<< (std::string& out, const TiXmlNode& base );
00389
00390 #else
00391
00392 friend TIXML_OSTREAM& operator<< (TIXML_OSTREAM& out, const TiXmlNode& base);
00393 #endif
00394
00398 enum NodeType
00399 {
00400 DOCUMENT,
00401 ELEMENT,
00402 COMMENT,
00403 UNKNOWN,
00404 TEXT,
00405 DECLARATION,
00406 TYPECOUNT
00407 };
00408
00409 virtual ~TiXmlNode();
00410
00423 const char * Value() const { return value.c_str (); }
00424
00434 void SetValue(const char * _value) { value = _value;}
00435
00436 #ifdef TIXML_USE_STL
00437
00438 void SetValue( const std::string& _value )
00439 {
00440 StringToBuffer buf( _value );
00441 SetValue( buf.buffer ? buf.buffer : "" );
00442 }
00443 #endif
00444
00446 void Clear();
00447
00449 TiXmlNode* Parent() { return parent; }
00450 const TiXmlNode* Parent() const { return parent; }
00451
00452 const TiXmlNode* FirstChild() const { return firstChild; }
00453 TiXmlNode* FirstChild() { return firstChild; }
00454 const TiXmlNode* FirstChild( const char * value ) const;
00455 TiXmlNode* FirstChild( const char * value );
00456
00457 const TiXmlNode* LastChild() const { return lastChild; }
00458 TiXmlNode* LastChild() { return lastChild; }
00459 const TiXmlNode* LastChild( const char * value ) const;
00460 TiXmlNode* LastChild( const char * value );
00461
00462 #ifdef TIXML_USE_STL
00463 const TiXmlNode* FirstChild( const std::string& _value ) const { return FirstChild (_value.c_str ()); }
00464 TiXmlNode* FirstChild( const std::string& _value ) { return FirstChild (_value.c_str ()); }
00465 const TiXmlNode* LastChild( const std::string& _value ) const { return LastChild (_value.c_str ()); }
00466 TiXmlNode* LastChild( const std::string& _value ) { return LastChild (_value.c_str ()); }
00467 #endif
00468
00485 const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
00486 TiXmlNode* IterateChildren( TiXmlNode* previous );
00487
00489 const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
00490 TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous );
00491
00492 #ifdef TIXML_USE_STL
00493 const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const { return IterateChildren (_value.c_str (), previous); }
00494 TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) { return IterateChildren (_value.c_str (), previous); }
00495 #endif
00496
00500 TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
00501
00502
00512 TiXmlNode* LinkEndChild( TiXmlNode* addThis );
00513
00517 TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
00518
00522 TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis );
00523
00527 TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
00528
00530 bool RemoveChild( TiXmlNode* removeThis );
00531
00533 const TiXmlNode* PreviousSibling() const { return prev; }
00534 TiXmlNode* PreviousSibling() { return prev; }
00535
00537 const TiXmlNode* PreviousSibling( const char * ) const;
00538 TiXmlNode* PreviousSibling( const char * );
00539
00540 #ifdef TIXML_USE_STL
00541 const TiXmlNode* PreviousSibling( const std::string& _value ) const { return PreviousSibling (_value.c_str ()); }
00542 TiXmlNode* PreviousSibling( const std::string& _value ) { return PreviousSibling (_value.c_str ()); }
00543 const TiXmlNode* NextSibling( const std::string& _value) const { return NextSibling (_value.c_str ()); }
00544 TiXmlNode* NextSibling( const std::string& _value) { return NextSibling (_value.c_str ()); }
00545 #endif
00546
00548 const TiXmlNode* NextSibling() const { return next; }
00549 TiXmlNode* NextSibling() { return next; }
00550
00552 const TiXmlNode* NextSibling( const char * ) const;
00553 TiXmlNode* NextSibling( const char * );
00554
00559 const TiXmlElement* NextSiblingElement() const;
00560 TiXmlElement* NextSiblingElement();
00561
00566 const TiXmlElement* NextSiblingElement( const char * ) const;
00567 TiXmlElement* NextSiblingElement( const char * );
00568
00569 #ifdef TIXML_USE_STL
00570 const TiXmlElement* NextSiblingElement( const std::string& _value) const { return NextSiblingElement (_value.c_str ()); }
00571 TiXmlElement* NextSiblingElement( const std::string& _value) { return NextSiblingElement (_value.c_str ()); }
00572 #endif
00573
00575 const TiXmlElement* FirstChildElement() const;
00576 TiXmlElement* FirstChildElement();
00577
00579 const TiXmlElement* FirstChildElement( const char * value ) const;
00580 TiXmlElement* FirstChildElement( const char * value );
00581
00582 #ifdef TIXML_USE_STL
00583 const TiXmlElement* FirstChildElement( const std::string& _value ) const { return FirstChildElement (_value.c_str ()); }
00584 TiXmlElement* FirstChildElement( const std::string& _value ) { return FirstChildElement (_value.c_str ()); }
00585 #endif
00586
00591 virtual int Type() const { return type; }
00592
00596 const TiXmlDocument* GetDocument() const;
00597 TiXmlDocument* GetDocument();
00598
00600 bool NoChildren() const { return !firstChild; }
00601
00602 const TiXmlDocument* ToDocument() const { return ( this && type == DOCUMENT ) ? (const TiXmlDocument*) this : 0; }
00603 const TiXmlElement* ToElement() const { return ( this && type == ELEMENT ) ? (const TiXmlElement*) this : 0; }
00604 const TiXmlComment* ToComment() const { return ( this && type == COMMENT ) ? (const TiXmlComment*) this : 0; }
00605 const TiXmlUnknown* ToUnknown() const { return ( this && type == UNKNOWN ) ? (const TiXmlUnknown*) this : 0; }
00606 const TiXmlText* ToText() const { return ( this && type == TEXT ) ? (const TiXmlText*) this : 0; }
00607 const TiXmlDeclaration* ToDeclaration() const { return ( this && type == DECLARATION ) ? (const TiXmlDeclaration*) this : 0; }
00608
00609 TiXmlDocument* ToDocument() { return ( this && type == DOCUMENT ) ? (TiXmlDocument*) this : 0; }
00610 TiXmlElement* ToElement() { return ( this && type == ELEMENT ) ? (TiXmlElement*) this : 0; }
00611 TiXmlComment* ToComment() { return ( this && type == COMMENT ) ? (TiXmlComment*) this : 0; }
00612 TiXmlUnknown* ToUnknown() { return ( this && type == UNKNOWN ) ? (TiXmlUnknown*) this : 0; }
00613 TiXmlText* ToText() { return ( this && type == TEXT ) ? (TiXmlText*) this : 0; }
00614 TiXmlDeclaration* ToDeclaration() { return ( this && type == DECLARATION ) ? (TiXmlDeclaration*) this : 0; }
00615
00619 virtual TiXmlNode* Clone() const = 0;
00620
00621 protected:
00622 TiXmlNode( NodeType _type );
00623
00624
00625
00626 void CopyTo( TiXmlNode* target ) const;
00627
00628 #ifdef TIXML_USE_STL
00629
00630 virtual void StreamIn( TIXML_ISTREAM* in, TIXML_STRING* tag ) = 0;
00631 #endif
00632
00633
00634 TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );
00635
00636
00637 const TIXML_STRING& SValue() const { return value ; }
00638
00639 TiXmlNode* parent;
00640 NodeType type;
00641
00642 TiXmlNode* firstChild;
00643 TiXmlNode* lastChild;
00644
00645 TIXML_STRING value;
00646
00647 TiXmlNode* prev;
00648 TiXmlNode* next;
00649
00650 private:
00651 TiXmlNode( const TiXmlNode& );
00652 void operator=( const TiXmlNode& base );
00653 };
00654
00655
00663 class TiXmlAttribute : public TiXmlBase
00664 {
00665 friend class TiXmlAttributeSet;
00666
00667 public:
00669 TiXmlAttribute() : TiXmlBase()
00670 {
00671 document = 0;
00672 prev = next = 0;
00673 }
00674
00675 #ifdef TIXML_USE_STL
00676
00677 TiXmlAttribute( const std::string& _name, const std::string& _value )
00678 {
00679 name = _name;
00680 value = _value;
00681 document = 0;
00682 prev = next = 0;
00683 }
00684 #endif
00685
00687 TiXmlAttribute( const char * _name, const char * _value )
00688 {
00689 name = _name;
00690 value = _value;
00691 document = 0;
00692 prev = next = 0;
00693 }
00694
00695 const char* Name() const { return name.c_str (); }
00696 const char* Value() const { return value.c_str (); }
00697 const int IntValue() const;
00698 const double DoubleValue() const;
00699
00709 int QueryIntValue( int* value ) const;
00711 int QueryDoubleValue( double* value ) const;
00712
00713 void SetName( const char* _name ) { name = _name; }
00714 void SetValue( const char* _value ) { value = _value; }
00715
00716 void SetIntValue( int value );
00717 void SetDoubleValue( double value );
00718
00719 #ifdef TIXML_USE_STL
00720
00721 void SetName( const std::string& _name )
00722 {
00723 StringToBuffer buf( _name );
00724 SetName ( buf.buffer ? buf.buffer : "error" );
00725 }
00727 void SetValue( const std::string& _value )
00728 {
00729 StringToBuffer buf( _value );
00730 SetValue( buf.buffer ? buf.buffer : "error" );
00731 }
00732 #endif
00733
00735 const TiXmlAttribute* Next() const;
00736 TiXmlAttribute* Next();
00738 const TiXmlAttribute* Previous() const;
00739 TiXmlAttribute* Previous();
00740
00741 bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
00742 bool operator<( const TiXmlAttribute& rhs ) const { return name < rhs.name; }
00743 bool operator>( const TiXmlAttribute& rhs ) const { return name > rhs.name; }
00744
00745
00746
00747
00748 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
00749
00750
00751 virtual void Print( FILE* cfile, int depth ) const;
00752
00753 virtual void StreamOut( TIXML_OSTREAM * out ) const;
00754
00755
00756 void SetDocument( TiXmlDocument* doc ) { document = doc; }
00757
00758 private:
00759 TiXmlAttribute( const TiXmlAttribute& );
00760 void operator=( const TiXmlAttribute& base );
00761
00762 TiXmlDocument* document;
00763 TIXML_STRING name;
00764 TIXML_STRING value;
00765 TiXmlAttribute* prev;
00766 TiXmlAttribute* next;
00767 };
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782 class TiXmlAttributeSet
00783 {
00784 public:
00785 TiXmlAttributeSet();
00786 ~TiXmlAttributeSet();
00787
00788 void Add( TiXmlAttribute* attribute );
00789 void Remove( TiXmlAttribute* attribute );
00790
00791 const TiXmlAttribute* First() const { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
00792 TiXmlAttribute* First() { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
00793 const TiXmlAttribute* Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
00794 TiXmlAttribute* Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
00795
00796 const TiXmlAttribute* Find( const char * name ) const;
00797 TiXmlAttribute* Find( const char * name );
00798
00799 private:
00800
00801
00802 TiXmlAttributeSet( const TiXmlAttributeSet& );
00803 void operator=( const TiXmlAttributeSet& );
00804
00805 TiXmlAttribute sentinel;
00806 };
00807
00808
00813 class TiXmlElement : public TiXmlNode
00814 {
00815 public:
00817 TiXmlElement (const char * in_value);
00818
00819 #ifdef TIXML_USE_STL
00820
00821 TiXmlElement( const std::string& _value );
00822 #endif
00823
00824 TiXmlElement( const TiXmlElement& );
00825
00826 void operator=( const TiXmlElement& base );
00827
00828 virtual ~TiXmlElement();
00829
00833 const char* Attribute( const char* name ) const;
00834
00841 const char* Attribute( const char* name, int* i ) const;
00842
00849 const char* Attribute( const char* name, double* d ) const;
00850
00858 int QueryIntAttribute( const char* name, int* value ) const;
00860 int QueryDoubleAttribute( const char* name, double* value ) const;
00862 int QueryDoubleAttribute( const char* name, float* value ) const {
00863 double d;
00864 int result = QueryDoubleAttribute( name, &d );
00865 *value = (float)d;
00866 return result;
00867 }
00868
00872 void SetAttribute( const char* name, const char * value );
00873
00874 #ifdef TIXML_USE_STL
00875 const char* Attribute( const std::string& name ) const { return Attribute( name.c_str() ); }
00876 const char* Attribute( const std::string& name, int* i ) const { return Attribute( name.c_str(), i ); }
00877 const char* Attribute( const std::string& name, double* d ) const { return Attribute( name.c_str(), d ); }
00878 int QueryIntAttribute( const std::string& name, int* value ) const { return QueryIntAttribute( name.c_str(), value ); }
00879 int QueryDoubleAttribute( const std::string& name, double* value ) const { return QueryDoubleAttribute( name.c_str(), value ); }
00880
00882 void SetAttribute( const std::string& name, const std::string& _value )
00883 {
00884 StringToBuffer n( name );
00885 StringToBuffer v( _value );
00886 if ( n.buffer && v.buffer )
00887 SetAttribute (n.buffer, v.buffer );
00888 }
00890 void SetAttribute( const std::string& name, int _value )
00891 {
00892 StringToBuffer n( name );
00893 if ( n.buffer )
00894 SetAttribute (n.buffer, _value);
00895 }
00896 #endif
00897
00901 void SetAttribute( const char * name, int value );
00902
00906 void SetDoubleAttribute( const char * name, double value );
00907
00910 void RemoveAttribute( const char * name );
00911 #ifdef TIXML_USE_STL
00912 void RemoveAttribute( const std::string& name ) { RemoveAttribute (name.c_str ()); }
00913 #endif
00914
00915 const TiXmlAttribute* FirstAttribute() const { return attributeSet.First(); }
00916 TiXmlAttribute* FirstAttribute() { return attributeSet.First(); }
00917 const TiXmlAttribute* LastAttribute() const { return attributeSet.Last(); }
00918 TiXmlAttribute* LastAttribute() { return attributeSet.Last(); }
00919
00921 virtual TiXmlNode* Clone() const;
00922
00923 virtual void Print( FILE* cfile, int depth ) const;
00924
00925
00926
00927
00928 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
00929
00930 protected:
00931
00932 void CopyTo( TiXmlElement* target ) const;
00933 void ClearThis();
00934
00935
00936 #ifdef TIXML_USE_STL
00937 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
00938 #endif
00939 virtual void StreamOut( TIXML_OSTREAM * out ) const;
00940
00941
00942
00943
00944
00945 const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
00946
00947 private:
00948
00949 TiXmlAttributeSet attributeSet;
00950 };
00951
00952
00955 class TiXmlComment : public TiXmlNode
00956 {
00957 public:
00959 TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
00960 TiXmlComment( const TiXmlComment& );
00961 void operator=( const TiXmlComment& base );
00962
00963 virtual ~TiXmlComment() {}
00964
00966 virtual TiXmlNode* Clone() const;
00968 virtual void Print( FILE* cfile, int depth ) const;
00969
00970
00971
00972
00973 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
00974
00975 protected:
00976 void CopyTo( TiXmlComment* target ) const;
00977
00978
00979 #ifdef TIXML_USE_STL
00980 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
00981 #endif
00982 virtual void StreamOut( TIXML_OSTREAM * out ) const;
00983
00984 private:
00985
00986 };
00987
00988
00991 class TiXmlText : public TiXmlNode
00992 {
00993 friend class TiXmlElement;
00994 public:
00996 TiXmlText (const char * initValue) : TiXmlNode (TiXmlNode::TEXT)
00997 {
00998 SetValue( initValue );
00999 }
01000 virtual ~TiXmlText() {}
01001
01002 #ifdef TIXML_USE_STL
01003
01004 TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
01005 {
01006 SetValue( initValue );
01007 }
01008 #endif
01009
01010 TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT ) { copy.CopyTo( this ); }
01011 void operator=( const TiXmlText& base ) { base.CopyTo( this ); }
01012
01014 virtual void Print( FILE* cfile, int depth ) const;
01015
01016 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01017
01018 protected :
01020 virtual TiXmlNode* Clone() const;
01021 void CopyTo( TiXmlText* target ) const;
01022
01023 virtual void StreamOut ( TIXML_OSTREAM * out ) const;
01024 bool Blank() const;
01025
01026 #ifdef TIXML_USE_STL
01027 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
01028 #endif
01029
01030 private:
01031 };
01032
01033
01047 class TiXmlDeclaration : public TiXmlNode
01048 {
01049 public:
01051 TiXmlDeclaration() : TiXmlNode( TiXmlNode::DECLARATION ) {}
01052
01053 #ifdef TIXML_USE_STL
01054
01055 TiXmlDeclaration( const std::string& _version,
01056 const std::string& _encoding,
01057 const std::string& _standalone );
01058 #endif
01059
01061 TiXmlDeclaration( const char* _version,
01062 const char* _encoding,
01063 const char* _standalone );
01064
01065 TiXmlDeclaration( const TiXmlDeclaration& copy );
01066 void operator=( const TiXmlDeclaration& copy );
01067
01068 virtual ~TiXmlDeclaration() {}
01069
01071 const char *Version() const { return version.c_str (); }
01073 const char *Encoding() const { return encoding.c_str (); }
01075 const char *Standalone() const { return standalone.c_str (); }
01076
01078 virtual TiXmlNode* Clone() const;
01080 virtual void Print( FILE* cfile, int depth ) const;
01081
01082 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01083
01084 protected:
01085 void CopyTo( TiXmlDeclaration* target ) const;
01086
01087 #ifdef TIXML_USE_STL
01088 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
01089 #endif
01090 virtual void StreamOut ( TIXML_OSTREAM * out) const;
01091
01092 private:
01093
01094 TIXML_STRING version;
01095 TIXML_STRING encoding;
01096 TIXML_STRING standalone;
01097 };
01098
01099
01107 class TiXmlUnknown : public TiXmlNode
01108 {
01109 public:
01110 TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN ) {}
01111 virtual ~TiXmlUnknown() {}
01112
01113 TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN ) { copy.CopyTo( this ); }
01114 void operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); }
01115
01117 virtual TiXmlNode* Clone() const;
01119 virtual void Print( FILE* cfile, int depth ) const;
01120
01121 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01122
01123 protected:
01124 void CopyTo( TiXmlUnknown* target ) const;
01125
01126 #ifdef TIXML_USE_STL
01127 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
01128 #endif
01129 virtual void StreamOut ( TIXML_OSTREAM * out ) const;
01130
01131 private:
01132
01133 };
01134
01135
01140 class TiXmlDocument : public TiXmlNode
01141 {
01142 public:
01144 TiXmlDocument();
01146 TiXmlDocument( const char * documentName );
01147
01148 #ifdef TIXML_USE_STL
01149
01150 TiXmlDocument( const std::string& documentName );
01151 #endif
01152
01153 TiXmlDocument( const TiXmlDocument& copy );
01154 void operator=( const TiXmlDocument& copy );
01155
01156 virtual ~TiXmlDocument() {}
01157
01162 bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01164 bool SaveFile() const;
01166 bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01168 bool SaveFile( const char * filename ) const;
01169
01170 #ifdef TIXML_USE_STL
01171 bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )
01172 {
01173 StringToBuffer f( filename );
01174 return ( f.buffer && LoadFile( f.buffer, encoding ));
01175 }
01176 bool SaveFile( const std::string& filename ) const
01177 {
01178 StringToBuffer f( filename );
01179 return ( f.buffer && SaveFile( f.buffer ));
01180 }
01181 #endif
01182
01187 virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01188
01193 const TiXmlElement* RootElement() const { return FirstChildElement(); }
01194 TiXmlElement* RootElement() { return FirstChildElement(); }
01195
01201 bool Error() const { return error; }
01202
01204 const char * ErrorDesc() const { return errorDesc.c_str (); }
01205
01209 const int ErrorId() const { return errorId; }
01210
01218 int ErrorRow() { return errorLocation.row+1; }
01219 int ErrorCol() { return errorLocation.col+1; }
01220
01241 void SetTabSize( int _tabsize ) { tabsize = _tabsize; }
01242
01243 int TabSize() const { return tabsize; }
01244
01248 void ClearError() { error = false;
01249 errorId = 0;
01250 errorDesc = "";
01251 errorLocation.row = errorLocation.col = 0;
01252
01253 }
01254
01256 void Print() const { Print( stdout, 0 ); }
01257
01259 virtual void Print( FILE* cfile, int depth = 0 ) const;
01260
01261 void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
01262
01263 protected :
01264 virtual void StreamOut ( TIXML_OSTREAM * out) const;
01265
01266 virtual TiXmlNode* Clone() const;
01267 #ifdef TIXML_USE_STL
01268 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
01269 #endif
01270
01271 private:
01272 void CopyTo( TiXmlDocument* target ) const;
01273
01274 bool error;
01275 int errorId;
01276 TIXML_STRING errorDesc;
01277 int tabsize;
01278 TiXmlCursor errorLocation;
01279 };
01280
01281
01362 class TiXmlHandle
01363 {
01364 public:
01366 TiXmlHandle( TiXmlNode* node ) { this->node = node; }
01368 TiXmlHandle( const TiXmlHandle& ref ) { this->node = ref.node; }
01369 TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
01370
01372 TiXmlHandle FirstChild() const;
01374 TiXmlHandle FirstChild( const char * value ) const;
01376 TiXmlHandle FirstChildElement() const;
01378 TiXmlHandle FirstChildElement( const char * value ) const;
01379
01383 TiXmlHandle Child( const char* value, int index ) const;
01387 TiXmlHandle Child( int index ) const;
01392 TiXmlHandle ChildElement( const char* value, int index ) const;
01397 TiXmlHandle ChildElement( int index ) const;
01398
01399 #ifdef TIXML_USE_STL
01400 TiXmlHandle FirstChild( const std::string& _value ) const { return FirstChild( _value.c_str() ); }
01401 TiXmlHandle FirstChildElement( const std::string& _value ) const { return FirstChildElement( _value.c_str() ); }
01402
01403 TiXmlHandle Child( const std::string& _value, int index ) const { return Child( _value.c_str(), index ); }
01404 TiXmlHandle ChildElement( const std::string& _value, int index ) const { return ChildElement( _value.c_str(), index ); }
01405 #endif
01406
01408 TiXmlNode* Node() const { return node; }
01410 TiXmlElement* Element() const { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
01412 TiXmlText* Text() const { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
01414 TiXmlUnknown* Unknown() const { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
01415
01416 private:
01417 TiXmlNode* node;
01418 };
01419
01420 #ifdef _MSC_VER
01421 #pragma warning( default : 4530 )
01422 #pragma warning( default : 4786 )
01423 #endif
01424
01425 #endif
01426