Crazy Eddies GUI System: tinyxml.h Source File

- Main Page
- Namespaces
- Classes
- Files
- Directories
- Related Pages

# tinyxml.h

    00001 /*
    00002 www.sourceforge.net/projects/tinyxml
    00003 Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
    00004
    00005 This software is provided 'as-is', without any express or implied
    00006 warranty. In no event will the authors be held liable for any
    00007 damages arising from the use of this software.
    00008
    00009 Permission is granted to anyone to use this software for any
    00010 purpose, including commercial applications, and to alter it and
    00011 redistribute it freely, subject to the following restrictions:
    00012
    00013 1. The origin of this software must not be misrepresented; you must
    00014 not claim that you wrote the original software. If you use this
    00015 software in a product, an acknowledgment in the product documentation
    00016 would be appreciated but is not required.
    00017
    00018 2. Altered source versions must be plainly marked as such, and
    00019 must not be misrepresented as being the original software.
    00020
    00021 3. This notice may not be removed or altered from any source
    00022 distribution.
    00023 */
    00024
    00025
    00026 #ifndef TINYXML_INCLUDED
    00027 #define TINYXML_INCLUDED
    00028
    00029 #ifdef _MSC_VER
    00030 #pragma warning( 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 // Help out windows:
    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         #define TIXML_CAST_STRING std::string
    00059 #else
    00060         #include "tinystr.h"
    00061         #define TIXML_STRING    TiXmlString
    00062         #define TIXML_OSTREAM   TiXmlOutStream
    00063         #define TIXML_CAST_STRING
    00064 #endif
    00065
    00066 class TiXmlDocument;
    00067 class TiXmlElement;
    00068 class TiXmlComment;
    00069 class TiXmlUnknown;
    00070 class TiXmlAttribute;
    00071 class TiXmlText;
    00072 class TiXmlDeclaration;
    00073 class TiXmlParsingData;
    00074
    00075 const int TIXML_MAJOR_VERSION = 2;
    00076 const int TIXML_MINOR_VERSION = 3;
    00077 const int TIXML_PATCH_VERSION = 3;
    00078
    00079 /*      Internal structure for tracking location of items
    00080         in the XML file.
    00081 */
    00082 struct TiXmlCursor
    00083 {
    00084         TiXmlCursor()           { Clear(); }
    00085         void Clear()            { row = col = -1; }
    00086
    00087         int row;        // 0 based.
    00088         int col;        // 0 based.
    00089 };
    00090
    00091
    00092 // Only used by Attribute::Query functions
    00093 enum
    00094 {
    00095         TIXML_SUCCESS,
    00096         TIXML_NO_ATTRIBUTE,
    00097         TIXML_WRONG_TYPE
    00098 };
    00099
    00100
    00101 // Used by the parsing routines.
    00102 enum TiXmlEncoding
    00103 {
    00104         TIXML_ENCODING_UNKNOWN,
    00105         TIXML_ENCODING_UTF8,
    00106         TIXML_ENCODING_LEGACY
    00107 };
    00108
    00109 const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
    00110
    00133 class TiXmlBase
    00134 {
    00135         friend class TiXmlNode;
    00136         friend class TiXmlElement;
    00137         friend class TiXmlDocument;
    00138
    00139 public:
    00140         TiXmlBase()     :       userData(0) {}
    00141         virtual ~TiXmlBase()                                    {}
    00142
    00148         virtual void Print( FILE* cfile, int depth ) const = 0;
    00149
    00156         static void SetCondenseWhiteSpace( bool condense )              { condenseWhiteSpace = condense; }
    00157
    00159         static bool IsWhiteSpaceCondensed()                                             { return condenseWhiteSpace; }
    00160
    00179         int Row() const                 { return location.row + 1; }
    00180         int Column() const              { return location.col + 1; }
    00181
    00182         void  SetUserData( void* user )                 { userData = user; }
    00183         void* GetUserData()                                             { return userData; }
    00184
    00185         // Table that returs, for a given lead byte, the total number of bytes
    00186         // in the UTF-8 sequence.
    00187         static const int utf8ByteTable[256];
    00188
    00189         virtual const char* Parse(      const char* p,
    00190                                                                 TiXmlParsingData* data,
    00191                                                                 TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
    00192
    00193         enum
    00194         {
    00195                 TIXML_NO_ERROR = 0,
    00196                 TIXML_ERROR,
    00197                 TIXML_ERROR_OPENING_FILE,
    00198                 TIXML_ERROR_OUT_OF_MEMORY,
    00199                 TIXML_ERROR_PARSING_ELEMENT,
    00200                 TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
    00201                 TIXML_ERROR_READING_ELEMENT_VALUE,
    00202                 TIXML_ERROR_READING_ATTRIBUTES,
    00203                 TIXML_ERROR_PARSING_EMPTY,
    00204                 TIXML_ERROR_READING_END_TAG,
    00205                 TIXML_ERROR_PARSING_UNKNOWN,
    00206                 TIXML_ERROR_PARSING_COMMENT,
    00207                 TIXML_ERROR_PARSING_DECLARATION,
    00208                 TIXML_ERROR_DOCUMENT_EMPTY,
    00209                 TIXML_ERROR_EMBEDDED_NULL,
    00210
    00211                 TIXML_ERROR_STRING_COUNT
    00212         };
    00213
    00214 protected:
    00215
    00216         // See STL_STRING_BUG
    00217         // Utility class to overcome a bug.
    00218         class StringToBuffer
    00219         {
    00220           public:
    00221                 StringToBuffer( const TIXML_STRING& str );
    00222                 ~StringToBuffer();
    00223                 char* buffer;
    00224         };
    00225
    00226         static const char*      SkipWhiteSpace( const char*, TiXmlEncoding encoding );
    00227         inline static bool      IsWhiteSpace( char c )
    00228         {
    00229                 return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );
    00230         }
    00231
    00232         virtual void StreamOut (TIXML_OSTREAM *) const = 0;
    00233
    00234         #ifdef TIXML_USE_STL
    00235             static bool StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag );
    00236             static bool StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag );
    00237         #endif
    00238
    00239         /*      Reads an XML name into the string provided. Returns
    00240                 a pointer just past the last character of the name,
    00241                 or 0 if the function has an error.
    00242         */
    00243         static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );
    00244
    00245         /*      Reads text. Returns a pointer past the given end tag.
    00246                 Wickedly complex options, but it keeps the (sensitive) code in one place.
    00247         */
    00248         static const char* ReadText(    const char* in,                         // where to start
    00249                                                                         TIXML_STRING* text,                     // the string read
    00250                                                                         bool ignoreWhiteSpace,          // whether to keep the white space
    00251                                                                         const char* endTag,                     // what ends this text
    00252                                                                         bool ignoreCase,                        // whether to ignore case in the end tag
    00253                                                                         TiXmlEncoding encoding );       // the current encoding
    00254
    00255         // If an entity has been found, transform it into a character.
    00256         static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding );
    00257
    00258         // Get a character, while interpreting entities.
    00259         // The length can be from 0 to 4 bytes.
    00260         inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
    00261         {
    00262                 assert( p );
    00263                 if ( encoding == TIXML_ENCODING_UTF8 )
    00264                 {
    00265                         *length = utf8ByteTable[ *((unsigned char*)p) ];
    00266                         assert( *length >= 0 && *length < 5 );
    00267                 }
    00268                 else
    00269                 {
    00270                         *length = 1;
    00271                 }
    00272
    00273                 if ( *length == 1 )
    00274                 {
    00275                         if ( *p == '&' )
    00276                                 return GetEntity( p, _value, length, encoding );
    00277                         *_value = *p;
    00278                         return p+1;
    00279                 }
    00280                 else if ( *length )
    00281                 {
    00282                         strncpy( _value, p, *length );
    00283                         return p + (*length);
    00284                 }
    00285                 else
    00286                 {
    00287                         // Not valid text.
    00288                         return 0;
    00289                 }
    00290         }
    00291
    00292         // Puts a string to a stream, expanding entities as it goes.
    00293         // Note this should not contian the '<', '>', etc, or they will be transformed into entities!
    00294         static void PutString( const TIXML_STRING& str, TIXML_OSTREAM* out );
    00295
    00296         static void PutString( const TIXML_STRING& str, TIXML_STRING* out );
    00297
    00298         // Return true if the next characters in the stream are any of the endTag sequences.
    00299         // Ignore case only works for english, and should only be relied on when comparing
    00300         // to Engilish words: StringEqual( p, "version", true ) is fine.
    00301         static bool StringEqual(        const char* p,
    00302                                                                 const char* endTag,
    00303                                                                 bool ignoreCase,
    00304                                                                 TiXmlEncoding encoding );
    00305
    00306         static const char* errorString[ TIXML_ERROR_STRING_COUNT ];
    00307
    00308         TiXmlCursor location;
    00309
    00311         void*                   userData;
    00312
    00313         // None of these methods are reliable for any language except English.
    00314         // Good for approximation, not great for accuracy.
    00315         static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
    00316         static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
    00317         inline static int ToLower( int v, TiXmlEncoding encoding )
    00318         {
    00319                 if ( encoding == TIXML_ENCODING_UTF8 )
    00320                 {
    00321                         if ( v < 128 ) return tolower( v );
    00322                         return v;
    00323                 }
    00324                 else
    00325                 {
    00326                         return tolower( v );
    00327                 }
    00328         }
    00329         static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
    00330
    00331 private:
    00332         TiXmlBase( const TiXmlBase& );                          // not implemented.
    00333         void operator=( const TiXmlBase& base );        // not allowed.
    00334
    00335         struct Entity
    00336         {
    00337                 const char*     str;
    00338                 unsigned int    strLength;
    00339                 char                chr;
    00340         };
    00341         enum
    00342         {
    00343                 NUM_ENTITY = 5,
    00344                 MAX_ENTITY_LENGTH = 6
    00345
    00346         };
    00347         static Entity entity[ NUM_ENTITY ];
    00348         static bool condenseWhiteSpace;
    00349 };
    00350
    00351
    00358 class TiXmlNode : public TiXmlBase
    00359 {
    00360         friend class TiXmlDocument;
    00361         friend class TiXmlElement;
    00362
    00363 public:
    00364         #ifdef TIXML_USE_STL
    00365
    00369             friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
    00370
    00387             friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
    00388
    00390                 friend std::string& operator<< (std::string& out, const TiXmlNode& base );
    00391
    00392         #else
    00393             // Used internally, not part of the public API.
    00394             friend TIXML_OSTREAM& operator<< (TIXML_OSTREAM& out, const TiXmlNode& base);
    00395         #endif
    00396
    00400         enum NodeType
    00401         {
    00402                 DOCUMENT,
    00403                 ELEMENT,
    00404                 COMMENT,
    00405                 UNKNOWN,
    00406                 TEXT,
    00407                 DECLARATION,
    00408                 TYPECOUNT
    00409         };
    00410
    00411         virtual ~TiXmlNode();
    00412
    00425         const char * Value() const { return value.c_str (); }
    00426
    00436         void SetValue(const char * _value) { value = _value;}
    00437
    00438     #ifdef TIXML_USE_STL
    00439
    00440         void SetValue( const std::string& _value )
    00441         {
    00442                 StringToBuffer buf( _value );
    00443                 SetValue( buf.buffer ? buf.buffer : "" );
    00444         }
    00445         #endif
    00446
    00448         void Clear();
    00449
    00451         TiXmlNode* Parent()                                                     { return parent; }
    00452         const TiXmlNode* Parent() const                         { return parent; }
    00453
    00454         const TiXmlNode* FirstChild()   const   { return firstChild; }
    00455         TiXmlNode* FirstChild()                                 { return firstChild; }
    00456         const TiXmlNode* FirstChild( const char * value ) const;
    00457         TiXmlNode* FirstChild( const char * value );
    00458
    00459         const TiXmlNode* LastChild() const      { return lastChild; }
    00460         TiXmlNode* LastChild()  { return lastChild; }
    00461         const TiXmlNode* LastChild( const char * value ) const;
    00462         TiXmlNode* LastChild( const char * value );
    00463
    00464     #ifdef TIXML_USE_STL
    00465         const TiXmlNode* FirstChild( const std::string& _value ) const  {       return FirstChild (_value.c_str ());    }
    00466         TiXmlNode* FirstChild( const std::string& _value )                              {       return FirstChild (_value.c_str ());    }
    00467         const TiXmlNode* LastChild( const std::string& _value ) const   {       return LastChild (_value.c_str ());     }
    00468         TiXmlNode* LastChild( const std::string& _value )                               {       return LastChild (_value.c_str ());     }
    00469         #endif
    00470
    00487         const TiXmlNode* IterateChildren( TiXmlNode* previous ) const;
    00488         TiXmlNode* IterateChildren( TiXmlNode* previous );
    00489
    00491         const TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous ) const;
    00492         TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous );
    00493
    00494     #ifdef TIXML_USE_STL
    00495         const TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) const        {       return IterateChildren (_value.c_str (), previous);     }
    00496         TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) {  return IterateChildren (_value.c_str (), previous);     }
    00497         #endif
    00498
    00502         TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
    00503
    00504
    00514         TiXmlNode* LinkEndChild( TiXmlNode* addThis );
    00515
    00519         TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
    00520
    00524         TiXmlNode* InsertAfterChild(  TiXmlNode* afterThis, const TiXmlNode& addThis );
    00525
    00529         TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
    00530
    00532         bool RemoveChild( TiXmlNode* removeThis );
    00533
    00535         const TiXmlNode* PreviousSibling() const                        { return prev; }
    00536         TiXmlNode* PreviousSibling()                                            { return prev; }
    00537
    00539         const TiXmlNode* PreviousSibling( const char * ) const;
    00540         TiXmlNode* PreviousSibling( const char * );
    00541
    00542     #ifdef TIXML_USE_STL
    00543         const TiXmlNode* PreviousSibling( const std::string& _value ) const     {       return PreviousSibling (_value.c_str ());       }
    00544         TiXmlNode* PreviousSibling( const std::string& _value )                         {       return PreviousSibling (_value.c_str ());       }
    00545         const TiXmlNode* NextSibling( const std::string& _value) const          {       return NextSibling (_value.c_str ());   }
    00546         TiXmlNode* NextSibling( const std::string& _value)                                      {       return NextSibling (_value.c_str ());   }
    00547         #endif
    00548
    00550         const TiXmlNode* NextSibling() const                            { return next; }
    00551         TiXmlNode* NextSibling()                                                        { return next; }
    00552
    00554         const TiXmlNode* NextSibling( const char * ) const;
    00555         TiXmlNode* NextSibling( const char * );
    00556
    00561         const TiXmlElement* NextSiblingElement() const;
    00562         TiXmlElement* NextSiblingElement();
    00563
    00568         const TiXmlElement* NextSiblingElement( const char * ) const;
    00569         TiXmlElement* NextSiblingElement( const char * );
    00570
    00571     #ifdef TIXML_USE_STL
    00572         const TiXmlElement* NextSiblingElement( const std::string& _value) const        {       return NextSiblingElement (_value.c_str ());    }
    00573         TiXmlElement* NextSiblingElement( const std::string& _value)                            {       return NextSiblingElement (_value.c_str ());    }
    00574         #endif
    00575
    00577         const TiXmlElement* FirstChildElement() const;
    00578         TiXmlElement* FirstChildElement();
    00579
    00581         const TiXmlElement* FirstChildElement( const char * value ) const;
    00582         TiXmlElement* FirstChildElement( const char * value );
    00583
    00584     #ifdef TIXML_USE_STL
    00585         const TiXmlElement* FirstChildElement( const std::string& _value ) const        {       return FirstChildElement (_value.c_str ());     }
    00586         TiXmlElement* FirstChildElement( const std::string& _value )                            {       return FirstChildElement (_value.c_str ());     }
    00587         #endif
    00588
    00593         virtual int Type() const        { return type; }
    00594
    00598         const TiXmlDocument* GetDocument() const;
    00599         TiXmlDocument* GetDocument();
    00600
    00602         bool NoChildren() const                                         { return !firstChild; }
    00603
    00604         const TiXmlDocument* ToDocument()       const           { return ( this && type == DOCUMENT ) ? (const TiXmlDocument*) this : 0; }
    00605         const TiXmlElement*  ToElement() const                  { return ( this && type == ELEMENT  ) ? (const TiXmlElement*)  this : 0; }
    00606         const TiXmlComment*  ToComment() const                  { return ( this && type == COMMENT  ) ? (const TiXmlComment*)  this : 0; }
    00607         const TiXmlUnknown*  ToUnknown() const                  { return ( this && type == UNKNOWN  ) ? (const TiXmlUnknown*)  this : 0; }
    00608         const TiXmlText*           ToText()    const            { return ( this && type == TEXT     ) ? (const TiXmlText*)     this : 0; }
    00609         const TiXmlDeclaration* ToDeclaration() const   { return ( this && type == DECLARATION ) ? (const TiXmlDeclaration*) this : 0; }
    00610
    00611         TiXmlDocument* ToDocument()                     { return ( this && type == DOCUMENT ) ? (TiXmlDocument*) this : 0; }
    00612         TiXmlElement*  ToElement()                      { return ( this && type == ELEMENT  ) ? (TiXmlElement*)  this : 0; }
    00613         TiXmlComment*  ToComment()                      { return ( this && type == COMMENT  ) ? (TiXmlComment*)  this : 0; }
    00614         TiXmlUnknown*  ToUnknown()                      { return ( this && type == UNKNOWN  ) ? (TiXmlUnknown*)  this : 0; }
    00615         TiXmlText*         ToText()                     { return ( this && type == TEXT     ) ? (TiXmlText*)     this : 0; }
    00616         TiXmlDeclaration* ToDeclaration()       { return ( this && type == DECLARATION ) ? (TiXmlDeclaration*) this : 0; }
    00617
    00621         virtual TiXmlNode* Clone() const = 0;
    00622
    00623 protected:
    00624         TiXmlNode( NodeType _type );
    00625
    00626         // Copy to the allocated object. Shared functionality between Clone, Copy constructor,
    00627         // and the assignment operator.
    00628         void CopyTo( TiXmlNode* target ) const;
    00629
    00630         #ifdef TIXML_USE_STL
    00631             // The real work of the input operator.
    00632             virtual void StreamIn( TIXML_ISTREAM* in, TIXML_STRING* tag ) = 0;
    00633         #endif
    00634
    00635         // Figure out what is at *p, and parse it. Returns null if it is not an xml node.
    00636         TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );
    00637
    00638         // Internal Value function returning a TIXML_STRING
    00639         const TIXML_STRING& SValue() const      { return value ; }
    00640
    00641         TiXmlNode*              parent;
    00642         NodeType                type;
    00643
    00644         TiXmlNode*              firstChild;
    00645         TiXmlNode*              lastChild;
    00646
    00647         TIXML_STRING    value;
    00648
    00649         TiXmlNode*              prev;
    00650         TiXmlNode*              next;
    00651
    00652 private:
    00653         TiXmlNode( const TiXmlNode& );                          // not implemented.
    00654         void operator=( const TiXmlNode& base );        // not allowed.
    00655 };
    00656
    00657
    00665 class TiXmlAttribute : public TiXmlBase
    00666 {
    00667         friend class TiXmlAttributeSet;
    00668
    00669 public:
    00671         TiXmlAttribute() : TiXmlBase()
    00672         {
    00673                 document = 0;
    00674                 prev = next = 0;
    00675         }
    00676
    00677         #ifdef TIXML_USE_STL
    00678
    00679         TiXmlAttribute( const std::string& _name, const std::string& _value )
    00680         {
    00681                 name = _name;
    00682                 value = _value;
    00683                 document = 0;
    00684                 prev = next = 0;
    00685         }
    00686         #endif
    00687
    00689         TiXmlAttribute( const char * _name, const char * _value )
    00690         {
    00691                 name = _name;
    00692                 value = _value;
    00693                 document = 0;
    00694                 prev = next = 0;
    00695         }
    00696
    00697         const char*             Name()  const           { return name.c_str (); }
    00698         const char*             Value() const           { return value.c_str (); }
    00699         const int       IntValue() const;
    00700         const double    DoubleValue() const;
    00701
    00711         int QueryIntValue( int* value ) const;
    00713         int QueryDoubleValue( double* value ) const;
    00714
    00715         void SetName( const char* _name )       { name = _name; }
    00716         void SetValue( const char* _value )     { value = _value; }
    00717
    00718         void SetIntValue( int value );
    00719         void SetDoubleValue( double value );
    00720
    00721     #ifdef TIXML_USE_STL
    00722
    00723         void SetName( const std::string& _name )
    00724         {
    00725                 StringToBuffer buf( _name );
    00726                 SetName ( buf.buffer ? buf.buffer : "error" );
    00727         }
    00729         void SetValue( const std::string& _value )
    00730         {
    00731                 StringToBuffer buf( _value );
    00732                 SetValue( buf.buffer ? buf.buffer : "error" );
    00733         }
    00734         #endif
    00735
    00737         const TiXmlAttribute* Next() const;
    00738         TiXmlAttribute* Next();
    00740         const TiXmlAttribute* Previous() const;
    00741         TiXmlAttribute* Previous();
    00742
    00743         bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
    00744         bool operator<( const TiXmlAttribute& rhs )      const { return name < rhs.name; }
    00745         bool operator>( const TiXmlAttribute& rhs )  const { return name > rhs.name; }
    00746
    00747         /*      Attribute parsing starts: first letter of the name
    00748                                                  returns: the next char after the value end quote
    00749         */
    00750         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    00751
    00752         // Prints this Attribute to a FILE stream.
    00753         virtual void Print( FILE* cfile, int depth ) const;
    00754
    00755         virtual void StreamOut( TIXML_OSTREAM * out ) const;
    00756         // [internal use]
    00757         // Set the document pointer so the attribute can report errors.
    00758         void SetDocument( TiXmlDocument* doc )  { document = doc; }
    00759
    00760 private:
    00761         TiXmlAttribute( const TiXmlAttribute& );                                // not implemented.
    00762         void operator=( const TiXmlAttribute& base );   // not allowed.
    00763
    00764         TiXmlDocument*  document;       // A pointer back to a document, for error reporting.
    00765         TIXML_STRING name;
    00766         TIXML_STRING value;
    00767         TiXmlAttribute* prev;
    00768         TiXmlAttribute* next;
    00769 };
    00770
    00771
    00772 /*      A class used to manage a group of attributes.
    00773         It is only used internally, both by the ELEMENT and the DECLARATION.
    00774
    00775         The set can be changed transparent to the Element and Declaration
    00776         classes that use it, but NOT transparent to the Attribute
    00777         which has to implement a next() and previous() method. Which makes
    00778         it a bit problematic and prevents the use of STL.
    00779
    00780         This version is implemented with circular lists because:
    00781                 - I like circular lists
    00782                 - it demonstrates some independence from the (typical) doubly linked list.
    00783 */
    00784 class TiXmlAttributeSet
    00785 {
    00786 public:
    00787         TiXmlAttributeSet();
    00788         ~TiXmlAttributeSet();
    00789
    00790         void Add( TiXmlAttribute* attribute );
    00791         void Remove( TiXmlAttribute* attribute );
    00792
    00793         const TiXmlAttribute* First()   const   { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
    00794         TiXmlAttribute* First()                                 { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
    00795         const TiXmlAttribute* Last() const              { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
    00796         TiXmlAttribute* Last()                                  { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
    00797
    00798         const TiXmlAttribute*   Find( const char * name ) const;
    00799         TiXmlAttribute* Find( const char * name );
    00800
    00801 private:
    00802         //*ME:  Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
    00803         //*ME:  this class must be also use a hidden/disabled copy-constructor !!!
    00804         TiXmlAttributeSet( const TiXmlAttributeSet& );  // not allowed
    00805         void operator=( const TiXmlAttributeSet& );     // not allowed (as TiXmlAttribute)
    00806
    00807         TiXmlAttribute sentinel;
    00808 };
    00809
    00810
    00815 class TiXmlElement : public TiXmlNode
    00816 {
    00817 public:
    00819         TiXmlElement (const char * in_value);
    00820
    00821         #ifdef TIXML_USE_STL
    00822
    00823         TiXmlElement( const std::string& _value );
    00824         #endif
    00825
    00826         TiXmlElement( const TiXmlElement& );
    00827
    00828         void operator=( const TiXmlElement& base );
    00829
    00830         virtual ~TiXmlElement();
    00831
    00835         const char* Attribute( const char* name ) const;
    00836
    00843         const char* Attribute( const char* name, int* i ) const;
    00844
    00851         const char* Attribute( const char* name, double* d ) const;
    00852
    00860         int QueryIntAttribute( const char* name, int* value ) const;
    00862         int QueryDoubleAttribute( const char* name, double* value ) const;
    00864         int QueryDoubleAttribute( const char* name, float* value ) const {
    00865                 double d;
    00866                 int result = QueryDoubleAttribute( name, &d );
    00867                 *value = (float)d;
    00868                 return result;
    00869         }
    00870
    00874         void SetAttribute( const char* name, const char * value );
    00875
    00876     #ifdef TIXML_USE_STL
    00877         const char* Attribute( const std::string& name ) const                          { return Attribute( name.c_str() ); }
    00878         const char* Attribute( const std::string& name, int* i ) const          { return Attribute( name.c_str(), i ); }
    00879         const char* Attribute( const std::string& name, double* d ) const       { return Attribute( name.c_str(), d ); }
    00880         int QueryIntAttribute( const std::string& name, int* value ) const      { return QueryIntAttribute( name.c_str(), value ); }
    00881         int QueryDoubleAttribute( const std::string& name, double* value ) const { return QueryDoubleAttribute( name.c_str(), value ); }
    00882
    00884         void SetAttribute( const std::string& name, const std::string& _value )
    00885         {
    00886                 StringToBuffer n( name );
    00887                 StringToBuffer v( _value );
    00888                 if ( n.buffer && v.buffer )
    00889                         SetAttribute (n.buffer, v.buffer );
    00890         }
    00892         void SetAttribute( const std::string& name, int _value )
    00893         {
    00894                 StringToBuffer n( name );
    00895                 if ( n.buffer )
    00896                         SetAttribute (n.buffer, _value);
    00897         }
    00898         #endif
    00899
    00903         void SetAttribute( const char * name, int value );
    00904
    00908         void SetDoubleAttribute( const char * name, double value );
    00909
    00912         void RemoveAttribute( const char * name );
    00913     #ifdef TIXML_USE_STL
    00914         void RemoveAttribute( const std::string& name ) {       RemoveAttribute (name.c_str ());        }
    00915         #endif
    00916
    00917         const TiXmlAttribute* FirstAttribute() const    { return attributeSet.First(); }
    00918         TiXmlAttribute* FirstAttribute()                                { return attributeSet.First(); }
    00919         const TiXmlAttribute* LastAttribute()   const   { return attributeSet.Last(); }
    00920         TiXmlAttribute* LastAttribute()                                 { return attributeSet.Last(); }
    00921
    00923         virtual TiXmlNode* Clone() const;
    00924         // Print the Element to a FILE stream.
    00925         virtual void Print( FILE* cfile, int depth ) const;
    00926
    00927         /*      Attribtue parsing starts: next char past '<'
    00928                                                  returns: next char past '>'
    00929         */
    00930         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    00931
    00932 protected:
    00933
    00934         void CopyTo( TiXmlElement* target ) const;
    00935         void ClearThis();       // like clear, but initializes 'this' object as well
    00936
    00937         // Used to be public [internal use]
    00938         #ifdef TIXML_USE_STL
    00939             virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    00940         #endif
    00941         virtual void StreamOut( TIXML_OSTREAM * out ) const;
    00942
    00943         /*      [internal use]
    00944                 Reads the "value" of the element -- another element, or text.
    00945                 This should terminate with the current end tag.
    00946         */
    00947         const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
    00948
    00949 private:
    00950
    00951         TiXmlAttributeSet attributeSet;
    00952 };
    00953
    00954
    00957 class TiXmlComment : public TiXmlNode
    00958 {
    00959 public:
    00961         TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
    00962         TiXmlComment( const TiXmlComment& );
    00963         void operator=( const TiXmlComment& base );
    00964
    00965         virtual ~TiXmlComment() {}
    00966
    00968         virtual TiXmlNode* Clone() const;
    00970         virtual void Print( FILE* cfile, int depth ) const;
    00971
    00972         /*      Attribtue parsing starts: at the ! of the !--
    00973                                                  returns: next char past '>'
    00974         */
    00975         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    00976
    00977 protected:
    00978         void CopyTo( TiXmlComment* target ) const;
    00979
    00980         // used to be public
    00981         #ifdef TIXML_USE_STL
    00982             virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    00983         #endif
    00984         virtual void StreamOut( TIXML_OSTREAM * out ) const;
    00985
    00986 private:
    00987
    00988 };
    00989
    00990
    00993 class TiXmlText : public TiXmlNode
    00994 {
    00995         friend class TiXmlElement;
    00996 public:
    00998         TiXmlText (const char * initValue) : TiXmlNode (TiXmlNode::TEXT)
    00999         {
    01000                 SetValue( initValue );
    01001         }
    01002         virtual ~TiXmlText() {}
    01003
    01004         #ifdef TIXML_USE_STL
    01005
    01006         TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
    01007         {
    01008                 SetValue( initValue );
    01009         }
    01010         #endif
    01011
    01012         TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT )       { copy.CopyTo( this ); }
    01013         void operator=( const TiXmlText& base )                                                         { base.CopyTo( this ); }
    01014
    01016         virtual void Print( FILE* cfile, int depth ) const;
    01017
    01018         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    01019
    01020 protected :
    01022         virtual TiXmlNode* Clone() const;
    01023         void CopyTo( TiXmlText* target ) const;
    01024
    01025         virtual void StreamOut ( TIXML_OSTREAM * out ) const;
    01026         bool Blank() const;     // returns true if all white space and new lines
    01027         // [internal use]
    01028         #ifdef TIXML_USE_STL
    01029             virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01030         #endif
    01031
    01032 private:
    01033 };
    01034
    01035
    01049 class TiXmlDeclaration : public TiXmlNode
    01050 {
    01051 public:
    01053         TiXmlDeclaration()   : TiXmlNode( TiXmlNode::DECLARATION ) {}
    01054
    01055 #ifdef TIXML_USE_STL
    01056
    01057         TiXmlDeclaration(       const std::string& _version,
    01058                                                 const std::string& _encoding,
    01059                                                 const std::string& _standalone );
    01060 #endif
    01061
    01063         TiXmlDeclaration(       const char* _version,
    01064                                                 const char* _encoding,
    01065                                                 const char* _standalone );
    01066
    01067         TiXmlDeclaration( const TiXmlDeclaration& copy );
    01068         void operator=( const TiXmlDeclaration& copy );
    01069
    01070         virtual ~TiXmlDeclaration()     {}
    01071
    01073         const char *Version() const                     { return version.c_str (); }
    01075         const char *Encoding() const            { return encoding.c_str (); }
    01077         const char *Standalone() const          { return standalone.c_str (); }
    01078
    01080         virtual TiXmlNode* Clone() const;
    01082         virtual void Print( FILE* cfile, int depth ) const;
    01083
    01084         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    01085
    01086 protected:
    01087         void CopyTo( TiXmlDeclaration* target ) const;
    01088         // used to be public
    01089         #ifdef TIXML_USE_STL
    01090             virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01091         #endif
    01092         virtual void StreamOut ( TIXML_OSTREAM * out) const;
    01093
    01094 private:
    01095
    01096         TIXML_STRING version;
    01097         TIXML_STRING encoding;
    01098         TIXML_STRING standalone;
    01099 };
    01100
    01101
    01109 class TiXmlUnknown : public TiXmlNode
    01110 {
    01111 public:
    01112         TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN )        {}
    01113         virtual ~TiXmlUnknown() {}
    01114
    01115         TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN )              { copy.CopyTo( this ); }
    01116         void operator=( const TiXmlUnknown& copy )                                                                              { copy.CopyTo( this ); }
    01117
    01119         virtual TiXmlNode* Clone() const;
    01121         virtual void Print( FILE* cfile, int depth ) const;
    01122
    01123         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
    01124
    01125 protected:
    01126         void CopyTo( TiXmlUnknown* target ) const;
    01127
    01128         #ifdef TIXML_USE_STL
    01129             virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01130         #endif
    01131         virtual void StreamOut ( TIXML_OSTREAM * out ) const;
    01132
    01133 private:
    01134
    01135 };
    01136
    01137
    01142 class TiXmlDocument : public TiXmlNode
    01143 {
    01144 public:
    01146         TiXmlDocument();
    01148         TiXmlDocument( const char * documentName );
    01149
    01150         #ifdef TIXML_USE_STL
    01151
    01152         TiXmlDocument( const std::string& documentName );
    01153         #endif
    01154
    01155         TiXmlDocument( const TiXmlDocument& copy );
    01156         void operator=( const TiXmlDocument& copy );
    01157
    01158         virtual ~TiXmlDocument() {}
    01159
    01164         bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
    01166         bool SaveFile() const;
    01168         bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
    01170         bool SaveFile( const char * filename ) const;
    01171
    01172         #ifdef TIXML_USE_STL
    01173         bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )
    01174         {
    01175                 StringToBuffer f( filename );
    01176                 return ( f.buffer && LoadFile( f.buffer, encoding ));
    01177         }
    01178         bool SaveFile( const std::string& filename ) const
    01179         {
    01180                 StringToBuffer f( filename );
    01181                 return ( f.buffer && SaveFile( f.buffer ));
    01182         }
    01183         #endif
    01184
    01189         virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
    01190
    01195         const TiXmlElement* RootElement() const         { return FirstChildElement(); }
    01196         TiXmlElement* RootElement()                                     { return FirstChildElement(); }
    01197
    01203         bool Error() const                                              { return error; }
    01204
    01206         const char * ErrorDesc() const  { return errorDesc.c_str (); }
    01207
    01211         const int ErrorId()     const                           { return errorId; }
    01212
    01220         int ErrorRow()  { return errorLocation.row+1; }
    01221         int ErrorCol()  { return errorLocation.col+1; }
    01222
    01243         void SetTabSize( int _tabsize )         { tabsize = _tabsize; }
    01244
    01245         int TabSize() const     { return tabsize; }
    01246
    01250         void ClearError()                                               {       error = false;
    01251                                                                                                 errorId = 0;
    01252                                                                                                 errorDesc = "";
    01253                                                                                                 errorLocation.row = errorLocation.col = 0;
    01254                                                                                                 //errorLocation.last = 0;
    01255                                                                                         }
    01256
    01258         void Print() const                                              { Print( stdout, 0 ); }
    01259
    01261         virtual void Print( FILE* cfile, int depth = 0 ) const;
    01262         // [internal use]
    01263         void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
    01264
    01265 protected :
    01266         virtual void StreamOut ( TIXML_OSTREAM * out) const;
    01267         // [internal use]
    01268         virtual TiXmlNode* Clone() const;
    01269         #ifdef TIXML_USE_STL
    01270             virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
    01271         #endif
    01272
    01273 private:
    01274         void CopyTo( TiXmlDocument* target ) const;
    01275
    01276         bool error;
    01277         int  errorId;
    01278         TIXML_STRING errorDesc;
    01279         int tabsize;
    01280         TiXmlCursor errorLocation;
    01281 };
    01282
    01283
    01364 class TiXmlHandle
    01365 {
    01366 public:
    01368         TiXmlHandle( TiXmlNode* node )                                  { this->node = node; }
    01370         TiXmlHandle( const TiXmlHandle& ref )                   { this->node = ref.node; }
    01371         TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
    01372
    01374         TiXmlHandle FirstChild() const;
    01376         TiXmlHandle FirstChild( const char * value ) const;
    01378         TiXmlHandle FirstChildElement() const;
    01380         TiXmlHandle FirstChildElement( const char * value ) const;
    01381
    01385         TiXmlHandle Child( const char* value, int index ) const;
    01389         TiXmlHandle Child( int index ) const;
    01394         TiXmlHandle ChildElement( const char* value, int index ) const;
    01399         TiXmlHandle ChildElement( int index ) const;
    01400
    01401         #ifdef TIXML_USE_STL
    01402         TiXmlHandle FirstChild( const std::string& _value ) const                               { return FirstChild( _value.c_str() ); }
    01403         TiXmlHandle FirstChildElement( const std::string& _value ) const                { return FirstChildElement( _value.c_str() ); }
    01404
    01405         TiXmlHandle Child( const std::string& _value, int index ) const                 { return Child( _value.c_str(), index ); }
    01406         TiXmlHandle ChildElement( const std::string& _value, int index ) const  { return ChildElement( _value.c_str(), index ); }
    01407         #endif
    01408
    01410         TiXmlNode* Node() const                 { return node; }
    01412         TiXmlElement* Element() const   { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
    01414         TiXmlText* Text() const                 { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
    01416         TiXmlUnknown* Unknown() const                   { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
    01417
    01418 private:
    01419         TiXmlNode* node;
    01420 };
    01421
    01422
    01423 #endif
    01424