TinyXml: tinyxml.h Source 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
+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
+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
+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
+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
+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
+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
+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
+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
+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 
+