Panda3D

tinyxml.h

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 
00109 /**
00110     Implements the interface to the "Visitor pattern" (see the Accept() method.)
00111     If you call the Accept() method, it requires being passed a TiXmlVisitor
00112     class to handle callbacks. For nodes that contain other nodes (Document, Element)
00113     you will get called with a VisitEnter/VisitExit pair. Nodes that are always leaves
00114     are simply called with Visit().
00115 
00116     If you return 'true' from a Visit method, recursive parsing will continue. If you return
00117     false, <b>no children of this node or its sibilings</b> will be Visited.
00118 
00119     All flavors of Visit methods have a default implementation that returns 'true' (continue 
00120     visiting). You need to only override methods that are interesting to you.
00121 
00122     Generally Accept() is called on the TiXmlDocument, although all nodes suppert Visiting.
00123 
00124     You should never change the document from a callback.
00125 
00126     @sa TiXmlNode::Accept()
00127 */
00128 class TiXmlVisitor
00129 {
00130 public:
00131     virtual ~TiXmlVisitor() {}
00132 
00133     /// Visit a document.
00134     virtual bool VisitEnter( const TiXmlDocument& /*doc*/ )         { return true; }
00135     /// Visit a document.
00136     virtual bool VisitExit( const TiXmlDocument& /*doc*/ )          { return true; }
00137 
00138     /// Visit an element.
00139     virtual bool VisitEnter( const TiXmlElement& /*element*/, const TiXmlAttribute* /*firstAttribute*/ )    { return true; }
00140     /// Visit an element.
00141     virtual bool VisitExit( const TiXmlElement& /*element*/ )       { return true; }
00142 
00143     /// Visit a declaration
00144     virtual bool Visit( const TiXmlDeclaration& /*declaration*/ )   { return true; }
00145     /// Visit a text node
00146     virtual bool Visit( const TiXmlText& /*text*/ )                 { return true; }
00147     /// Visit a comment node
00148     virtual bool Visit( const TiXmlComment& /*comment*/ )           { return true; }
00149     /// Visit an unknow node
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 
00172 /** TiXmlBase is a base class for every class in TinyXml.
00173     It does little except to establish that TinyXml classes
00174     can be printed and provide some utility functions.
00175 
00176     In XML, the document and elements can contain
00177     other elements and other types of nodes.
00178 
00179     @verbatim
00180     A Document can contain: Element (container or leaf)
00181                             Comment (leaf)
00182                             Unknown (leaf)
00183                             Declaration( leaf )
00184 
00185     An Element can contain: Element (container or leaf)
00186                             Text    (leaf)
00187                             Attributes (not on tree)
00188                             Comment (leaf)
00189                             Unknown (leaf)
00190 
00191     A Decleration contains: Attributes (not on tree)
00192     @endverbatim
00193 */
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 
00204     /** All TinyXml classes can print themselves to a filestream
00205         or the string class (TiXmlString in non-STL mode, std::string
00206         in STL mode.) Either or both cfile and str can be null.
00207         
00208         This is a formatted print, and will insert 
00209         tabs and newlines.
00210         
00211         (For an unformatted stream, use the << operator.)
00212     */
00213     virtual void Print( FILE* cfile, int depth ) const = 0;
00214 
00215     /** The world does not agree on whether white space should be kept or
00216         not. In order to make everyone happy, these global, static functions
00217         are provided to set whether or not TinyXml will condense all white space
00218         into a single space or not. The default is to condense. Note changing this
00219         value is not thread safe.
00220     */
00221     static void SetCondenseWhiteSpace( bool condense )      { condenseWhiteSpace = condense; }
00222 
00223     /// Return the current white space setting.
00224     static bool IsWhiteSpaceCondensed()                     { return condenseWhiteSpace; }
00225 
00226     /** Return the position, in the original source file, of this node or attribute.
00227         The row and column are 1-based. (That is the first row and first column is
00228         1,1). If the returns values are 0 or less, then the parser does not have
00229         a row and column value.
00230 
00231         Generally, the row and column value will be set when the TiXmlDocument::Load(),
00232         TiXmlDocument::LoadFile(), or any TiXmlNode::Parse() is called. It will NOT be set
00233         when the DOM was created from operator>>.
00234 
00235         The values reflect the initial load. Once the DOM is modified programmatically
00236         (by adding or changing nodes and attributes) the new values will NOT update to
00237         reflect changes in the document.
00238 
00239         There is a minor performance cost to computing the row and column. Computation
00240         can be disabled if TiXmlDocument::SetTabSize() is called with 0 as the value.
00241 
00242         @sa TiXmlDocument::SetTabSize()
00243     */
00244     int Row() const         { return location.row + 1; }
00245     int Column() const      { return location.col + 1; }    ///< See Row()
00246 
00247     void  SetUserData( void* user )         { userData = user; }    ///< Set a pointer to arbitrary user data.
00248     void* GetUserData()                     { return userData; }    ///< Get a pointer to arbitrary user data.
00249     const void* GetUserData() const         { return userData; }    ///< Get a pointer to arbitrary user data.
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 
00259     /** Expands entities in a string. Note this should not contian the tag's '<', '>', etc, 
00260         or they will be transformed into entities!
00261     */
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 
00375     /// Field containing a generic user pointer
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 
00417 /** The parent class for everything in the Document Object Model.
00418     (Except for attributes).
00419     Nodes have siblings, a parent, and children. A node can be
00420     in a document, or stand on its own. The type of a TiXmlNode
00421     can be queried, and it can be cast to its more defined type.
00422 */
00423 class TiXmlNode : public TiXmlBase
00424 {
00425     friend class TiXmlDocument;
00426     friend class TiXmlElement;
00427 
00428 public:
00429     #ifdef TIXML_USE_STL    
00430 
00431         /** An input stream operator, for every class. Tolerant of newlines and
00432             formatting, but doesn't expect them.
00433         */
00434         friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
00435 
00436         /** An output stream operator, for every class. Note that this outputs
00437             without any newlines or formatting, as opposed to Print(), which
00438             includes tabs and new lines.
00439 
00440             The operator<< and operator>> are not completely symmetric. Writing
00441             a node to a stream is very well defined. You'll get a nice stream
00442             of output, without any extra whitespace or newlines.
00443             
00444             But reading is not as well defined. (As it always is.) If you create
00445             a TiXmlElement (for example) and read that from an input stream,
00446             the text needs to define an element or junk will result. This is
00447             true of all input streams, but it's worth keeping in mind.
00448 
00449             A TiXmlDocument will read nodes until it reads a root element, and
00450             all the children of that root element.
00451         */  
00452         friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
00453 
00454         /// Appends the XML node or attribute to a std::string.
00455         friend std::string& operator<< (std::string& out, const TiXmlNode& base );
00456 
00457     #endif
00458 
00459     /** The types of XML nodes supported by TinyXml. (All the
00460             unsupported types are picked up by UNKNOWN.)
00461     */
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 
00475     /** The meaning of 'value' changes for the specific type of
00476         TiXmlNode.
00477         @verbatim
00478         Document:   filename of the xml file
00479         Element:    name of the element
00480         Comment:    the comment text
00481         Unknown:    the tag contents
00482         Text:       the text string
00483         @endverbatim
00484 
00485         The subclasses will wrap this function.
00486     */
00487     const char *Value() const { return value.c_str (); }
00488 
00489     #ifdef TIXML_USE_STL
00490     /** Return Value() as a std::string. If you only use STL,
00491         this is more efficient than calling Value().
00492         Only available in STL mode.
00493     */
00494     const std::string& ValueStr() const { return value; }
00495     #endif
00496 
00497     const TIXML_STRING& ValueTStr() const { return value; }
00498 
00499     /** Changes the value of the node. Defined as:
00500         @verbatim
00501         Document:   filename of the xml file
00502         Element:    name of the element
00503         Comment:    the comment text
00504         Unknown:    the tag contents
00505         Text:       the text string
00506         @endverbatim
00507     */
00508     void SetValue(const char * _value) { value = _value;}
00509 
00510     #ifdef TIXML_USE_STL
00511     /// STL std::string form.
00512     void SetValue( const std::string& _value )  { value = _value; }
00513     #endif
00514 
00515     /// Delete all the children of this node. Does not affect 'this'.
00516     void Clear();
00517 
00518     /// One step up the DOM.
00519     TiXmlNode* Parent()                         { return parent; }
00520     const TiXmlNode* Parent() const             { return parent; }
00521 
00522     const TiXmlNode* FirstChild()   const       { return firstChild; }  ///< The first child of this node. Will be null if there are no children.
00523     TiXmlNode* FirstChild()                     { return firstChild; }
00524     const TiXmlNode* FirstChild( const char * value ) const;            ///< The first child of this node with the matching 'value'. Will be null if none found.
00525     /// The first child of this node with the matching 'value'. Will be null if none found.
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; }       /// The last child of this node. Will be null if there are no children.
00532     TiXmlNode* LastChild()  { return lastChild; }
00533     
00534     const TiXmlNode* LastChild( const char * value ) const;         /// The last child of this node matching 'value'. Will be null if there are no children.
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 ());    }   ///< STL std::string form.
00541     TiXmlNode* FirstChild( const std::string& _value )              {   return FirstChild (_value.c_str ());    }   ///< STL std::string form.
00542     const TiXmlNode* LastChild( const std::string& _value ) const   {   return LastChild (_value.c_str ()); }   ///< STL std::string form.
00543     TiXmlNode* LastChild( const std::string& _value )               {   return LastChild (_value.c_str ()); }   ///< STL std::string form.
00544     #endif
00545 
00546     /** An alternate way to walk the children of a node.
00547         One way to iterate over nodes is:
00548         @verbatim
00549             for( child = parent->FirstChild(); child; child = child->NextSibling() )
00550         @endverbatim
00551 
00552         IterateChildren does the same thing with the syntax:
00553         @verbatim
00554             child = 0;
00555             while( child = parent->IterateChildren( child ) )
00556         @endverbatim
00557 
00558         IterateChildren takes the previous child as input and finds
00559         the next one. If the previous child is null, it returns the
00560         first. IterateChildren will return null when done.
00561     */
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 
00567     /// This flavor of IterateChildren searches for children with a particular 'value'
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); }   ///< STL std::string form.
00575     TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) {    return IterateChildren (_value.c_str (), previous); }   ///< STL std::string form.
00576     #endif
00577 
00578     /** Add a new node related to this. Adds a child past the LastChild.
00579         Returns a pointer to the new object or NULL if an error occured.
00580     */
00581     TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
00582 
00583 
00584     /** Add a new node related to this. Adds a child past the LastChild.
00585 
00586         NOTE: the node to be added is passed by pointer, and will be
00587         henceforth owned (and deleted) by tinyXml. This method is efficient
00588         and avoids an extra copy, but should be used with care as it
00589         uses a different memory model than the other insert functions.
00590 
00591         @sa InsertEndChild
00592     */
00593     TiXmlNode* LinkEndChild( TiXmlNode* addThis );
00594 
00595     /** Add a new node related to this. Adds a child before the specified child.
00596         Returns a pointer to the new object or NULL if an error occured.
00597     */
00598     TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
00599 
00600     /** Add a new node related to this. Adds a child after the specified child.
00601         Returns a pointer to the new object or NULL if an error occured.
00602     */
00603     TiXmlNode* InsertAfterChild(  TiXmlNode* afterThis, const TiXmlNode& addThis );
00604 
00605     /** Replace a child of this node.
00606         Returns a pointer to the new object or NULL if an error occured.
00607     */
00608     TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
00609 
00610     /// Delete a child of this node.
00611     bool RemoveChild( TiXmlNode* removeThis );
00612 
00613     /// Navigate to a sibling node.
00614     const TiXmlNode* PreviousSibling() const            { return prev; }
00615     TiXmlNode* PreviousSibling()                        { return prev; }
00616 
00617     /// Navigate to a sibling node.
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 ());   }   ///< STL std::string form.
00625     TiXmlNode* PreviousSibling( const std::string& _value )             {   return PreviousSibling (_value.c_str ());   }   ///< STL std::string form.
00626     const TiXmlNode* NextSibling( const std::string& _value) const      {   return NextSibling (_value.c_str ());   }   ///< STL std::string form.
00627     TiXmlNode* NextSibling( const std::string& _value)                  {   return NextSibling (_value.c_str ());   }   ///< STL std::string form.
00628     #endif
00629 
00630     /// Navigate to a sibling node.
00631     const TiXmlNode* NextSibling() const                { return next; }
00632     TiXmlNode* NextSibling()                            { return next; }
00633 
00634     /// Navigate to a sibling node with the given 'value'.
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 
00640     /** Convenience function to get through elements.
00641         Calls NextSibling and ToElement. Will skip all non-Element
00642         nodes. Returns 0 if there is not another element.
00643     */
00644     const TiXmlElement* NextSiblingElement() const;
00645     TiXmlElement* NextSiblingElement() {
00646         return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() );
00647     }
00648 
00649     /** Convenience function to get through elements.
00650         Calls NextSibling and ToElement. Will skip all non-Element
00651         nodes. Returns 0 if there is not another element.
00652     */
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 ());    }   ///< STL std::string form.
00660     TiXmlElement* NextSiblingElement( const std::string& _value)                {   return NextSiblingElement (_value.c_str ());    }   ///< STL std::string form.
00661     #endif
00662 
00663     /// Convenience function to get through elements.
00664     const TiXmlElement* FirstChildElement() const;
00665     TiXmlElement* FirstChildElement() {
00666         return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() );
00667     }
00668 
00669     /// Convenience function to get through elements.
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 ()); }   ///< STL std::string form.
00677     TiXmlElement* FirstChildElement( const std::string& _value )                {   return FirstChildElement (_value.c_str ()); }   ///< STL std::string form.
00678     #endif
00679 
00680     /** Query the type (as an enumerated value, above) of this node.
00681         The possible types are: DOCUMENT, ELEMENT, COMMENT,
00682                                 UNKNOWN, TEXT, and DECLARATION.
00683     */
00684     int Type() const    { return type; }
00685 
00686     /** Return a pointer to the Document this node lives in.
00687         Returns null if not in a document.
00688     */
00689     const TiXmlDocument* GetDocument() const;
00690     TiXmlDocument* GetDocument() {
00691         return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() );
00692     }
00693 
00694     /// Returns true if this node has no children.
00695     bool NoChildren() const                     { return !firstChild; }
00696 
00697     virtual const TiXmlDocument*    ToDocument()    const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00698     virtual const TiXmlElement*     ToElement()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00699     virtual const TiXmlComment*     ToComment()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00700     virtual const TiXmlUnknown*     ToUnknown()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00701     virtual const TiXmlText*        ToText()        const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00702     virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00703 
00704     virtual TiXmlDocument*          ToDocument()    { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00705     virtual TiXmlElement*           ToElement()     { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00706     virtual TiXmlComment*           ToComment()     { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00707     virtual TiXmlUnknown*           ToUnknown()     { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00708     virtual TiXmlText*              ToText()        { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00709     virtual TiXmlDeclaration*       ToDeclaration() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
00710 
00711     /** Create an exact duplicate of this node and return it. The memory must be deleted
00712         by the caller. 
00713     */
00714     virtual TiXmlNode* Clone() const = 0;
00715 
00716     /** Accept a hierchical visit the nodes in the TinyXML DOM. Every node in the 
00717         XML tree will be conditionally visited and the host will be called back
00718         via the TiXmlVisitor interface.
00719 
00720         This is essentially a SAX interface for TinyXML. (Note however it doesn't re-parse
00721         the XML for the callbacks, so the performance of TinyXML is unchanged by using this
00722         interface versus any other.)
00723 
00724         The interface has been based on ideas from:
00725 
00726         - http://www.saxproject.org/
00727         - http://c2.com/cgi/wiki?HierarchicalVisitorPattern 
00728 
00729         Which are both good references for "visiting".
00730 
00731         An example of using Accept():
00732         @verbatim
00733         TiXmlPrinter printer;
00734         tinyxmlDoc.Accept( &printer );
00735         const char* xmlcstr = printer.CStr();
00736         @endverbatim
00737     */
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 
00772 /** An attribute is a name-value pair. Elements have an arbitrary
00773     number of attributes, each with a unique name.
00774 
00775     @note The attributes are not TiXmlNodes, since they are not
00776           part of the tinyXML document object model. There are other
00777           suggested ways to look at this problem.
00778 */
00779 class TiXmlAttribute : public TiXmlBase
00780 {
00781     friend class TiXmlAttributeSet;
00782 
00783 public:
00784     /// Construct an empty attribute.
00785     TiXmlAttribute() : TiXmlBase()
00786     {
00787         document = 0;
00788         prev = next = 0;
00789     }
00790 
00791     #ifdef TIXML_USE_STL
00792     /// std::string constructor.
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 
00802     /// Construct an attribute with a name and value.
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(); }        ///< Return the name of this attribute.
00812     const char*     Value() const       { return value.c_str(); }       ///< Return the value of this attribute.
00813     #ifdef TIXML_USE_STL
00814     const std::string& ValueStr() const { return value; }               ///< Return the value of this attribute.
00815     #endif
00816     int             IntValue() const;                                   ///< Return the value of this attribute, converted to an integer.
00817     double          DoubleValue() const;                                ///< Return the value of this attribute, converted to a double.
00818 
00819     // Get the tinyxml string representation
00820     const TIXML_STRING& NameTStr() const { return name; }
00821 
00822     /** QueryIntValue examines the value string. It is an alternative to the
00823         IntValue() method with richer error checking.
00824         If the value is an integer, it is stored in 'value' and 
00825         the call returns TIXML_SUCCESS. If it is not
00826         an integer, it returns TIXML_WRONG_TYPE.
00827 
00828         A specialized but useful call. Note that for success it returns 0,
00829         which is the opposite of almost all other TinyXml calls.
00830     */
00831     int QueryIntValue( int* _value ) const;
00832     /// QueryDoubleValue examines the value string. See QueryIntValue().
00833     int QueryDoubleValue( double* _value ) const;
00834 
00835     void SetName( const char* _name )   { name = _name; }               ///< Set the name of this attribute.
00836     void SetValue( const char* _value ) { value = _value; }             ///< Set the value.
00837 
00838     void SetIntValue( int _value );                                     ///< Set the value from an integer.
00839     void SetDoubleValue( double _value );                               ///< Set the value from a double.
00840 
00841     #ifdef TIXML_USE_STL
00842     /// STL std::string form.
00843     void SetName( const std::string& _name )    { name = _name; }   
00844     /// STL std::string form.   
00845     void SetValue( const std::string& _value )  { value = _value; }
00846     #endif
00847 
00848     /// Get the next sibling attribute in the DOM. Returns null at end.
00849     const TiXmlAttribute* Next() const;
00850     TiXmlAttribute* Next() {
00851         return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() ); 
00852     }
00853 
00854     /// Get the previous sibling attribute in the DOM. Returns null at beginning.
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 
00936 /** The element is a container class. It has a value, the element name,
00937     and can contain other elements, text, comments, and unknowns.
00938     Elements also contain an arbitrary number of attributes.
00939 */
00940 class TiXmlElement : public TiXmlNode
00941 {
00942 public:
00943     /// Construct an element.
00944     TiXmlElement (const char * in_value);
00945 
00946     #ifdef TIXML_USE_STL
00947     /// std::string constructor.
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 
00957     /** Given an attribute name, Attribute() returns the value
00958         for the attribute of that name, or null if none exists.
00959     */
00960     const char* Attribute( const char* name ) const;
00961 
00962     /** Given an attribute name, Attribute() returns the value
00963         for the attribute of that name, or null if none exists.
00964         If the attribute exists and can be converted to an integer,
00965         the integer value will be put in the return 'i', if 'i'
00966         is non-null.
00967     */
00968     const char* Attribute( const char* name, int* i ) const;
00969 
00970     /** Given an attribute name, Attribute() returns the value
00971         for the attribute of that name, or null if none exists.
00972         If the attribute exists and can be converted to an double,
00973         the double value will be put in the return 'd', if 'd'
00974         is non-null.
00975     */
00976     const char* Attribute( const char* name, double* d ) const;
00977 
00978     /** QueryIntAttribute examines the attribute - it is an alternative to the
00979         Attribute() method with richer error checking.
00980         If the attribute is an integer, it is stored in 'value' and 
00981         the call returns TIXML_SUCCESS. If it is not
00982         an integer, it returns TIXML_WRONG_TYPE. If the attribute
00983         does not exist, then TIXML_NO_ATTRIBUTE is returned.
00984     */  
00985     int QueryIntAttribute( const char* name, int* _value ) const;
00986     /// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().
00987     int QueryDoubleAttribute( const char* name, double* _value ) const;
00988     /// QueryFloatAttribute examines the attribute - see QueryIntAttribute().
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     /// QueryStringAttribute examines the attribute - see QueryIntAttribute().
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 
01009     /** Template form of the attribute query which will try to read the
01010         attribute into the specified type. Very easy, very powerful, but
01011         be careful to make sure to call this with the correct type.
01012         
01013         NOTE: This method doesn't work correctly for 'string' types that contain spaces.
01014 
01015         @return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE
01016     */
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 
01040     /** Sets an attribute of name to a given value. The attribute
01041         will be created if it does not exist, or changed if it does.
01042     */
01043     void SetAttribute( const char* name, const char * _value );
01044 
01045     #ifdef TIXML_USE_STL
01046     const std::string* Attribute( const std::string& name ) const;
01047     const std::string* Attribute( const std::string& name, int* i ) const;
01048     const std::string* Attribute( const std::string& name, double* d ) const;
01049     int QueryIntAttribute( const std::string& name, int* _value ) const;
01050     int QueryDoubleAttribute( const std::string& name, double* _value ) const;
01051 
01052     /// STL std::string form.
01053     void SetAttribute( const std::string& name, const std::string& _value );
01054     ///< STL std::string form.
01055     void SetAttribute( const std::string& name, int _value );
01056     ///< STL std::string form.
01057     void SetDoubleAttribute( const std::string& name, double value );
01058     #endif
01059 
01060     /** Sets an attribute of name to a given value. The attribute
01061         will be created if it does not exist, or changed if it does.
01062     */
01063     void SetAttribute( const char * name, int value );
01064 
01065     /** Sets an attribute of name to a given value. The attribute
01066         will be created if it does not exist, or changed if it does.
01067     */
01068     void SetDoubleAttribute( const char * name, double value );
01069 
01070     /** Deletes an attribute with the given name.
01071     */
01072     void RemoveAttribute( const char * name );
01073     #ifdef TIXML_USE_STL
01074     void RemoveAttribute( const std::string& name ) {   RemoveAttribute (name.c_str ());    }   ///< STL std::string form.
01075     #endif
01076 
01077     const TiXmlAttribute* FirstAttribute() const    { return attributeSet.First(); }        ///< Access the first attribute in this element.
01078     TiXmlAttribute* FirstAttribute()                { return attributeSet.First(); }
01079     const TiXmlAttribute* LastAttribute()   const   { return attributeSet.Last(); }     ///< Access the last attribute in this element.
01080     TiXmlAttribute* LastAttribute()                 { return attributeSet.Last(); }
01081 
01082     /** Convenience function for easy access to the text inside an element. Although easy
01083         and concise, GetText() is limited compared to getting the TiXmlText child
01084         and accessing it directly.
01085     
01086         If the first child of 'this' is a TiXmlText, the GetText()
01087         returns the character string of the Text node, else null is returned.
01088 
01089         This is a convenient method for getting the text of simple contained text:
01090         @verbatim
01091         <foo>This is text</foo>
01092         const char* str = fooElement->GetText();
01093         @endverbatim
01094 
01095         'str' will be a pointer to "This is text". 
01096         
01097         Note that this function can be misleading. If the element foo was created from
01098         this XML:
01099         @verbatim
01100         <foo><b>This is text</b></foo> 
01101         @endverbatim
01102 
01103         then the value of str would be null. The first child node isn't a text node, it is
01104         another element. From this XML:
01105         @verbatim
01106         <foo>This is <b>text</b></foo> 
01107         @endverbatim
01108         GetText() will return "This is ".
01109 
01110         WARNING: GetText() accesses a child node - don't become confused with the 
01111                  similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are 
01112                  safe type casts on the referenced node.
01113     */
01114     const char* GetText() const;
01115 
01116     /// Creates a new Element and returns it - the returned element is a copy.
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; } ///< Cast to a more defined type. Will return null not of the requested type.
01127     virtual TiXmlElement*           ToElement()           { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
01128 
01129     /** Walk the XML tree visiting this node and all of its children. 
01130     */
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 
01153 /** An XML comment.
01154 */
01155 class TiXmlComment : public TiXmlNode
01156 {
01157 public:
01158     /// Constructs an empty comment.
01159     TiXmlComment() : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {}
01160     /// Construct a comment from text.
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 
01169     /// Returns a copy of this Comment.
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; } ///< Cast to a more defined type. Will return null not of the requested type.
01180     virtual TiXmlComment*  ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
01181 
01182     /** Walk the XML tree visiting this node and all of its children. 
01183     */
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 
01200 /** XML text. A text node can have 2 ways to output the next. "normal" output 
01201     and CDATA. It will default to the mode it was parsed from the XML file and
01202     you generally want to leave it alone, but you can change the output mode with 
01203     SetCDATA() and query it with CDATA().
01204 */
01205 class TiXmlText : public TiXmlNode
01206 {
01207     friend class TiXmlElement;
01208 public:
01209     /** Constructor for text element. By default, it is treated as 
01210         normal, encoded text. If you want it be output as a CDATA text
01211         element, set the parameter _cdata to 'true'
01212     */
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     /// Constructor.
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 
01235     /// Queries whether this represents text using a CDATA section.
01236     bool CDATA() const              { return cdata; }
01237     /// Turns on or off a CDATA representation of text.
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; } ///< Cast to a more defined type. Will return null not of the requested type.
01243     virtual TiXmlText*       ToText()       { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
01244 
01245     /** Walk the XML tree visiting this node and all of its children. 
01246     */
01247     virtual bool Accept( TiXmlVisitor* content ) const;
01248 
01249 protected :
01250     ///  [internal use] Creates a new Element and returns it.
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 
01265 /** In correct XML the declaration is the first entry in the file.
01266     @verbatim
01267         <?xml version="1.0" standalone="yes"?>
01268     @endverbatim
01269 
01270     TinyXml will happily read or write files without a declaration,
01271     however. There are 3 possible attributes to the declaration:
01272     version, encoding, and standalone.
01273 
01274     Note: In this version of the code, the attributes are
01275     handled as special cases, not generic attributes, simply
01276     because there can only be at most 3 and they are always the same.
01277 */
01278 class TiXmlDeclaration : public TiXmlNode
01279 {
01280 public:
01281     /// Construct an empty declaration.
01282     TiXmlDeclaration()   : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) {}
01283 
01284 #ifdef TIXML_USE_STL
01285     /// Constructor.
01286     TiXmlDeclaration(   const std::string& _version,
01287                         const std::string& _encoding,
01288                         const std::string& _standalone );
01289 #endif
01290 
01291     /// Construct.
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 
01301     /// Version. Will return an empty string if none was found.
01302     const char *Version() const         { return version.c_str (); }
01303     /// Encoding. Will return an empty string if none was found.
01304     const char *Encoding() const        { return encoding.c_str (); }
01305     /// Is this a standalone document?
01306     const char *Standalone() const      { return standalone.c_str (); }
01307 
01308     /// Creates a copy of this Declaration and returns it.
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; } ///< Cast to a more defined type. Will return null not of the requested type.
01319     virtual TiXmlDeclaration*       ToDeclaration()       { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
01320 
01321     /** Walk the XML tree visiting this node and all of its children. 
01322     */
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 
01340 /** Any tag that tinyXml doesn't recognize is saved as an
01341     unknown. It is a tag of text, but should not be modified.
01342     It will be written back to the XML, unchanged, when the file
01343     is saved.
01344 
01345     DTD tags get thrown into TiXmlUnknowns.
01346 */
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 
01356     /// Creates a copy of this Unknown and returns it.
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; } ///< Cast to a more defined type. Will return null not of the requested type.
01364     virtual TiXmlUnknown*           ToUnknown()     { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
01365 
01366     /** Walk the XML tree visiting this node and all of its children. 
01367     */
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 
01382 /** Always the top level node. A document binds together all the
01383     XML pieces. It can be saved, loaded, and printed to the screen.
01384     The 'value' of a document node is the xml file name.
01385 */
01386 class TiXmlDocument : public TiXmlNode
01387 {
01388 public:
01389     /// Create an empty document, that has no name.
01390     TiXmlDocument();
01391     /// Create a document with a name. The name of the document is also the filename of the xml.
01392     TiXmlDocument( const char * documentName );
01393 
01394     #ifdef TIXML_USE_STL
01395     /// Constructor.
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 
01404     /** Load a file using the current document value.
01405         Returns true if successful. Will delete any existing
01406         document data before loading.
01407     */
01408     bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01409     /// Save a file using the current document value. Returns true if successful.
01410     bool SaveFile() const;
01411     /// Load a file using the given filename. Returns true if successful.
01412     bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01413     /// Save a file using the given filename. Returns true if successful.
01414     bool SaveFile( const char * filename ) const;
01415     /** Load a file using the given FILE*. Returns true if successful. Note that this method
01416         doesn't stream - the entire object pointed at by the FILE*
01417         will be interpreted as an XML file. TinyXML doesn't stream in XML from the current
01418         file location. Streaming may be added in the future.
01419     */
01420     bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01421     /// Save a file using the given FILE*. Returns true if successful.
01422     bool SaveFile( FILE* ) const;
01423 
01424     #ifdef TIXML_USE_STL
01425     bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )           ///< STL std::string version.
01426     {
01427         return LoadFile( filename.c_str(), encoding );
01428     }
01429     bool SaveFile( const std::string& filename ) const      ///< STL std::string version.
01430     {
01431         return SaveFile( filename.c_str() );
01432     }
01433     #endif
01434 
01435     /** Parse the given null terminated block of xml data. Passing in an encoding to this
01436         method (either TIXML_ENCODING_LEGACY or TIXML_ENCODING_UTF8 will force TinyXml
01437         to use that encoding, regardless of what TinyXml might otherwise try to detect.
01438     */
01439     virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01440 
01441     /** Get the root element -- the only top level element -- of the document.
01442         In well formed XML, there should only be one. TinyXml is tolerant of
01443         multiple elements at the document level.
01444     */
01445     const TiXmlElement* RootElement() const     { return FirstChildElement(); }
01446     TiXmlElement* RootElement()                 { return FirstChildElement(); }
01447 
01448     /** If an error occurs, Error will be set to true. Also,
01449         - The ErrorId() will contain the integer identifier of the error (not generally useful)
01450         - The ErrorDesc() method will return the name of the error. (very useful)
01451         - The ErrorRow() and ErrorCol() will return the location of the error (if known)
01452     */  
01453     bool Error() const                      { return error; }
01454 
01455     /// Contains a textual (english) description of the error if one occurs.
01456     const char * ErrorDesc() const  { return errorDesc.c_str (); }
01457 
01458     /** Generally, you probably want the error string ( ErrorDesc() ). But if you
01459         prefer the ErrorId, this function will fetch it.
01460     */
01461     int ErrorId()   const               { return errorId; }
01462 
01463     /** Returns the location (if known) of the error. The first column is column 1, 
01464         and the first row is row 1. A value of 0 means the row and column wasn't applicable
01465         (memory errors, for example, have no row/column) or the parser lost the error. (An
01466         error in the error reporting, in that case.)
01467 
01468         @sa SetTabSize, Row, Column
01469     */
01470     int ErrorRow() const    { return errorLocation.row+1; }
01471     int ErrorCol() const    { return errorLocation.col+1; } ///< The column where the error occured. See ErrorRow()
01472 
01473     /** SetTabSize() allows the error reporting functions (ErrorRow() and ErrorCol())
01474         to report the correct values for row and column. It does not change the output
01475         or input in any way.
01476         
01477         By calling this method, with a tab size
01478         greater than 0, the row and column of each node and attribute is stored
01479         when the file is loaded. Very useful for tracking the DOM back in to
01480         the source file.
01481 
01482         The tab size is required for calculating the location of nodes. If not
01483         set, the default of 4 is used. The tabsize is set per document. Setting
01484         the tabsize to 0 disables row/column tracking.
01485 
01486         Note that row and column tracking is not supported when using operator>>.
01487 
01488         The tab size needs to be enabled before the parse or load. Correct usage:
01489         @verbatim
01490         TiXmlDocument doc;
01491         doc.SetTabSize( 8 );
01492         doc.Load( "myfile.xml" );
01493         @endverbatim
01494 
01495         @sa Row, Column
01496     */
01497     void SetTabSize( int _tabsize )     { tabsize = _tabsize; }
01498 
01499     int TabSize() const { return tabsize; }
01500 
01501     /** If you have handled the error, it can be reset with this call. The error
01502         state is automatically cleared if you Parse a new XML block.
01503     */
01504     void ClearError()                       {   error = false; 
01505                                                 errorId = 0; 
01506                                                 errorDesc = ""; 
01507                                                 errorLocation.row = errorLocation.col = 0; 
01508                                                 //errorLocation.last = 0; 
01509                                             }
01510 
01511     /** Write the document to standard out using formatted printing ("pretty print"). */
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 
01520     /// Print this Document to a FILE stream.
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; } ///< Cast to a more defined type. Will return null not of the requested type.
01526     virtual TiXmlDocument*          ToDocument()          { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
01527 
01528     /** Walk the XML tree visiting this node and all of its children. 
01529     */
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 
01551 /**
01552     A TiXmlHandle is a class that wraps a node pointer with null checks; this is
01553     an incredibly useful thing. Note that TiXmlHandle is not part of the TinyXml
01554     DOM structure. It is a separate utility class.
01555 
01556     Take an example:
01557     @verbatim
01558     <Document>
01559         <Element attributeA = "valueA">
01560             <Child attributeB = "value1" />
01561             <Child attributeB = "value2" />
01562         </Element>
01563     <Document>
01564     @endverbatim
01565 
01566     Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very 
01567     easy to write a *lot* of code that looks like:
01568 
01569     @verbatim
01570     TiXmlElement* root = document.FirstChildElement( "Document" );
01571     if ( root )
01572     {
01573         TiXmlElement* element = root->FirstChildElement( "Element" );
01574         if ( element )
01575         {
01576             TiXmlElement* child = element->FirstChildElement( "Child" );
01577             if ( child )
01578             {
01579                 TiXmlElement* child2 = child->NextSiblingElement( "Child" );
01580                 if ( child2 )
01581                 {
01582                     // Finally do something useful.
01583     @endverbatim
01584 
01585     And that doesn't even cover "else" cases. TiXmlHandle addresses the verbosity
01586     of such code. A TiXmlHandle checks for null pointers so it is perfectly safe 
01587     and correct to use:
01588 
01589     @verbatim
01590     TiXmlHandle docHandle( &document );
01591     TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).ToElement();
01592     if ( child2 )
01593     {
01594         // do something useful
01595     @endverbatim
01596 
01597     Which is MUCH more concise and useful.
01598 
01599     It is also safe to copy handles - internally they are nothing more than node pointers.
01600     @verbatim
01601     TiXmlHandle handleCopy = handle;
01602     @endverbatim
01603 
01604     What they should not be used for is iteration:
01605 
01606     @verbatim
01607     int i=0; 
01608     while ( true )
01609     {
01610         TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", i ).ToElement();
01611         if ( !child )
01612             break;
01613         // do something
01614         ++i;
01615     }
01616     @endverbatim
01617 
01618     It seems reasonable, but it is in fact two embedded while loops. The Child method is 
01619     a linear walk to find the element, so this code would iterate much more than it needs 
01620     to. Instead, prefer:
01621 
01622     @verbatim
01623     TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild( "Child" ).ToElement();
01624 
01625     for( child; child; child=child->NextSiblingElement() )
01626     {
01627         // do something
01628     }
01629     @endverbatim
01630 */
01631 class TiXmlHandle
01632 {
01633 public:
01634     /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
01635     TiXmlHandle( TiXmlNode* _node )                 { this->node = _node; }
01636     /// Copy constructor
01637     TiXmlHandle( const TiXmlHandle& ref )           { this->node = ref.node; }
01638     TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
01639 
01640     /// Return a handle to the first child node.
01641     TiXmlHandle FirstChild() const;
01642     /// Return a handle to the first child node with the given name.
01643     TiXmlHandle FirstChild( const char * value ) const;
01644     /// Return a handle to the first child element.
01645     TiXmlHandle FirstChildElement() const;
01646     /// Return a handle to the first child element with the given name.
01647     TiXmlHandle FirstChildElement( const char * value ) const;
01648 
01649     /** Return a handle to the "index" child with the given name. 
01650         The first child is 0, the second 1, etc.
01651     */
01652     TiXmlHandle Child( const char* value, int index ) const;
01653     /** Return a handle to the "index" child. 
01654         The first child is 0, the second 1, etc.
01655     */
01656     TiXmlHandle Child( int index ) const;
01657     /** Return a handle to the "index" child element with the given name. 
01658         The first child element is 0, the second 1, etc. Note that only TiXmlElements
01659         are indexed: other types are not counted.
01660     */
01661     TiXmlHandle ChildElement( const char* value, int index ) const;
01662     /** Return a handle to the "index" child element. 
01663         The first child element is 0, the second 1, etc. Note that only TiXmlElements
01664         are indexed: other types are not counted.
01665     */
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 
01676     /** Return the handle as a TiXmlNode. This may return null.
01677     */
01678     TiXmlNode* ToNode() const           { return node; } 
01679     /** Return the handle as a TiXmlElement. This may return null.
01680     */
01681     TiXmlElement* ToElement() const     { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
01682     /** Return the handle as a TiXmlText. This may return null.
01683     */
01684     TiXmlText* ToText() const           { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
01685     /** Return the handle as a TiXmlUnknown. This may return null.
01686     */
01687     TiXmlUnknown* ToUnknown() const     { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
01688 
01689     /** @deprecated use ToNode. 
01690         Return the handle as a TiXmlNode. This may return null.
01691     */
01692     TiXmlNode* Node() const         { return ToNode(); } 
01693     /** @deprecated use ToElement. 
01694         Return the handle as a TiXmlElement. This may return null.
01695     */
01696     TiXmlElement* Element() const   { return ToElement(); }
01697     /** @deprecated use ToText()
01698         Return the handle as a TiXmlText. This may return null.
01699     */
01700     TiXmlText* Text() const         { return ToText(); }
01701     /** @deprecated use ToUnknown()
01702         Return the handle as a TiXmlUnknown. This may return null.
01703     */
01704     TiXmlUnknown* Unknown() const   { return ToUnknown(); }
01705 
01706 private:
01707     TiXmlNode* node;
01708 };
01709 
01710 
01711 /** Print to memory functionality. The TiXmlPrinter is useful when you need to:
01712 
01713     -# Print to memory (especially in non-STL mode)
01714     -# Control formatting (line endings, etc.)
01715 
01716     When constructed, the TiXmlPrinter is in its default "pretty printing" mode.
01717     Before calling Accept() you can call methods to control the printing
01718     of the XML document. After TiXmlNode::Accept() is called, the printed document can
01719     be accessed via the CStr(), Str(), and Size() methods.
01720 
01721     TiXmlPrinter uses the Visitor API.
01722     @verbatim
01723     TiXmlPrinter printer;
01724     printer.SetIndent( "\t" );
01725 
01726     doc.Accept( &printer );
01727     fprintf( stdout, "%s", printer.CStr() );
01728     @endverbatim
01729 */
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 
01747     /** Set the indent characters for printing. By default 4 spaces
01748         but tab (\t) is also useful, or null/empty string for no indentation.
01749     */
01750     void SetIndent( const char* _indent )           { indent = _indent ? _indent : "" ; }
01751     /// Query the indention string.
01752     const char* Indent()                            { return indent.c_str(); }
01753     /** Set the line breaking string. By default set to newline (\n). 
01754         Some operating systems prefer other characters, or can be
01755         set to the null/empty string for no indenation.
01756     */
01757     void SetLineBreak( const char* _lineBreak )     { lineBreak = _lineBreak ? _lineBreak : ""; }
01758     /// Query the current line breaking string.
01759     const char* LineBreak()                         { return lineBreak.c_str(); }
01760 
01761     /** Switch over to "stream printing" which is the most dense formatting without 
01762         linebreaks. Common when the XML is needed for network transmission.
01763     */
01764     void SetStreamPrinting()                        { indent = "";
01765                                                       lineBreak = "";
01766                                                     }   
01767     /// Return the result.
01768     const char* CStr()                              { return buffer.c_str(); }
01769     /// Return the length of the result string.
01770     size_t Size()                                   { return buffer.size(); }
01771 
01772     #ifdef TIXML_USE_STL
01773     /// Return the result.
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 Functions Variables Enumerations