osgEarth 2.1.1

/home/cube/sources/osgearth/src/osgEarth/tinyxml.h

Go to the documentation of this file.
00001 /*
00002 www.sourceforge.net/projects/tinyxml
00003 Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
00004 
00005 This software is provided 'as-is', without any express or implied
00006 warranty. In no event will the authors be held liable for any
00007 damages arising from the use of this software.
00008 
00009 Permission is granted to anyone to use this software for any
00010 purpose, including commercial applications, and to alter it and
00011 redistribute it freely, subject to the following restrictions:
00012 
00013 1. The origin of this software must not be misrepresented; you must
00014 not claim that you wrote the original software. If you use this
00015 software in a product, an acknowledgment in the product documentation
00016 would be appreciated but is not required.
00017 
00018 2. Altered source versions must be plainly marked as such, and
00019 must not be misrepresented as being the original software.
00020 
00021 3. This notice may not be removed or altered from any source
00022 distribution.
00023 */
00024 
00025 
00026 #ifndef TINYXML_INCLUDED
00027 #define TINYXML_INCLUDED
00028 
00029 #ifdef _MSC_VER
00030 #pragma warning( push )
00031 #pragma warning( disable : 4530 )
00032 #pragma warning( disable : 4786 )
00033 #endif
00034 
00035 #include <ctype.h>
00036 #include <stdio.h>
00037 #include <stdlib.h>
00038 #include <string.h>
00039 #include <assert.h>
00040 
00041 // Help out windows:
00042 #if defined( _DEBUG ) && !defined( DEBUG )
00043 #define DEBUG
00044 #endif
00045 
00046 #ifdef TIXML_USE_STL
00047         #include <string>
00048         #include <iostream>
00049         #include <sstream>
00050         #define TIXML_STRING            std::string
00051 #else
00052         #include "tinystr.h"
00053         #define TIXML_STRING            TiXmlString
00054 #endif
00055 
00056 // Deprecated library function hell. Compilers want to use the
00057 // new safe versions. This probably doesn't fully address the problem,
00058 // but it gets closer. There are too many compilers for me to fully
00059 // test. If you get compilation troubles, undefine TIXML_SAFE
00060 #define TIXML_SAFE
00061 
00062 #ifdef TIXML_SAFE
00063         #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
00064                 // Microsoft visual studio, version 2005 and higher.
00065                 #define TIXML_SNPRINTF _snprintf_s
00066                 #define TIXML_SSCANF   sscanf_s
00067         #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
00068                 // Microsoft visual studio, version 6 and higher.
00069                 //#pragma message( "Using _sn* functions." )
00070                 #define TIXML_SNPRINTF _snprintf
00071                 #define TIXML_SSCANF   sscanf
00072         #elif defined(__GNUC__) && (__GNUC__ >= 3 )
00073                 // GCC version 3 and higher.s
00074                 //#warning( "Using sn* functions." )
00075                 #define TIXML_SNPRINTF snprintf
00076                 #define TIXML_SSCANF   sscanf
00077         #else
00078                 #define TIXML_SNPRINTF snprintf
00079                 #define TIXML_SSCANF   sscanf
00080         #endif
00081 #endif  
00082 
00083 class TiXmlDocument;
00084 class TiXmlElement;
00085 class TiXmlComment;
00086 class TiXmlUnknown;
00087 class TiXmlAttribute;
00088 class TiXmlText;
00089 class TiXmlDeclaration;
00090 class TiXmlParsingData;
00091 
00092 const int TIXML_MAJOR_VERSION = 2;
00093 const int TIXML_MINOR_VERSION = 6;
00094 const int TIXML_PATCH_VERSION = 1;
00095 
00096 /*      Internal structure for tracking location of items 
00097         in the XML file.
00098 */
00099 struct TiXmlCursor
00100 {
00101         TiXmlCursor()           { Clear(); }
00102         void Clear()            { row = col = -1; }
00103 
00104         int row;        // 0 based.
00105         int col;        // 0 based.
00106 };
00107 
00108 
00128 class TiXmlVisitor
00129 {
00130 public:
00131         virtual ~TiXmlVisitor() {}
00132 
00134         virtual bool VisitEnter( const TiXmlDocument& /*doc*/ )                 { return true; }
00136         virtual bool VisitExit( const TiXmlDocument& /*doc*/ )                  { return true; }
00137 
00139         virtual bool VisitEnter( const TiXmlElement& /*element*/, const TiXmlAttribute* /*firstAttribute*/ )    { return true; }
00141         virtual bool VisitExit( const TiXmlElement& /*element*/ )               { return true; }
00142 
00144         virtual bool Visit( const TiXmlDeclaration& /*declaration*/ )   { return true; }
00146         virtual bool Visit( const TiXmlText& /*text*/ )                                 { return true; }
00148         virtual bool Visit( const TiXmlComment& /*comment*/ )                   { return true; }
00150         virtual bool Visit( const TiXmlUnknown& /*unknown*/ )                   { return true; }
00151 };
00152 
00153 // Only used by Attribute::Query functions
00154 enum 
00155 { 
00156         TIXML_SUCCESS,
00157         TIXML_NO_ATTRIBUTE,
00158         TIXML_WRONG_TYPE
00159 };
00160 
00161 
00162 // Used by the parsing routines.
00163 enum TiXmlEncoding
00164 {
00165         TIXML_ENCODING_UNKNOWN,
00166         TIXML_ENCODING_UTF8,
00167         TIXML_ENCODING_LEGACY
00168 };
00169 
00170 const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
00171 
00194 class TiXmlBase
00195 {
00196         friend class TiXmlNode;
00197         friend class TiXmlElement;
00198         friend class TiXmlDocument;
00199 
00200 public:
00201         TiXmlBase()     :       userData(0)             {}
00202         virtual ~TiXmlBase()                    {}
00203 
00213         virtual void Print( FILE* cfile, int depth ) const = 0;
00214 
00221         static void SetCondenseWhiteSpace( bool condense )              { condenseWhiteSpace = condense; }
00222 
00224         static bool IsWhiteSpaceCondensed()                                             { return condenseWhiteSpace; }
00225 
00244         int Row() const                 { return location.row + 1; }
00245         int Column() const              { return location.col + 1; }    
00246 
00247         void  SetUserData( void* user )                 { userData = user; }    
00248         void* GetUserData()                                             { return userData; }    
00249         const void* GetUserData() const                 { return userData; }    
00250 
00251         // Table that returs, for a given lead byte, the total number of bytes
00252         // in the UTF-8 sequence.
00253         static const int utf8ByteTable[256];
00254 
00255         virtual const char* Parse(      const char* p, 
00256                                                                 TiXmlParsingData* data, 
00257                                                                 TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
00258 
00262         static void EncodeString( const TIXML_STRING& str, TIXML_STRING* out );
00263 
00264         enum
00265         {
00266                 TIXML_NO_ERROR = 0,
00267                 TIXML_ERROR,
00268                 TIXML_ERROR_OPENING_FILE,
00269                 TIXML_ERROR_PARSING_ELEMENT,
00270                 TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
00271                 TIXML_ERROR_READING_ELEMENT_VALUE,
00272                 TIXML_ERROR_READING_ATTRIBUTES,
00273                 TIXML_ERROR_PARSING_EMPTY,
00274                 TIXML_ERROR_READING_END_TAG,
00275                 TIXML_ERROR_PARSING_UNKNOWN,
00276                 TIXML_ERROR_PARSING_COMMENT,
00277                 TIXML_ERROR_PARSING_DECLARATION,
00278                 TIXML_ERROR_DOCUMENT_EMPTY,
00279                 TIXML_ERROR_EMBEDDED_NULL,
00280                 TIXML_ERROR_PARSING_CDATA,
00281                 TIXML_ERROR_DOCUMENT_TOP_ONLY,
00282 
00283                 TIXML_ERROR_STRING_COUNT
00284         };
00285 
00286 protected:
00287 
00288         static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding );
00289 
00290         inline static bool IsWhiteSpace( char c )               
00291         { 
00292                 return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); 
00293         }
00294         inline static bool IsWhiteSpace( int c )
00295         {
00296                 if ( c < 256 )
00297                         return IsWhiteSpace( (char) c );
00298                 return false;   // Again, only truly correct for English/Latin...but usually works.
00299         }
00300 
00301         #ifdef TIXML_USE_STL
00302         static bool     StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );
00303         static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag );
00304         #endif
00305 
00306         /*      Reads an XML name into the string provided. Returns
00307                 a pointer just past the last character of the name,
00308                 or 0 if the function has an error.
00309         */
00310         static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );
00311 
00312         /*      Reads text. Returns a pointer past the given end tag.
00313                 Wickedly complex options, but it keeps the (sensitive) code in one place.
00314         */
00315         static const char* ReadText(    const char* in,                         // where to start
00316                                                                         TIXML_STRING* text,                     // the string read
00317                                                                         bool ignoreWhiteSpace,          // whether to keep the white space
00318                                                                         const char* endTag,                     // what ends this text
00319                                                                         bool ignoreCase,                        // whether to ignore case in the end tag
00320                                                                         TiXmlEncoding encoding );       // the current encoding
00321 
00322         // If an entity has been found, transform it into a character.
00323         static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding );
00324 
00325         // Get a character, while interpreting entities.
00326         // The length can be from 0 to 4 bytes.
00327         inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
00328         {
00329                 assert( p );
00330                 if ( encoding == TIXML_ENCODING_UTF8 )
00331                 {
00332                         *length = utf8ByteTable[ *((const unsigned char*)p) ];
00333                         assert( *length >= 0 && *length < 5 );
00334                 }
00335                 else
00336                 {
00337                         *length = 1;
00338                 }
00339 
00340                 if ( *length == 1 )
00341                 {
00342                         if ( *p == '&' )
00343                                 return GetEntity( p, _value, length, encoding );
00344                         *_value = *p;
00345                         return p+1;
00346                 }
00347                 else if ( *length )
00348                 {
00349                         //strncpy( _value, p, *length );        // lots of compilers don't like this function (unsafe),
00350                                                                                                 // and the null terminator isn't needed
00351                         for( int i=0; p[i] && i<*length; ++i ) {
00352                                 _value[i] = p[i];
00353                         }
00354                         return p + (*length);
00355                 }
00356                 else
00357                 {
00358                         // Not valid text.
00359                         return 0;
00360                 }
00361         }
00362 
00363         // Return true if the next characters in the stream are any of the endTag sequences.
00364         // Ignore case only works for english, and should only be relied on when comparing
00365         // to English words: StringEqual( p, "version", true ) is fine.
00366         static bool StringEqual(        const char* p,
00367                                                                 const char* endTag,
00368                                                                 bool ignoreCase,
00369                                                                 TiXmlEncoding encoding );
00370 
00371         static const char* errorString[ TIXML_ERROR_STRING_COUNT ];
00372 
00373         TiXmlCursor location;
00374 
00376         void*                   userData;
00377         
00378         // None of these methods are reliable for any language except English.
00379         // Good for approximation, not great for accuracy.
00380         static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
00381         static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
00382         inline static int ToLower( int v, TiXmlEncoding encoding )
00383         {
00384                 if ( encoding == TIXML_ENCODING_UTF8 )
00385                 {
00386                         if ( v < 128 ) return tolower( v );
00387                         return v;
00388                 }
00389                 else
00390                 {
00391                         return tolower( v );
00392                 }
00393         }
00394         static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
00395 
00396 private:
00397         TiXmlBase( const TiXmlBase& );                          // not implemented.
00398         void operator=( const TiXmlBase& base );        // not allowed.
00399 
00400         struct Entity
00401         {
00402                 const char*     str;
00403                 unsigned int    strLength;
00404                 char                chr;
00405         };
00406         enum
00407         {
00408                 NUM_ENTITY = 5,
00409                 MAX_ENTITY_LENGTH = 6
00410 
00411         };
00412         static Entity entity[ NUM_ENTITY ];
00413         static bool condenseWhiteSpace;
00414 };
00415 
00416 
00423 class TiXmlNode : public TiXmlBase
00424 {
00425         friend class TiXmlDocument;
00426         friend class TiXmlElement;
00427 
00428 public:
00429         #ifdef TIXML_USE_STL    
00430 
00434             friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
00435 
00452             friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
00453 
00455                 friend std::string& operator<< (std::string& out, const TiXmlNode& base );
00456 
00457         #endif
00458 
00462         enum NodeType
00463         {
00464                 TINYXML_DOCUMENT,
00465                 TINYXML_ELEMENT,
00466                 TINYXML_COMMENT,
00467                 TINYXML_UNKNOWN,
00468                 TINYXML_TEXT,
00469                 TINYXML_DECLARATION,
00470                 TINYXML_TYPECOUNT
00471         };
00472 
00473         virtual ~TiXmlNode();
00474 
00487         const char *Value() const { return value.c_str (); }
00488 
00489     #ifdef TIXML_USE_STL
00490 
00494         const std::string& ValueStr() const { return value; }
00495         #endif
00496 
00497         const TIXML_STRING& ValueTStr() const { return value; }
00498 
00508         void SetValue(const char * _value) { value = _value;}
00509 
00510     #ifdef TIXML_USE_STL
00511 
00512         void SetValue( const std::string& _value )      { value = _value; }
00513         #endif
00514 
00516         void Clear();
00517 
00519         TiXmlNode* Parent()                                                     { return parent; }
00520         const TiXmlNode* Parent() const                         { return parent; }
00521 
00522         const TiXmlNode* FirstChild()   const           { return firstChild; }  
00523         TiXmlNode* FirstChild()                                         { return firstChild; }
00524         const TiXmlNode* FirstChild( const char * value ) const;                        
00525 
00526         TiXmlNode* FirstChild( const char * _value ) {
00527                 // Call through to the const version - safe since nothing is changed. Exiting syntax: cast this to a const (always safe)
00528                 // call the method, cast the return back to non-const.
00529                 return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild( _value ));
00530         }
00531         const TiXmlNode* LastChild() const      { return lastChild; }           
00532         TiXmlNode* LastChild()  { return lastChild; }
00533         
00534         const TiXmlNode* LastChild( const char * value ) const;                 
00535         TiXmlNode* LastChild( const char * _value ) {
00536                 return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild( _value ));
00537         }
00538 
00539     #ifdef TIXML_USE_STL
00540         const TiXmlNode* FirstChild( const std::string& _value ) const  {       return FirstChild (_value.c_str ());    }       
00541         TiXmlNode* FirstChild( const std::string& _value )                              {       return FirstChild (_value.c_str ());    }       
00542         const TiXmlNode* LastChild( const std::string& _value ) const   {       return LastChild (_value.c_str ());     }       
00543         TiXmlNode* LastChild( const std::string& _value )                               {       return LastChild (_value.c_str ());     }       
00544         #endif
00545 
00562         const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
00563         TiXmlNode* IterateChildren( const TiXmlNode* previous ) {
00564                 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( previous ) );
00565         }
00566 
00568         const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
00569         TiXmlNode* IterateChildren( const char * _value, const TiXmlNode* previous ) {
00570                 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( _value, previous ) );
00571         }
00572 
00573     #ifdef TIXML_USE_STL
00574         const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const  {       return IterateChildren (_value.c_str (), previous);     }       
00575         TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) {    return IterateChildren (_value.c_str (), previous);     }       
00576         #endif
00577 
00581         TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
00582 
00583 
00593         TiXmlNode* LinkEndChild( TiXmlNode* addThis );
00594 
00598         TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
00599 
00603         TiXmlNode* InsertAfterChild(  TiXmlNode* afterThis, const TiXmlNode& addThis );
00604 
00608         TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
00609 
00611         bool RemoveChild( TiXmlNode* removeThis );
00612 
00614         const TiXmlNode* PreviousSibling() const                        { return prev; }
00615         TiXmlNode* PreviousSibling()                                            { return prev; }
00616 
00618         const TiXmlNode* PreviousSibling( const char * ) const;
00619         TiXmlNode* PreviousSibling( const char *_prev ) {
00620                 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->PreviousSibling( _prev ) );
00621         }
00622 
00623     #ifdef TIXML_USE_STL
00624         const TiXmlNode* PreviousSibling( const std::string& _value ) const     {       return PreviousSibling (_value.c_str ());       }       
00625         TiXmlNode* PreviousSibling( const std::string& _value )                         {       return PreviousSibling (_value.c_str ());       }       
00626         const TiXmlNode* NextSibling( const std::string& _value) const          {       return NextSibling (_value.c_str ());   }       
00627         TiXmlNode* NextSibling( const std::string& _value)                                      {       return NextSibling (_value.c_str ());   }       
00628         #endif
00629 
00631         const TiXmlNode* NextSibling() const                            { return next; }
00632         TiXmlNode* NextSibling()                                                        { return next; }
00633 
00635         const TiXmlNode* NextSibling( const char * ) const;
00636         TiXmlNode* NextSibling( const char* _next ) {
00637                 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->NextSibling( _next ) );
00638         }
00639 
00644         const TiXmlElement* NextSiblingElement() const;
00645         TiXmlElement* NextSiblingElement() {
00646                 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() );
00647         }
00648 
00653         const TiXmlElement* NextSiblingElement( const char * ) const;
00654         TiXmlElement* NextSiblingElement( const char *_next ) {
00655                 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement( _next ) );
00656         }
00657 
00658     #ifdef TIXML_USE_STL
00659         const TiXmlElement* NextSiblingElement( const std::string& _value) const        {       return NextSiblingElement (_value.c_str ());    }       
00660         TiXmlElement* NextSiblingElement( const std::string& _value)                            {       return NextSiblingElement (_value.c_str ());    }       
00661         #endif
00662 
00664         const TiXmlElement* FirstChildElement() const;
00665         TiXmlElement* FirstChildElement() {
00666                 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() );
00667         }
00668 
00670         const TiXmlElement* FirstChildElement( const char * _value ) const;
00671         TiXmlElement* FirstChildElement( const char * _value ) {
00672                 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement( _value ) );
00673         }
00674 
00675     #ifdef TIXML_USE_STL
00676         const TiXmlElement* FirstChildElement( const std::string& _value ) const        {       return FirstChildElement (_value.c_str ());     }       
00677         TiXmlElement* FirstChildElement( const std::string& _value )                            {       return FirstChildElement (_value.c_str ());     }       
00678         #endif
00679 
00684         int Type() const        { return type; }
00685 
00689         const TiXmlDocument* GetDocument() const;
00690         TiXmlDocument* GetDocument() {
00691                 return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() );
00692         }
00693 
00695         bool NoChildren() const                                         { return !firstChild; }
00696 
00697         virtual const TiXmlDocument*    ToDocument()    const { return 0; } 
00698         virtual const TiXmlElement*     ToElement()     const { return 0; } 
00699         virtual const TiXmlComment*     ToComment()     const { return 0; } 
00700         virtual const TiXmlUnknown*     ToUnknown()     const { return 0; } 
00701         virtual const TiXmlText*        ToText()        const { return 0; } 
00702         virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } 
00703 
00704         virtual TiXmlDocument*          ToDocument()    { return 0; } 
00705         virtual TiXmlElement*           ToElement()         { return 0; } 
00706         virtual TiXmlComment*           ToComment()     { return 0; } 
00707         virtual TiXmlUnknown*           ToUnknown()         { return 0; } 
00708         virtual TiXmlText*                  ToText()        { return 0; } 
00709         virtual TiXmlDeclaration*       ToDeclaration() { return 0; } 
00710 
00714         virtual TiXmlNode* Clone() const = 0;
00715 
00738         virtual bool Accept( TiXmlVisitor* visitor ) const = 0;
00739 
00740 protected:
00741         TiXmlNode( NodeType _type );
00742 
00743         // Copy to the allocated object. Shared functionality between Clone, Copy constructor,
00744         // and the assignment operator.
00745         void CopyTo( TiXmlNode* target ) const;
00746 
00747         #ifdef TIXML_USE_STL
00748             // The real work of the input operator.
00749         virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;
00750         #endif
00751 
00752         // Figure out what is at *p, and parse it. Returns null if it is not an xml node.
00753         TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );
00754 
00755         TiXmlNode*              parent;
00756         NodeType                type;
00757 
00758         TiXmlNode*              firstChild;
00759         TiXmlNode*              lastChild;
00760 
00761         TIXML_STRING    value;
00762 
00763         TiXmlNode*              prev;
00764         TiXmlNode*              next;
00765 
00766 private:
00767         TiXmlNode( const TiXmlNode& );                          // not implemented.
00768         void operator=( const TiXmlNode& base );        // not allowed.
00769 };
00770 
00771 
00779 class TiXmlAttribute : public TiXmlBase
00780 {
00781         friend class TiXmlAttributeSet;
00782 
00783 public:
00785         TiXmlAttribute() : TiXmlBase()
00786         {
00787                 document = 0;
00788                 prev = next = 0;
00789         }
00790 
00791         #ifdef TIXML_USE_STL
00792 
00793         TiXmlAttribute( const std::string& _name, const std::string& _value )
00794         {
00795                 name = _name;
00796                 value = _value;
00797                 document = 0;
00798                 prev = next = 0;
00799         }
00800         #endif
00801 
00803         TiXmlAttribute( const char * _name, const char * _value )
00804         {
00805                 name = _name;
00806                 value = _value;
00807                 document = 0;
00808                 prev = next = 0;
00809         }
00810 
00811         const char*             Name()  const           { return name.c_str(); }                
00812         const char*             Value() const           { return value.c_str(); }               
00813         #ifdef TIXML_USE_STL
00814         const std::string& ValueStr() const     { return value; }                               
00815         #endif
00816         int                             IntValue() const;                                                                       
00817         double                  DoubleValue() const;                                                            
00818 
00819         // Get the tinyxml string representation
00820         const TIXML_STRING& NameTStr() const { return name; }
00821 
00831         int QueryIntValue( int* _value ) const;
00833         int QueryDoubleValue( double* _value ) const;
00834 
00835         void SetName( const char* _name )       { name = _name; }                               
00836         void SetValue( const char* _value )     { value = _value; }                             
00837 
00838         void SetIntValue( int _value );                                                                         
00839         void SetDoubleValue( double _value );                                                           
00840 
00841     #ifdef TIXML_USE_STL
00842 
00843         void SetName( const std::string& _name )        { name = _name; }       
00845         void SetValue( const std::string& _value )      { value = _value; }
00846         #endif
00847 
00849         const TiXmlAttribute* Next() const;
00850         TiXmlAttribute* Next() {
00851                 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() ); 
00852         }
00853 
00855         const TiXmlAttribute* Previous() const;
00856         TiXmlAttribute* Previous() {
00857                 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Previous() ); 
00858         }
00859 
00860         bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
00861         bool operator<( const TiXmlAttribute& rhs )      const { return name < rhs.name; }
00862         bool operator>( const TiXmlAttribute& rhs )  const { return name > rhs.name; }
00863 
00864         /*      Attribute parsing starts: first letter of the name
00865                                                  returns: the next char after the value end quote
00866         */
00867         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
00868 
00869         // Prints this Attribute to a FILE stream.
00870         virtual void Print( FILE* cfile, int depth ) const {
00871                 Print( cfile, depth, 0 );
00872         }
00873         void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
00874 
00875         // [internal use]
00876         // Set the document pointer so the attribute can report errors.
00877         void SetDocument( TiXmlDocument* doc )  { document = doc; }
00878 
00879 private:
00880         TiXmlAttribute( const TiXmlAttribute& );                                // not implemented.
00881         void operator=( const TiXmlAttribute& base );   // not allowed.
00882 
00883         TiXmlDocument*  document;       // A pointer back to a document, for error reporting.
00884         TIXML_STRING name;
00885         TIXML_STRING value;
00886         TiXmlAttribute* prev;
00887         TiXmlAttribute* next;
00888 };
00889 
00890 
00891 /*      A class used to manage a group of attributes.
00892         It is only used internally, both by the ELEMENT and the DECLARATION.
00893         
00894         The set can be changed transparent to the Element and Declaration
00895         classes that use it, but NOT transparent to the Attribute
00896         which has to implement a next() and previous() method. Which makes
00897         it a bit problematic and prevents the use of STL.
00898 
00899         This version is implemented with circular lists because:
00900                 - I like circular lists
00901                 - it demonstrates some independence from the (typical) doubly linked list.
00902 */
00903 class TiXmlAttributeSet
00904 {
00905 public:
00906         TiXmlAttributeSet();
00907         ~TiXmlAttributeSet();
00908 
00909         void Add( TiXmlAttribute* attribute );
00910         void Remove( TiXmlAttribute* attribute );
00911 
00912         const TiXmlAttribute* First()   const   { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
00913         TiXmlAttribute* First()                                 { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
00914         const TiXmlAttribute* Last() const              { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
00915         TiXmlAttribute* Last()                                  { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
00916 
00917         TiXmlAttribute* Find( const char* _name ) const;
00918         TiXmlAttribute* FindOrCreate( const char* _name );
00919 
00920 #       ifdef TIXML_USE_STL
00921         TiXmlAttribute* Find( const std::string& _name ) const;
00922         TiXmlAttribute* FindOrCreate( const std::string& _name );
00923 #       endif
00924 
00925 
00926 private:
00927         //*ME:  Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
00928         //*ME:  this class must be also use a hidden/disabled copy-constructor !!!
00929         TiXmlAttributeSet( const TiXmlAttributeSet& );  // not allowed
00930         void operator=( const TiXmlAttributeSet& );     // not allowed (as TiXmlAttribute)
00931 
00932         TiXmlAttribute sentinel;
00933 };
00934 
00935 
00940 class TiXmlElement : public TiXmlNode
00941 {
00942 public:
00944         TiXmlElement (const char * in_value);
00945 
00946         #ifdef TIXML_USE_STL
00947 
00948         TiXmlElement( const std::string& _value );
00949         #endif
00950 
00951         TiXmlElement( const TiXmlElement& );
00952 
00953         void operator=( const TiXmlElement& base );
00954 
00955         virtual ~TiXmlElement();
00956 
00960         const char* Attribute( const char* name ) const;
00961 
00968         const char* Attribute( const char* name, int* i ) const;
00969 
00976         const char* Attribute( const char* name, double* d ) const;
00977 
00985         int QueryIntAttribute( const char* name, int* _value ) const;
00987         int QueryDoubleAttribute( const char* name, double* _value ) const;
00989         int QueryFloatAttribute( const char* name, float* _value ) const {
00990                 double d;
00991                 int result = QueryDoubleAttribute( name, &d );
00992                 if ( result == TIXML_SUCCESS ) {
00993                         *_value = (float)d;
00994                 }
00995                 return result;
00996         }
00997 
00998     #ifdef TIXML_USE_STL
00999 
01000         int QueryStringAttribute( const char* name, std::string* _value ) const {
01001                 const char* cstr = Attribute( name );
01002                 if ( cstr ) {
01003                         *_value = std::string( cstr );
01004                         return TIXML_SUCCESS;
01005                 }
01006                 return TIXML_NO_ATTRIBUTE;
01007         }
01008 
01017         template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const
01018         {
01019                 const TiXmlAttribute* node = attributeSet.Find( name );
01020                 if ( !node )
01021                         return TIXML_NO_ATTRIBUTE;
01022 
01023                 std::stringstream sstream( node->ValueStr() );
01024                 sstream >> *outValue;
01025                 if ( !sstream.fail() )
01026                         return TIXML_SUCCESS;
01027                 return TIXML_WRONG_TYPE;
01028         }
01029 
01030         int QueryValueAttribute( const std::string& name, std::string* outValue ) const
01031         {
01032                 const TiXmlAttribute* node = attributeSet.Find( name );
01033                 if ( !node )
01034                         return TIXML_NO_ATTRIBUTE;
01035                 *outValue = node->ValueStr();
01036                 return TIXML_SUCCESS;
01037         }
01038         #endif
01039 
01043         void SetAttribute( const char* name, const char * _value );
01044 
01045     #ifdef TIXML_USE_STL
01046         const std::string* Attribute( const std::string& name ) const;
01047         const std::string* Attribute( const std::string& name, int* i ) const;
01048         const std::string* Attribute( const std::string& name, double* d ) const;
01049         int QueryIntAttribute( const std::string& name, int* _value ) const;
01050         int QueryDoubleAttribute( const std::string& name, double* _value ) const;
01051 
01053         void SetAttribute( const std::string& name, const std::string& _value );
01055         void SetAttribute( const std::string& name, int _value );
01057         void SetDoubleAttribute( const std::string& name, double value );
01058         #endif
01059 
01063         void SetAttribute( const char * name, int value );
01064 
01068         void SetDoubleAttribute( const char * name, double value );
01069 
01072         void RemoveAttribute( const char * name );
01073     #ifdef TIXML_USE_STL
01074         void RemoveAttribute( const std::string& name ) {       RemoveAttribute (name.c_str ());        }       
01075         #endif
01076 
01077         const TiXmlAttribute* FirstAttribute() const    { return attributeSet.First(); }                
01078         TiXmlAttribute* FirstAttribute()                                { return attributeSet.First(); }
01079         const TiXmlAttribute* LastAttribute()   const   { return attributeSet.Last(); }         
01080         TiXmlAttribute* LastAttribute()                                 { return attributeSet.Last(); }
01081 
01114         const char* GetText() const;
01115 
01117         virtual TiXmlNode* Clone() const;
01118         // Print the Element to a FILE stream.
01119         virtual void Print( FILE* cfile, int depth ) const;
01120 
01121         /*      Attribtue parsing starts: next char past '<'
01122                                                  returns: next char past '>'
01123         */
01124         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01125 
01126         virtual const TiXmlElement*     ToElement()     const { return this; } 
01127         virtual TiXmlElement*           ToElement()               { return this; } 
01128 
01131         virtual bool Accept( TiXmlVisitor* visitor ) const;
01132 
01133 protected:
01134 
01135         void CopyTo( TiXmlElement* target ) const;
01136         void ClearThis();       // like clear, but initializes 'this' object as well
01137 
01138         // Used to be public [internal use]
01139         #ifdef TIXML_USE_STL
01140         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01141         #endif
01142         /*      [internal use]
01143                 Reads the "value" of the element -- another element, or text.
01144                 This should terminate with the current end tag.
01145         */
01146         const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
01147 
01148 private:
01149         TiXmlAttributeSet attributeSet;
01150 };
01151 
01152 
01155 class TiXmlComment : public TiXmlNode
01156 {
01157 public:
01159         TiXmlComment() : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {}
01161         TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {
01162                 SetValue( _value );
01163         }
01164         TiXmlComment( const TiXmlComment& );
01165         void operator=( const TiXmlComment& base );
01166 
01167         virtual ~TiXmlComment() {}
01168 
01170         virtual TiXmlNode* Clone() const;
01171         // Write this Comment to a FILE stream.
01172         virtual void Print( FILE* cfile, int depth ) const;
01173 
01174         /*      Attribtue parsing starts: at the ! of the !--
01175                                                  returns: next char past '>'
01176         */
01177         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01178 
01179         virtual const TiXmlComment*  ToComment() const { return this; } 
01180         virtual TiXmlComment*  ToComment() { return this; } 
01181 
01184         virtual bool Accept( TiXmlVisitor* visitor ) const;
01185 
01186 protected:
01187         void CopyTo( TiXmlComment* target ) const;
01188 
01189         // used to be public
01190         #ifdef TIXML_USE_STL
01191         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01192         #endif
01193 //      virtual void StreamOut( TIXML_OSTREAM * out ) const;
01194 
01195 private:
01196 
01197 };
01198 
01199 
01205 class TiXmlText : public TiXmlNode
01206 {
01207         friend class TiXmlElement;
01208 public:
01213         TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT)
01214         {
01215                 SetValue( initValue );
01216                 cdata = false;
01217         }
01218         virtual ~TiXmlText() {}
01219 
01220         #ifdef TIXML_USE_STL
01221 
01222         TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT)
01223         {
01224                 SetValue( initValue );
01225                 cdata = false;
01226         }
01227         #endif
01228 
01229         TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TINYXML_TEXT )       { copy.CopyTo( this ); }
01230         void operator=( const TiXmlText& base )                                                         { base.CopyTo( this ); }
01231 
01232         // Write this text object to a FILE stream.
01233         virtual void Print( FILE* cfile, int depth ) const;
01234 
01236         bool CDATA() const                              { return cdata; }
01238         void SetCDATA( bool _cdata )    { cdata = _cdata; }
01239 
01240         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01241 
01242         virtual const TiXmlText* ToText() const { return this; } 
01243         virtual TiXmlText*       ToText()       { return this; } 
01244 
01247         virtual bool Accept( TiXmlVisitor* content ) const;
01248 
01249 protected :
01251         virtual TiXmlNode* Clone() const;
01252         void CopyTo( TiXmlText* target ) const;
01253 
01254         bool Blank() const;     // returns true if all white space and new lines
01255         // [internal use]
01256         #ifdef TIXML_USE_STL
01257         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01258         #endif
01259 
01260 private:
01261         bool cdata;                     // true if this should be input and output as a CDATA style text element
01262 };
01263 
01264 
01278 class TiXmlDeclaration : public TiXmlNode
01279 {
01280 public:
01282         TiXmlDeclaration()   : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) {}
01283 
01284 #ifdef TIXML_USE_STL
01285 
01286         TiXmlDeclaration(       const std::string& _version,
01287                                                 const std::string& _encoding,
01288                                                 const std::string& _standalone );
01289 #endif
01290 
01292         TiXmlDeclaration(       const char* _version,
01293                                                 const char* _encoding,
01294                                                 const char* _standalone );
01295 
01296         TiXmlDeclaration( const TiXmlDeclaration& copy );
01297         void operator=( const TiXmlDeclaration& copy );
01298 
01299         virtual ~TiXmlDeclaration()     {}
01300 
01302         const char *Version() const                     { return version.c_str (); }
01304         const char *Encoding() const            { return encoding.c_str (); }
01306         const char *Standalone() const          { return standalone.c_str (); }
01307 
01309         virtual TiXmlNode* Clone() const;
01310         // Print this declaration to a FILE stream.
01311         virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
01312         virtual void Print( FILE* cfile, int depth ) const {
01313                 Print( cfile, depth, 0 );
01314         }
01315 
01316         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01317 
01318         virtual const TiXmlDeclaration* ToDeclaration() const { return this; } 
01319         virtual TiXmlDeclaration*       ToDeclaration()       { return this; } 
01320 
01323         virtual bool Accept( TiXmlVisitor* visitor ) const;
01324 
01325 protected:
01326         void CopyTo( TiXmlDeclaration* target ) const;
01327         // used to be public
01328         #ifdef TIXML_USE_STL
01329         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01330         #endif
01331 
01332 private:
01333 
01334         TIXML_STRING version;
01335         TIXML_STRING encoding;
01336         TIXML_STRING standalone;
01337 };
01338 
01339 
01347 class TiXmlUnknown : public TiXmlNode
01348 {
01349 public:
01350         TiXmlUnknown() : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN )        {}
01351         virtual ~TiXmlUnknown() {}
01352 
01353         TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN )              { copy.CopyTo( this ); }
01354         void operator=( const TiXmlUnknown& copy )                                                                              { copy.CopyTo( this ); }
01355 
01357         virtual TiXmlNode* Clone() const;
01358         // Print this Unknown to a FILE stream.
01359         virtual void Print( FILE* cfile, int depth ) const;
01360 
01361         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01362 
01363         virtual const TiXmlUnknown*     ToUnknown()     const { return this; } 
01364         virtual TiXmlUnknown*           ToUnknown()         { return this; } 
01365 
01368         virtual bool Accept( TiXmlVisitor* content ) const;
01369 
01370 protected:
01371         void CopyTo( TiXmlUnknown* target ) const;
01372 
01373         #ifdef TIXML_USE_STL
01374         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01375         #endif
01376 
01377 private:
01378 
01379 };
01380 
01381 
01386 class TiXmlDocument : public TiXmlNode
01387 {
01388 public:
01390         TiXmlDocument();
01392         TiXmlDocument( const char * documentName );
01393 
01394         #ifdef TIXML_USE_STL
01395 
01396         TiXmlDocument( const std::string& documentName );
01397         #endif
01398 
01399         TiXmlDocument( const TiXmlDocument& copy );
01400         void operator=( const TiXmlDocument& copy );
01401 
01402         virtual ~TiXmlDocument() {}
01403 
01408         bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01410         bool SaveFile() const;
01412         bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01414         bool SaveFile( const char * filename ) const;
01420         bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01422         bool SaveFile( FILE* ) const;
01423 
01424         #ifdef TIXML_USE_STL
01425         bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )                   
01426         {
01427                 return LoadFile( filename.c_str(), encoding );
01428         }
01429         bool SaveFile( const std::string& filename ) const              
01430         {
01431                 return SaveFile( filename.c_str() );
01432         }
01433         #endif
01434 
01439         virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01440 
01445         const TiXmlElement* RootElement() const         { return FirstChildElement(); }
01446         TiXmlElement* RootElement()                                     { return FirstChildElement(); }
01447 
01453         bool Error() const                                              { return error; }
01454 
01456         const char * ErrorDesc() const  { return errorDesc.c_str (); }
01457 
01461         int ErrorId()   const                           { return errorId; }
01462 
01470         int ErrorRow() const    { return errorLocation.row+1; }
01471         int ErrorCol() const    { return errorLocation.col+1; } 
01472 
01497         void SetTabSize( int _tabsize )         { tabsize = _tabsize; }
01498 
01499         int TabSize() const     { return tabsize; }
01500 
01504         void ClearError()                                               {       error = false; 
01505                                                                                                 errorId = 0; 
01506                                                                                                 errorDesc = ""; 
01507                                                                                                 errorLocation.row = errorLocation.col = 0; 
01508                                                                                                 //errorLocation.last = 0; 
01509                                                                                         }
01510 
01512         void Print() const                                              { Print( stdout, 0 ); }
01513 
01514         /* Write the document to a string using formatted printing ("pretty print"). This
01515                 will allocate a character array (new char[]) and return it as a pointer. The
01516                 calling code pust call delete[] on the return char* to avoid a memory leak.
01517         */
01518         //char* PrintToMemory() const; 
01519 
01521         virtual void Print( FILE* cfile, int depth = 0 ) const;
01522         // [internal use]
01523         void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
01524 
01525         virtual const TiXmlDocument*    ToDocument()    const { return this; } 
01526         virtual TiXmlDocument*          ToDocument()          { return this; } 
01527 
01530         virtual bool Accept( TiXmlVisitor* content ) const;
01531 
01532 protected :
01533         // [internal use]
01534         virtual TiXmlNode* Clone() const;
01535         #ifdef TIXML_USE_STL
01536         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01537         #endif
01538 
01539 private:
01540         void CopyTo( TiXmlDocument* target ) const;
01541 
01542         bool error;
01543         int  errorId;
01544         TIXML_STRING errorDesc;
01545         int tabsize;
01546         TiXmlCursor errorLocation;
01547         bool useMicrosoftBOM;           // the UTF-8 BOM were found when read. Note this, and try to write.
01548 };
01549 
01550 
01631 class TiXmlHandle
01632 {
01633 public:
01635         TiXmlHandle( TiXmlNode* _node )                                 { this->node = _node; }
01637         TiXmlHandle( const TiXmlHandle& ref )                   { this->node = ref.node; }
01638         TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
01639 
01641         TiXmlHandle FirstChild() const;
01643         TiXmlHandle FirstChild( const char * value ) const;
01645         TiXmlHandle FirstChildElement() const;
01647         TiXmlHandle FirstChildElement( const char * value ) const;
01648 
01652         TiXmlHandle Child( const char* value, int index ) const;
01656         TiXmlHandle Child( int index ) const;
01661         TiXmlHandle ChildElement( const char* value, int index ) const;
01666         TiXmlHandle ChildElement( int index ) const;
01667 
01668         #ifdef TIXML_USE_STL
01669         TiXmlHandle FirstChild( const std::string& _value ) const                               { return FirstChild( _value.c_str() ); }
01670         TiXmlHandle FirstChildElement( const std::string& _value ) const                { return FirstChildElement( _value.c_str() ); }
01671 
01672         TiXmlHandle Child( const std::string& _value, int index ) const                 { return Child( _value.c_str(), index ); }
01673         TiXmlHandle ChildElement( const std::string& _value, int index ) const  { return ChildElement( _value.c_str(), index ); }
01674         #endif
01675 
01678         TiXmlNode* ToNode() const                       { return node; } 
01681         TiXmlElement* ToElement() const         { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
01684         TiXmlText* ToText() const                       { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
01687         TiXmlUnknown* ToUnknown() const         { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
01688 
01692         TiXmlNode* Node() const                 { return ToNode(); } 
01696         TiXmlElement* Element() const   { return ToElement(); }
01700         TiXmlText* Text() const                 { return ToText(); }
01704         TiXmlUnknown* Unknown() const   { return ToUnknown(); }
01705 
01706 private:
01707         TiXmlNode* node;
01708 };
01709 
01710 
01730 class TiXmlPrinter : public TiXmlVisitor
01731 {
01732 public:
01733         TiXmlPrinter() : depth( 0 ), simpleTextPrint( false ),
01734                                          buffer(), indent( "    " ), lineBreak( "\n" ) {}
01735 
01736         virtual bool VisitEnter( const TiXmlDocument& doc );
01737         virtual bool VisitExit( const TiXmlDocument& doc );
01738 
01739         virtual bool VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute );
01740         virtual bool VisitExit( const TiXmlElement& element );
01741 
01742         virtual bool Visit( const TiXmlDeclaration& declaration );
01743         virtual bool Visit( const TiXmlText& text );
01744         virtual bool Visit( const TiXmlComment& comment );
01745         virtual bool Visit( const TiXmlUnknown& unknown );
01746 
01750         void SetIndent( const char* _indent )                   { indent = _indent ? _indent : "" ; }
01752         const char* Indent()                                                    { return indent.c_str(); }
01757         void SetLineBreak( const char* _lineBreak )             { lineBreak = _lineBreak ? _lineBreak : ""; }
01759         const char* LineBreak()                                                 { return lineBreak.c_str(); }
01760 
01764         void SetStreamPrinting()                                                { indent = "";
01765                                                                                                           lineBreak = "";
01766                                                                                                         }       
01768         const char* CStr()                                                              { return buffer.c_str(); }
01770         size_t Size()                                                                   { return buffer.size(); }
01771 
01772         #ifdef TIXML_USE_STL
01773 
01774         const std::string& Str()                                                { return buffer; }
01775         #endif
01776 
01777 private:
01778         void DoIndent() {
01779                 for( int i=0; i<depth; ++i )
01780                         buffer += indent;
01781         }
01782         void DoLineBreak() {
01783                 buffer += lineBreak;
01784         }
01785 
01786         int depth;
01787         bool simpleTextPrint;
01788         TIXML_STRING buffer;
01789         TIXML_STRING indent;
01790         TIXML_STRING lineBreak;
01791 };
01792 
01793 
01794 #ifdef _MSC_VER
01795 #pragma warning( pop )
01796 #endif
01797 
01798 #endif
01799 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines