![]() |
OpenAlbum 1.0.b
|
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_TICPP 00047 #ifndef TIXML_USE_STL 00048 #define TIXML_USE_STL 00049 #endif 00050 #endif 00051 00052 #ifdef TIXML_USE_STL 00053 #include <string> 00054 #include <iostream> 00055 #include <sstream> 00056 #define TIXML_STRING std::string 00057 #else 00058 #include "tinystr.h" 00059 #define TIXML_STRING TiXmlString 00060 #endif 00061 00062 // Deprecated library function hell. Compilers want to use the 00063 // new safe versions. This probably doesn't fully address the problem, 00064 // but it gets closer. There are too many compilers for me to fully 00065 // test. If you get compilation troubles, undefine TIXML_SAFE 00066 #define TIXML_SAFE 00067 00068 #ifdef TIXML_SAFE 00069 #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) 00070 // Microsoft visual studio, version 2005 and higher. 00071 #define TIXML_SNPRINTF _snprintf_s 00072 #define TIXML_SNSCANF _snscanf_s 00073 #define TIXML_SSCANF sscanf_s 00074 #elif defined(_MSC_VER) && (_MSC_VER >= 1200 ) 00075 // Microsoft visual studio, version 6 and higher. 00076 //#pragma message( "Using _sn* functions." ) 00077 #define TIXML_SNPRINTF _snprintf 00078 #define TIXML_SNSCANF _snscanf 00079 #define TIXML_SSCANF sscanf 00080 #elif defined(__GNUC__) && (__GNUC__ >= 3 ) 00081 // GCC version 3 and higher.s 00082 //#warning( "Using sn* functions." ) 00083 #define TIXML_SNPRINTF snprintf 00084 #define TIXML_SNSCANF snscanf 00085 #define TIXML_SSCANF sscanf 00086 #else 00087 #define TIXML_SSCANF sscanf 00088 #endif 00089 #endif 00090 00091 class TiXmlDocument; 00092 class TiXmlElement; 00093 class TiXmlComment; 00094 class TiXmlUnknown; 00095 class TiXmlAttribute; 00096 class TiXmlText; 00097 class TiXmlDeclaration; 00098 class TiXmlStylesheetReference; 00099 class TiXmlParsingData; 00100 00101 const int TIXML_MAJOR_VERSION = 2; 00102 const int TIXML_MINOR_VERSION = 5; 00103 const int TIXML_PATCH_VERSION = 3; 00104 00105 /* Internal structure for tracking location of items 00106 in the XML file. 00107 */ 00108 struct TiXmlCursor 00109 { 00110 TiXmlCursor() { Clear(); } 00111 void Clear() { row = col = -1; } 00112 00113 int row; // 0 based. 00114 int col; // 0 based. 00115 }; 00116 00117 00136 class TiXmlVisitor 00137 { 00138 public: 00139 virtual ~TiXmlVisitor() {} 00140 00142 virtual bool VisitEnter( const TiXmlDocument& /*doc*/ ) { return true; } 00144 virtual bool VisitExit( const TiXmlDocument& /*doc*/ ) { return true; } 00145 00147 virtual bool VisitEnter( const TiXmlElement& /*element*/, const TiXmlAttribute* /*firstAttribute*/ ) { return true; } 00149 virtual bool VisitExit( const TiXmlElement& /*element*/ ) { return true; } 00150 00152 virtual bool Visit( const TiXmlDeclaration& /*declaration*/ ) { return true; } 00154 virtual bool Visit( const TiXmlStylesheetReference& /*stylesheet*/ ) { return true; } 00156 virtual bool Visit( const TiXmlText& /*text*/ ) { return true; } 00158 virtual bool Visit( const TiXmlComment& /*comment*/ ) { return true; } 00160 virtual bool Visit( const TiXmlUnknown& /*unknown*/ ) { return true; } 00161 }; 00162 00163 // Only used by Attribute::Query functions 00164 enum 00165 { 00166 TIXML_SUCCESS, 00167 TIXML_NO_ATTRIBUTE, 00168 TIXML_WRONG_TYPE 00169 }; 00170 00171 00172 // Used by the parsing routines. 00173 enum TiXmlEncoding 00174 { 00175 TIXML_ENCODING_UNKNOWN, 00176 TIXML_ENCODING_UTF8, 00177 TIXML_ENCODING_LEGACY 00178 }; 00179 00180 const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN; 00181 00204 #ifdef TIXML_USE_TICPP 00205 #include "ticpprc.h" 00206 class TiXmlBase : public TiCppRC 00207 #else 00208 class TiXmlBase 00209 #endif 00210 { 00211 friend class TiXmlNode; 00212 friend class TiXmlElement; 00213 friend class TiXmlDocument; 00214 00215 public: 00216 TiXmlBase() : userData(0) {} 00217 virtual ~TiXmlBase() {} 00218 00228 virtual void Print( FILE* cfile, int depth ) const = 0; 00229 00236 static void SetCondenseWhiteSpace( bool condense ) { condenseWhiteSpace = condense; } 00237 00239 static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; } 00240 00259 int Row() const { return location.row + 1; } 00260 int Column() const { return location.col + 1; } 00261 00262 void SetUserData( void* user ) { userData = user; } 00263 void* GetUserData() { return userData; } 00264 const void* GetUserData() const { return userData; } 00265 00266 // Table that returs, for a given lead byte, the total number of bytes 00267 // in the UTF-8 sequence. 00268 static const int utf8ByteTable[256]; 00269 00270 virtual const char* Parse( const char* p, 00271 TiXmlParsingData* data, 00272 TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0; 00273 00277 static void EncodeString( const TIXML_STRING& str, TIXML_STRING* out ); 00278 00279 enum 00280 { 00281 TIXML_NO_ERROR = 0, 00282 TIXML_ERROR, 00283 TIXML_ERROR_OPENING_FILE, 00284 TIXML_ERROR_OUT_OF_MEMORY, 00285 TIXML_ERROR_PARSING_ELEMENT, 00286 TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, 00287 TIXML_ERROR_READING_ELEMENT_VALUE, 00288 TIXML_ERROR_READING_ATTRIBUTES, 00289 TIXML_ERROR_PARSING_EMPTY, 00290 TIXML_ERROR_READING_END_TAG, 00291 TIXML_ERROR_PARSING_UNKNOWN, 00292 TIXML_ERROR_PARSING_COMMENT, 00293 TIXML_ERROR_PARSING_DECLARATION, 00294 TIXML_ERROR_DOCUMENT_EMPTY, 00295 TIXML_ERROR_EMBEDDED_NULL, 00296 TIXML_ERROR_PARSING_CDATA, 00297 TIXML_ERROR_DOCUMENT_TOP_ONLY, 00298 00299 TIXML_ERROR_STRING_COUNT 00300 }; 00301 00302 protected: 00303 00304 static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding ); 00305 inline static bool IsWhiteSpace( char c ) 00306 { 00307 return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); 00308 } 00309 inline static bool IsWhiteSpace( int c ) 00310 { 00311 if ( c < 256 ) 00312 return IsWhiteSpace( (char) c ); 00313 return false; // Again, only truly correct for English/Latin...but usually works. 00314 } 00315 00316 #ifdef TIXML_USE_STL 00317 static bool StreamWhiteSpace( std::istream * in, TIXML_STRING * tag ); 00318 static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag ); 00319 #endif 00320 00321 /* Reads an XML name into the string provided. Returns 00322 a pointer just past the last character of the name, 00323 or 0 if the function has an error. 00324 */ 00325 static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding ); 00326 00327 /* Reads text. Returns a pointer past the given end tag. 00328 Wickedly complex options, but it keeps the (sensitive) code in one place. 00329 */ 00330 static const char* ReadText( const char* in, // where to start 00331 TIXML_STRING* text, // the string read 00332 bool ignoreWhiteSpace, // whether to keep the white space 00333 const char* endTag, // what ends this text 00334 bool ignoreCase, // whether to ignore case in the end tag 00335 TiXmlEncoding encoding ); // the current encoding 00336 00337 // If an entity has been found, transform it into a character. 00338 static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding ); 00339 00340 // Get a character, while interpreting entities. 00341 // The length can be from 0 to 4 bytes. 00342 inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding ) 00343 { 00344 assert( p ); 00345 if ( encoding == TIXML_ENCODING_UTF8 ) 00346 { 00347 *length = utf8ByteTable[ *((const unsigned char*)p) ]; 00348 assert( *length >= 0 && *length < 5 ); 00349 } 00350 else 00351 { 00352 *length = 1; 00353 } 00354 00355 if ( *length == 1 ) 00356 { 00357 if ( *p == '&' ) 00358 return GetEntity( p, _value, length, encoding ); 00359 *_value = *p; 00360 return p+1; 00361 } 00362 else if ( *length ) 00363 { 00364 //strncpy( _value, p, *length ); // lots of compilers don't like this function (unsafe), 00365 // and the null terminator isn't needed 00366 for( int i=0; p[i] && i<*length; ++i ) { 00367 _value[i] = p[i]; 00368 } 00369 return p + (*length); 00370 } 00371 else 00372 { 00373 // Not valid text. 00374 return 0; 00375 } 00376 } 00377 00378 // Return true if the next characters in the stream are any of the endTag sequences. 00379 // Ignore case only works for english, and should only be relied on when comparing 00380 // to English words: StringEqual( p, "version", true ) is fine. 00381 static bool StringEqual( const char* p, 00382 const char* endTag, 00383 bool ignoreCase, 00384 TiXmlEncoding encoding ); 00385 00386 static const char* errorString[ TIXML_ERROR_STRING_COUNT ]; 00387 00388 TiXmlCursor location; 00389 00391 void* userData; 00392 00393 // None of these methods are reliable for any language except English. 00394 // Good for approximation, not great for accuracy. 00395 static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding ); 00396 static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding ); 00397 inline static int ToLower( int v, TiXmlEncoding encoding ) 00398 { 00399 if ( encoding == TIXML_ENCODING_UTF8 ) 00400 { 00401 if ( v < 128 ) return tolower( v ); 00402 return v; 00403 } 00404 else 00405 { 00406 return tolower( v ); 00407 } 00408 } 00409 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length ); 00410 00411 private: 00412 TiXmlBase( const TiXmlBase& ); // not implemented. 00413 void operator=( const TiXmlBase& base ); // not allowed. 00414 00415 struct Entity 00416 { 00417 const char* str; 00418 unsigned int strLength; 00419 char chr; 00420 }; 00421 enum 00422 { 00423 NUM_ENTITY = 5, 00424 MAX_ENTITY_LENGTH = 6 00425 00426 }; 00427 static Entity entity[ NUM_ENTITY ]; 00428 static bool condenseWhiteSpace; 00429 }; 00430 00431 00438 class TiXmlNode : public TiXmlBase 00439 { 00440 friend class TiXmlDocument; 00441 friend class TiXmlElement; 00442 00443 public: 00444 #ifdef TIXML_USE_STL 00445 00449 friend std::istream& operator >> (std::istream& in, TiXmlNode& base); 00450 00467 friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base); 00468 00470 friend std::string& operator<< (std::string& out, const TiXmlNode& base ); 00471 00472 #endif 00473 00477 enum NodeType 00478 { 00479 DOCUMENT, 00480 ELEMENT, 00481 COMMENT, 00482 UNKNOWN, 00483 TEXT, 00484 DECLARATION, 00485 STYLESHEETREFERENCE, 00486 TYPECOUNT 00487 }; 00488 00489 virtual ~TiXmlNode(); 00490 00503 const char *Value() const { return value.c_str (); } 00504 00505 #ifdef TIXML_USE_STL 00506 00510 const std::string& ValueStr() const { return value; } 00511 #endif 00512 00513 const TIXML_STRING& ValueTStr() const { return value; } 00514 00524 void SetValue(const char * _value) { value = _value;} 00525 00526 #ifdef TIXML_USE_STL 00527 00528 void SetValue( const std::string& _value ) { value = _value; } 00529 #endif 00530 00532 void Clear(); 00533 00535 TiXmlNode* Parent() { return parent; } 00536 const TiXmlNode* Parent() const { return parent; } 00537 00538 const TiXmlNode* FirstChild() const { return firstChild; } 00539 TiXmlNode* FirstChild() { return firstChild; } 00540 const TiXmlNode* FirstChild( const char * value ) const; 00541 00542 TiXmlNode* FirstChild( const char * _value ) { 00543 // Call through to the const version - safe since nothing is changed. Exiting syntax: cast this to a const (always safe) 00544 // call the method, cast the return back to non-const. 00545 return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild( _value )); 00546 } 00547 const TiXmlNode* LastChild() const { return lastChild; } 00548 TiXmlNode* LastChild() { return lastChild; } 00549 00550 const TiXmlNode* LastChild( const char * value ) const; 00551 TiXmlNode* LastChild( const char * _value ) { 00552 return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild( _value )); 00553 } 00554 00555 #ifdef TIXML_USE_STL 00556 const TiXmlNode* FirstChild( const std::string& _value ) const { return FirstChild (_value.c_str ()); } 00557 TiXmlNode* FirstChild( const std::string& _value ) { return FirstChild (_value.c_str ()); } 00558 const TiXmlNode* LastChild( const std::string& _value ) const { return LastChild (_value.c_str ()); } 00559 TiXmlNode* LastChild( const std::string& _value ) { return LastChild (_value.c_str ()); } 00560 #endif 00561 00578 const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const; 00579 TiXmlNode* IterateChildren( const TiXmlNode* previous ) { 00580 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( previous ) ); 00581 } 00582 00584 const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const; 00585 TiXmlNode* IterateChildren( const char * _value, const TiXmlNode* previous ) { 00586 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( _value, previous ) ); 00587 } 00588 00589 #ifdef TIXML_USE_STL 00590 const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const { return IterateChildren (_value.c_str (), previous); } 00591 TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) { return IterateChildren (_value.c_str (), previous); } 00592 #endif 00593 00597 TiXmlNode* InsertEndChild( const TiXmlNode& addThis ); 00598 00599 00609 TiXmlNode* LinkEndChild( TiXmlNode* addThis ); 00610 00614 TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis ); 00615 00619 TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis ); 00620 00624 TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis ); 00625 00627 bool RemoveChild( TiXmlNode* removeThis ); 00628 00630 const TiXmlNode* PreviousSibling() const { return prev; } 00631 TiXmlNode* PreviousSibling() { return prev; } 00632 00634 const TiXmlNode* PreviousSibling( const char * ) const; 00635 TiXmlNode* PreviousSibling( const char *_prev ) { 00636 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->PreviousSibling( _prev ) ); 00637 } 00638 00639 #ifdef TIXML_USE_STL 00640 const TiXmlNode* PreviousSibling( const std::string& _value ) const { return PreviousSibling (_value.c_str ()); } 00641 TiXmlNode* PreviousSibling( const std::string& _value ) { return PreviousSibling (_value.c_str ()); } 00642 const TiXmlNode* NextSibling( const std::string& _value) const { return NextSibling (_value.c_str ()); } 00643 TiXmlNode* NextSibling( const std::string& _value) { return NextSibling (_value.c_str ()); } 00644 #endif 00645 00647 const TiXmlNode* NextSibling() const { return next; } 00648 TiXmlNode* NextSibling() { return next; } 00649 00651 const TiXmlNode* NextSibling( const char * ) const; 00652 TiXmlNode* NextSibling( const char* _next ) { 00653 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->NextSibling( _next ) ); 00654 } 00655 00660 const TiXmlElement* NextSiblingElement() const; 00661 TiXmlElement* NextSiblingElement() { 00662 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() ); 00663 } 00664 00669 const TiXmlElement* NextSiblingElement( const char * ) const; 00670 TiXmlElement* NextSiblingElement( const char *_next ) { 00671 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement( _next ) ); 00672 } 00673 00674 #ifdef TIXML_USE_STL 00675 const TiXmlElement* NextSiblingElement( const std::string& _value) const { return NextSiblingElement (_value.c_str ()); } 00676 TiXmlElement* NextSiblingElement( const std::string& _value) { return NextSiblingElement (_value.c_str ()); } 00677 #endif 00678 00680 const TiXmlElement* FirstChildElement() const; 00681 TiXmlElement* FirstChildElement() { 00682 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() ); 00683 } 00684 00686 const TiXmlElement* FirstChildElement( const char * _value ) const; 00687 TiXmlElement* FirstChildElement( const char * _value ) { 00688 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement( _value ) ); 00689 } 00690 00691 #ifdef TIXML_USE_STL 00692 const TiXmlElement* FirstChildElement( const std::string& _value ) const { return FirstChildElement (_value.c_str ()); } 00693 TiXmlElement* FirstChildElement( const std::string& _value ) { return FirstChildElement (_value.c_str ()); } 00694 #endif 00695 00700 int Type() const { return type; } 00701 00705 const TiXmlDocument* GetDocument() const; 00706 TiXmlDocument* GetDocument() { 00707 return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() ); 00708 } 00709 00711 bool NoChildren() const { return !firstChild; } 00712 00713 virtual const TiXmlDocument* ToDocument() const { return 0; } 00714 virtual const TiXmlElement* ToElement() const { return 0; } 00715 virtual const TiXmlComment* ToComment() const { return 0; } 00716 virtual const TiXmlUnknown* ToUnknown() const { return 0; } 00717 virtual const TiXmlText* ToText() const { return 0; } 00718 virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } 00719 virtual const TiXmlStylesheetReference* ToStylesheetReference() const { return 0; } 00720 00721 virtual TiXmlDocument* ToDocument() { return 0; } 00722 virtual TiXmlElement* ToElement() { return 0; } 00723 virtual TiXmlComment* ToComment() { return 0; } 00724 virtual TiXmlUnknown* ToUnknown() { return 0; } 00725 virtual TiXmlText* ToText() { return 0; } 00726 virtual TiXmlDeclaration* ToDeclaration() { return 0; } 00727 virtual TiXmlStylesheetReference* ToStylesheetReference() { return 0; } 00728 00732 virtual TiXmlNode* Clone() const = 0; 00733 00756 virtual bool Accept( TiXmlVisitor* visitor ) const = 0; 00757 00758 protected: 00759 TiXmlNode( NodeType _type ); 00760 00761 // Copy to the allocated object. Shared functionality between Clone, Copy constructor, 00762 // and the assignment operator. 00763 void CopyTo( TiXmlNode* target ) const; 00764 00765 #ifdef TIXML_USE_STL 00766 // The real work of the input operator. 00767 virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0; 00768 #endif 00769 00770 // Figure out what is at *p, and parse it. Returns null if it is not an xml node. 00771 TiXmlNode* Identify( const char* start, TiXmlEncoding encoding ); 00772 00773 TiXmlNode* parent; 00774 NodeType type; 00775 00776 TiXmlNode* firstChild; 00777 TiXmlNode* lastChild; 00778 00779 TIXML_STRING value; 00780 00781 TiXmlNode* prev; 00782 TiXmlNode* next; 00783 00784 private: 00785 TiXmlNode( const TiXmlNode& ); // not implemented. 00786 void operator=( const TiXmlNode& base ); // not allowed. 00787 }; 00788 00789 00797 class TiXmlAttribute : public TiXmlBase 00798 { 00799 friend class TiXmlAttributeSet; 00800 00801 public: 00803 TiXmlAttribute() : TiXmlBase() 00804 { 00805 document = 0; 00806 prev = next = 0; 00807 } 00808 00809 #ifdef TIXML_USE_STL 00810 00811 TiXmlAttribute( const std::string& _name, const std::string& _value ) 00812 { 00813 name = _name; 00814 value = _value; 00815 document = 0; 00816 prev = next = 0; 00817 } 00818 #endif 00819 00821 TiXmlAttribute( const char * _name, const char * _value ) 00822 { 00823 name = _name; 00824 value = _value; 00825 document = 0; 00826 prev = next = 0; 00827 } 00828 00829 const char* Name() const { return name.c_str(); } 00830 const char* Value() const { return value.c_str(); } 00831 #ifdef TIXML_USE_STL 00832 const std::string& ValueStr() const { return value; } 00833 #endif 00834 int IntValue() const; 00835 double DoubleValue() const; 00836 00837 // Get the tinyxml string representation 00838 const TIXML_STRING& NameTStr() const { return name; } 00839 00849 int QueryIntValue( int* _value ) const; 00851 int QueryDoubleValue( double* _value ) const; 00852 00853 void SetName( const char* _name ) { name = _name; } 00854 void SetValue( const char* _value ) { value = _value; } 00855 00856 void SetIntValue( int _value ); 00857 void SetDoubleValue( double _value ); 00858 00859 #ifdef TIXML_USE_STL 00860 00861 void SetName( const std::string& _name ) { name = _name; } 00863 void SetValue( const std::string& _value ) { value = _value; } 00864 #endif 00865 00867 const TiXmlAttribute* Next() const; 00868 TiXmlAttribute* Next() { 00869 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() ); 00870 } 00871 00873 const TiXmlAttribute* Previous() const; 00874 TiXmlAttribute* Previous() { 00875 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Previous() ); 00876 } 00877 00878 bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; } 00879 bool operator<( const TiXmlAttribute& rhs ) const { return name < rhs.name; } 00880 bool operator>( const TiXmlAttribute& rhs ) const { return name > rhs.name; } 00881 00882 /* Attribute parsing starts: first letter of the name 00883 returns: the next char after the value end quote 00884 */ 00885 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 00886 00887 // Prints this Attribute to a FILE stream. 00888 virtual void Print( FILE* cfile, int depth ) const { 00889 Print( cfile, depth, 0 ); 00890 } 00891 void Print( FILE* cfile, int depth, TIXML_STRING* str ) const; 00892 00893 // [internal use] 00894 // Set the document pointer so the attribute can report errors. 00895 void SetDocument( TiXmlDocument* doc ) { document = doc; } 00896 00897 private: 00898 TiXmlAttribute( const TiXmlAttribute& ); // not implemented. 00899 void operator=( const TiXmlAttribute& base ); // not allowed. 00900 00901 TiXmlDocument* document; // A pointer back to a document, for error reporting. 00902 TIXML_STRING name; 00903 TIXML_STRING value; 00904 TiXmlAttribute* prev; 00905 TiXmlAttribute* next; 00906 }; 00907 00908 00909 /* A class used to manage a group of attributes. 00910 It is only used internally, both by the ELEMENT and the DECLARATION. 00911 00912 The set can be changed transparent to the Element and Declaration 00913 classes that use it, but NOT transparent to the Attribute 00914 which has to implement a next() and previous() method. Which makes 00915 it a bit problematic and prevents the use of STL. 00916 00917 This version is implemented with circular lists because: 00918 - I like circular lists 00919 - it demonstrates some independence from the (typical) doubly linked list. 00920 */ 00921 class TiXmlAttributeSet 00922 { 00923 public: 00924 TiXmlAttributeSet(); 00925 ~TiXmlAttributeSet(); 00926 00927 void Add( TiXmlAttribute* attribute ); 00928 void Remove( TiXmlAttribute* attribute ); 00929 00930 const TiXmlAttribute* First() const { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; } 00931 TiXmlAttribute* First() { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; } 00932 const TiXmlAttribute* Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; } 00933 TiXmlAttribute* Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; } 00934 00935 const TiXmlAttribute* Find( const char* _name ) const; 00936 TiXmlAttribute* Find( const char* _name ) { 00937 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) ); 00938 } 00939 #ifdef TIXML_USE_STL 00940 const TiXmlAttribute* Find( const std::string& _name ) const; 00941 TiXmlAttribute* Find( const std::string& _name ) { 00942 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) ); 00943 } 00944 00945 #endif 00946 00947 private: 00948 //*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element), 00949 //*ME: this class must be also use a hidden/disabled copy-constructor !!! 00950 TiXmlAttributeSet( const TiXmlAttributeSet& ); // not allowed 00951 void operator=( const TiXmlAttributeSet& ); // not allowed (as TiXmlAttribute) 00952 00953 TiXmlAttribute sentinel; 00954 }; 00955 00956 00961 class TiXmlElement : public TiXmlNode 00962 { 00963 public: 00965 TiXmlElement (const char * in_value); 00966 00967 #ifdef TIXML_USE_STL 00968 00969 TiXmlElement( const std::string& _value ); 00970 #endif 00971 00972 TiXmlElement( const TiXmlElement& ); 00973 00974 void operator=( const TiXmlElement& base ); 00975 00976 virtual ~TiXmlElement(); 00977 00981 const char* Attribute( const char* name ) const; 00982 00989 const char* Attribute( const char* name, int* i ) const; 00990 00997 const char* Attribute( const char* name, double* d ) const; 00998 01006 int QueryIntAttribute( const char* name, int* _value ) const; 01008 int QueryDoubleAttribute( const char* name, double* _value ) const; 01010 int QueryFloatAttribute( const char* name, float* _value ) const { 01011 double d; 01012 int result = QueryDoubleAttribute( name, &d ); 01013 if ( result == TIXML_SUCCESS ) { 01014 *_value = (float)d; 01015 } 01016 return result; 01017 } 01018 01019 #ifdef TIXML_USE_STL 01020 01028 template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const 01029 { 01030 const TiXmlAttribute* node = attributeSet.Find( name ); 01031 if ( !node ) 01032 return TIXML_NO_ATTRIBUTE; 01033 01034 std::stringstream sstream( node->ValueStr() ); 01035 sstream >> *outValue; 01036 if ( !sstream.fail() ) 01037 return TIXML_SUCCESS; 01038 return TIXML_WRONG_TYPE; 01039 } 01040 /* 01041 This is - in theory - a bug fix for "QueryValueAtribute returns truncated std::string" 01042 but template specialization is hard to get working cross-compiler. Leaving the bug for now. 01043 01044 // The above will fail for std::string because the space character is used as a seperator. 01045 // Specialize for strings. Bug [ 1695429 ] QueryValueAtribute returns truncated std::string 01046 template<> int QueryValueAttribute( const std::string& name, std::string* outValue ) const 01047 { 01048 const TiXmlAttribute* node = attributeSet.Find( name ); 01049 if ( !node ) 01050 return TIXML_NO_ATTRIBUTE; 01051 *outValue = node->ValueStr(); 01052 return TIXML_SUCCESS; 01053 } 01054 */ 01055 #endif 01056 01060 void SetAttribute( const char* name, const char * _value ); 01061 01062 #ifdef TIXML_USE_STL 01063 const std::string* Attribute( const std::string& name ) const; 01064 const std::string* Attribute( const std::string& name, int* i ) const; 01065 const std::string* Attribute( const std::string& name, double* d ) const; 01066 int QueryIntAttribute( const std::string& name, int* _value ) const; 01067 int QueryDoubleAttribute( const std::string& name, double* _value ) const; 01068 01070 void SetAttribute( const std::string& name, const std::string& _value ); 01072 void SetAttribute( const std::string& name, int _value ); 01073 #endif 01074 01078 void SetAttribute( const char * name, int value ); 01079 01083 void SetDoubleAttribute( const char * name, double value ); 01084 01087 void RemoveAttribute( const char * name ); 01088 #ifdef TIXML_USE_STL 01089 void RemoveAttribute( const std::string& name ) { RemoveAttribute (name.c_str ()); } 01090 #endif 01091 01092 const TiXmlAttribute* FirstAttribute() const { return attributeSet.First(); } 01093 TiXmlAttribute* FirstAttribute() { return attributeSet.First(); } 01094 const TiXmlAttribute* LastAttribute() const { return attributeSet.Last(); } 01095 TiXmlAttribute* LastAttribute() { return attributeSet.Last(); } 01096 01129 const char* GetText() const; 01130 01132 virtual TiXmlNode* Clone() const; 01133 // Print the Element to a FILE stream. 01134 virtual void Print( FILE* cfile, int depth ) const; 01135 01136 /* Attribtue parsing starts: next char past '<' 01137 returns: next char past '>' 01138 */ 01139 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01140 01141 virtual const TiXmlElement* ToElement() const { return this; } 01142 virtual TiXmlElement* ToElement() { return this; } 01143 01146 virtual bool Accept( TiXmlVisitor* visitor ) const; 01147 01148 protected: 01149 01150 void CopyTo( TiXmlElement* target ) const; 01151 void ClearThis(); // like clear, but initializes 'this' object as well 01152 01153 // Used to be public [internal use] 01154 #ifdef TIXML_USE_STL 01155 virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); 01156 #endif 01157 /* [internal use] 01158 Reads the "value" of the element -- another element, or text. 01159 This should terminate with the current end tag. 01160 */ 01161 const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding ); 01162 01163 private: 01164 01165 TiXmlAttributeSet attributeSet; 01166 }; 01167 01168 01171 class TiXmlComment : public TiXmlNode 01172 { 01173 public: 01175 TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {} 01177 TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::COMMENT ) { 01178 SetValue( _value ); 01179 } 01180 TiXmlComment( const TiXmlComment& ); 01181 void operator=( const TiXmlComment& base ); 01182 01183 virtual ~TiXmlComment() {} 01184 01186 virtual TiXmlNode* Clone() const; 01187 // Write this Comment to a FILE stream. 01188 virtual void Print( FILE* cfile, int depth ) const; 01189 01190 /* Attribtue parsing starts: at the ! of the !-- 01191 returns: next char past '>' 01192 */ 01193 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01194 01195 virtual const TiXmlComment* ToComment() const { return this; } 01196 virtual TiXmlComment* ToComment() { return this; } 01197 01200 virtual bool Accept( TiXmlVisitor* visitor ) const; 01201 01202 protected: 01203 void CopyTo( TiXmlComment* target ) const; 01204 01205 // used to be public 01206 #ifdef TIXML_USE_STL 01207 virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); 01208 #endif 01209 // virtual void StreamOut( TIXML_OSTREAM * out ) const; 01210 01211 private: 01212 01213 }; 01214 01215 01221 class TiXmlText : public TiXmlNode 01222 { 01223 friend class TiXmlElement; 01224 public: 01229 TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT) 01230 { 01231 SetValue( initValue ); 01232 cdata = false; 01233 } 01234 virtual ~TiXmlText() {} 01235 01236 #ifdef TIXML_USE_STL 01237 01238 TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT) 01239 { 01240 SetValue( initValue ); 01241 cdata = false; 01242 } 01243 #endif 01244 01245 TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT ) { copy.CopyTo( this ); } 01246 void operator=( const TiXmlText& base ) { base.CopyTo( this ); } 01247 01248 // Write this text object to a FILE stream. 01249 virtual void Print( FILE* cfile, int depth ) const; 01250 01252 bool CDATA() const { return cdata; } 01254 void SetCDATA( bool _cdata ) { cdata = _cdata; } 01255 01256 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01257 01258 virtual const TiXmlText* ToText() const { return this; } 01259 virtual TiXmlText* ToText() { return this; } 01260 01263 virtual bool Accept( TiXmlVisitor* content ) const; 01264 01265 protected : 01267 virtual TiXmlNode* Clone() const; 01268 void CopyTo( TiXmlText* target ) const; 01269 01270 bool Blank() const; // returns true if all white space and new lines 01271 // [internal use] 01272 #ifdef TIXML_USE_STL 01273 virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); 01274 #endif 01275 01276 private: 01277 bool cdata; // true if this should be input and output as a CDATA style text element 01278 }; 01279 01280 01294 class TiXmlDeclaration : public TiXmlNode 01295 { 01296 public: 01298 TiXmlDeclaration() : TiXmlNode( TiXmlNode::DECLARATION ) {} 01299 01300 #ifdef TIXML_USE_STL 01301 01302 TiXmlDeclaration( const std::string& _version, 01303 const std::string& _encoding, 01304 const std::string& _standalone ); 01305 #endif 01306 01308 TiXmlDeclaration( const char* _version, 01309 const char* _encoding, 01310 const char* _standalone ); 01311 01312 TiXmlDeclaration( const TiXmlDeclaration& copy ); 01313 void operator=( const TiXmlDeclaration& copy ); 01314 01315 virtual ~TiXmlDeclaration() {} 01316 01318 const char *Version() const { return version.c_str (); } 01320 const char *Encoding() const { return encoding.c_str (); } 01322 const char *Standalone() const { return standalone.c_str (); } 01323 01325 virtual TiXmlNode* Clone() const; 01326 // Print this declaration to a FILE stream. 01327 virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const; 01328 virtual void Print( FILE* cfile, int depth ) const { 01329 Print( cfile, depth, 0 ); 01330 } 01331 01332 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01333 01334 virtual const TiXmlDeclaration* ToDeclaration() const { return this; } 01335 virtual TiXmlDeclaration* ToDeclaration() { return this; } 01336 01339 virtual bool Accept( TiXmlVisitor* visitor ) const; 01340 01341 protected: 01342 void CopyTo( TiXmlDeclaration* target ) const; 01343 // used to be public 01344 #ifdef TIXML_USE_STL 01345 virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); 01346 #endif 01347 01348 private: 01349 01350 TIXML_STRING version; 01351 TIXML_STRING encoding; 01352 TIXML_STRING standalone; 01353 }; 01354 01364 class TiXmlStylesheetReference : public TiXmlNode 01365 { 01366 public: 01368 TiXmlStylesheetReference() : TiXmlNode( TiXmlNode::STYLESHEETREFERENCE ) {} 01369 01370 #ifdef TIXML_USE_STL 01371 01372 TiXmlStylesheetReference( const std::string& _type, 01373 const std::string& _href ); 01374 #endif 01375 01377 TiXmlStylesheetReference( const char* _type, 01378 const char* _href ); 01379 01380 TiXmlStylesheetReference( const TiXmlStylesheetReference& copy ); 01381 void operator=( const TiXmlStylesheetReference& copy ); 01382 01383 virtual ~TiXmlStylesheetReference() {} 01384 01386 const char *Type() const { return type.c_str (); } 01388 const char *Href() const { return href.c_str (); } 01389 01391 virtual TiXmlNode* Clone() const; 01392 // Print this declaration to a FILE stream. 01393 virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const; 01394 virtual void Print( FILE* cfile, int depth ) const { 01395 Print( cfile, depth, 0 ); 01396 } 01397 01398 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01399 01400 virtual const TiXmlStylesheetReference* ToStylesheetReference() const { return this; } 01401 virtual TiXmlStylesheetReference* ToStylesheetReference() { return this; } 01402 01405 virtual bool Accept( TiXmlVisitor* visitor ) const; 01406 01407 protected: 01408 void CopyTo( TiXmlStylesheetReference* target ) const; 01409 // used to be public 01410 #ifdef TIXML_USE_STL 01411 virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); 01412 #endif 01413 01414 private: 01415 01416 TIXML_STRING type; 01417 TIXML_STRING href; 01418 }; 01419 01427 class TiXmlUnknown : public TiXmlNode 01428 { 01429 public: 01430 TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN ) {} 01431 virtual ~TiXmlUnknown() {} 01432 01433 TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN ) { copy.CopyTo( this ); } 01434 void operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); } 01435 01437 virtual TiXmlNode* Clone() const; 01438 // Print this Unknown to a FILE stream. 01439 virtual void Print( FILE* cfile, int depth ) const; 01440 01441 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01442 01443 virtual const TiXmlUnknown* ToUnknown() const { return this; } 01444 virtual TiXmlUnknown* ToUnknown() { return this; } 01445 01448 virtual bool Accept( TiXmlVisitor* content ) const; 01449 01450 protected: 01451 void CopyTo( TiXmlUnknown* target ) const; 01452 01453 #ifdef TIXML_USE_STL 01454 virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); 01455 #endif 01456 01457 private: 01458 01459 }; 01460 01461 01466 class TiXmlDocument : public TiXmlNode 01467 { 01468 public: 01470 TiXmlDocument(); 01472 TiXmlDocument( const char * documentName ); 01473 01474 #ifdef TIXML_USE_STL 01475 01476 TiXmlDocument( const std::string& documentName ); 01477 #endif 01478 01479 TiXmlDocument( const TiXmlDocument& copy ); 01480 void operator=( const TiXmlDocument& copy ); 01481 01482 virtual ~TiXmlDocument() {} 01483 01488 bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); 01490 bool SaveFile() const; 01492 bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); 01494 bool SaveFile( const char * filename ) const; 01500 bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); 01502 bool SaveFile( FILE* ) const; 01503 01504 #ifdef TIXML_USE_STL 01505 bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ) 01506 { 01507 // StringToBuffer f( filename ); 01508 // return ( f.buffer && LoadFile( f.buffer, encoding )); 01509 return LoadFile( filename.c_str(), encoding ); 01510 } 01511 bool SaveFile( const std::string& filename ) const 01512 { 01513 // StringToBuffer f( filename ); 01514 // return ( f.buffer && SaveFile( f.buffer )); 01515 return SaveFile( filename.c_str() ); 01516 } 01517 #endif 01518 01523 virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); 01524 01529 const TiXmlElement* RootElement() const { return FirstChildElement(); } 01530 TiXmlElement* RootElement() { return FirstChildElement(); } 01531 01537 bool Error() const { return error; } 01538 01540 const char * ErrorDesc() const { return errorDesc.c_str (); } 01541 01545 int ErrorId() const { return errorId; } 01546 01554 int ErrorRow() const { return errorLocation.row+1; } 01555 int ErrorCol() const { return errorLocation.col+1; } 01556 01581 void SetTabSize( int _tabsize ) { tabsize = _tabsize; } 01582 01583 int TabSize() const { return tabsize; } 01584 01588 void ClearError() { error = false; 01589 errorId = 0; 01590 errorDesc = ""; 01591 errorLocation.row = errorLocation.col = 0; 01592 //errorLocation.last = 0; 01593 } 01594 01596 void Print() const { Print( stdout, 0 ); } 01597 01598 /* Write the document to a string using formatted printing ("pretty print"). This 01599 will allocate a character array (new char[]) and return it as a pointer. The 01600 calling code pust call delete[] on the return char* to avoid a memory leak. 01601 */ 01602 //char* PrintToMemory() const; 01603 01605 virtual void Print( FILE* cfile, int depth = 0 ) const; 01606 // [internal use] 01607 void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding ); 01608 01609 virtual const TiXmlDocument* ToDocument() const { return this; } 01610 virtual TiXmlDocument* ToDocument() { return this; } 01611 01614 virtual bool Accept( TiXmlVisitor* content ) const; 01615 01616 protected : 01617 // [internal use] 01618 virtual TiXmlNode* Clone() const; 01619 #ifdef TIXML_USE_STL 01620 virtual void StreamIn( std::istream * in, TIXML_STRING * tag ); 01621 #endif 01622 01623 private: 01624 void CopyTo( TiXmlDocument* target ) const; 01625 01626 bool error; 01627 int errorId; 01628 TIXML_STRING errorDesc; 01629 int tabsize; 01630 TiXmlCursor errorLocation; 01631 bool useMicrosoftBOM; // the UTF-8 BOM were found when read. Note this, and try to write. 01632 }; 01633 01634 01715 class TiXmlHandle 01716 { 01717 public: 01719 TiXmlHandle( TiXmlNode* _node ) { this->node = _node; } 01721 TiXmlHandle( const TiXmlHandle& ref ) { this->node = ref.node; } 01722 TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; } 01723 01725 TiXmlHandle FirstChild() const; 01727 TiXmlHandle FirstChild( const char * value ) const; 01729 TiXmlHandle FirstChildElement() const; 01731 TiXmlHandle FirstChildElement( const char * value ) const; 01732 01736 TiXmlHandle Child( const char* value, int index ) const; 01740 TiXmlHandle Child( int index ) const; 01745 TiXmlHandle ChildElement( const char* value, int index ) const; 01750 TiXmlHandle ChildElement( int index ) const; 01751 01752 #ifdef TIXML_USE_STL 01753 TiXmlHandle FirstChild( const std::string& _value ) const { return FirstChild( _value.c_str() ); } 01754 TiXmlHandle FirstChildElement( const std::string& _value ) const { return FirstChildElement( _value.c_str() ); } 01755 01756 TiXmlHandle Child( const std::string& _value, int index ) const { return Child( _value.c_str(), index ); } 01757 TiXmlHandle ChildElement( const std::string& _value, int index ) const { return ChildElement( _value.c_str(), index ); } 01758 #endif 01759 01762 TiXmlNode* ToNode() const { return node; } 01765 TiXmlElement* ToElement() const { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); } 01768 TiXmlText* ToText() const { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); } 01771 TiXmlUnknown* ToUnknown() const { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); } 01772 01776 TiXmlNode* Node() const { return ToNode(); } 01780 TiXmlElement* Element() const { return ToElement(); } 01784 TiXmlText* Text() const { return ToText(); } 01788 TiXmlUnknown* Unknown() const { return ToUnknown(); } 01789 01790 private: 01791 TiXmlNode* node; 01792 }; 01793 01794 01814 class TiXmlPrinter : public TiXmlVisitor 01815 { 01816 public: 01817 TiXmlPrinter() : depth( 0 ), simpleTextPrint( false ), 01818 buffer(), indent( " " ), lineBreak( "\n" ) {} 01819 01820 virtual bool VisitEnter( const TiXmlDocument& doc ); 01821 virtual bool VisitExit( const TiXmlDocument& doc ); 01822 01823 virtual bool VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute ); 01824 virtual bool VisitExit( const TiXmlElement& element ); 01825 01826 virtual bool Visit( const TiXmlDeclaration& declaration ); 01827 virtual bool Visit( const TiXmlText& text ); 01828 virtual bool Visit( const TiXmlComment& comment ); 01829 virtual bool Visit( const TiXmlUnknown& unknown ); 01830 01834 void SetIndent( const char* _indent ) { indent = _indent ? _indent : "" ; } 01836 const char* Indent() { return indent.c_str(); } 01841 void SetLineBreak( const char* _lineBreak ) { lineBreak = _lineBreak ? _lineBreak : ""; } 01843 const char* LineBreak() { return lineBreak.c_str(); } 01844 01848 void SetStreamPrinting() { indent = ""; 01849 lineBreak = ""; 01850 } 01852 const char* CStr() { return buffer.c_str(); } 01854 size_t Size() { return buffer.size(); } 01855 01856 #ifdef TIXML_USE_STL 01857 01858 const std::string& Str() { return buffer; } 01859 #endif 01860 01861 private: 01862 void DoIndent() { 01863 for( int i=0; i<depth; ++i ) 01864 buffer += indent; 01865 } 01866 void DoLineBreak() { 01867 buffer += lineBreak; 01868 } 01869 01870 int depth; 01871 bool simpleTextPrint; 01872 TIXML_STRING buffer; 01873 TIXML_STRING indent; 01874 TIXML_STRING lineBreak; 01875 }; 01876 01877 01878 #ifdef _MSC_VER 01879 #pragma warning( pop ) 01880 #endif 01881 01882 #endif 01883