Orocos Real-Time Toolkit
2.5.0
|
00001 /*************************************************************************** 00002 tag: Peter Soetens do nov 2 13:06:00 CET 2006 tinyxml.h 00003 00004 tinyxml.h - description 00005 ------------------- 00006 begin : do november 02 2006 00007 copyright : (C) 2006 Peter Soetens 00008 email : peter.soetens@gmail.com 00009 00010 *************************************************************************** 00011 * This library is free software; you can redistribute it and/or * 00012 * modify it under the terms of the GNU General Public * 00013 * License as published by the Free Software Foundation; * 00014 * version 2 of the License. * 00015 * * 00016 * As a special exception, you may use this file as part of a free * 00017 * software library without restriction. Specifically, if other files * 00018 * instantiate templates or use macros or inline functions from this * 00019 * file, or you compile this file and link it with other files to * 00020 * produce an executable, this file does not by itself cause the * 00021 * resulting executable to be covered by the GNU General Public * 00022 * License. This exception does not however invalidate any other * 00023 * reasons why the executable file might be covered by the GNU General * 00024 * Public License. * 00025 * * 00026 * This library is distributed in the hope that it will be useful, * 00027 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00028 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00029 * Lesser General Public License for more details. * 00030 * * 00031 * You should have received a copy of the GNU General Public * 00032 * License along with this library; if not, write to the Free Software * 00033 * Foundation, Inc., 59 Temple Place, * 00034 * Suite 330, Boston, MA 02111-1307 USA * 00035 * * 00036 ***************************************************************************/ 00037 00038 00039 /* 00040 www.sourceforge.net/projects/tinyxml 00041 Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com) 00042 00043 This software is provided 'as-is', without any express or implied 00044 warranty. In no event will the authors be held liable for any 00045 damages arising from the use of this software. 00046 00047 Permission is granted to anyone to use this software for any 00048 purpose, including commercial applications, and to alter it and 00049 redistribute it freely, subject to the following restrictions: 00050 00051 1. The origin of this software must not be misrepresented; you must 00052 not claim that you wrote the original software. If you use this 00053 software in a product, an acknowledgment in the product documentation 00054 would be appreciated but is not required. 00055 00056 2. Altered source versions must be plainly marked as such, and 00057 must not be misrepresented as being the original software. 00058 00059 3. This notice may not be removed or altered from any source 00060 distribution. 00061 */ 00062 00063 00064 #ifndef TINYXML_INCLUDED 00065 #define TINYXML_INCLUDED 00066 00067 #ifdef _MSC_VER 00068 #pragma warning( push ) 00069 #pragma warning( disable : 4530 ) 00070 #pragma warning( disable : 4786 ) 00071 #endif 00072 00073 #include <ctype.h> 00074 #include <stdio.h> 00075 #include <stdlib.h> 00076 #include <string.h> 00077 #include <assert.h> 00078 00079 // Help out windows: 00080 #if defined( _DEBUG ) && !defined( DEBUG ) 00081 #define DEBUG 00082 #endif 00083 00084 #ifdef TIXML_USE_STL 00085 #include <string> 00086 #include <iostream> 00087 #define TIXML_STRING std::string 00088 #define TIXML_ISTREAM std::istream 00089 #define TIXML_OSTREAM std::ostream 00090 #else 00091 #include "tinystr.h" 00092 #define TIXML_STRING TiXmlString 00093 #define TIXML_OSTREAM TiXmlOutStream 00094 #endif 00095 00096 // Deprecated library function hell. Compilers want to use the 00097 // new safe versions. This probably doesn't fully address the problem, 00098 // but it gets closer. There are too many compilers for me to fully 00099 // test. If you get compilation troubles, undefine TIXML_SAFE 00100 00101 #define TIXML_SAFE // TinyXml isn't fully buffer overrun protected, safe code. This is work in progress. 00102 #ifdef TIXML_SAFE 00103 #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) 00104 // Microsoft visual studio, version 2005 and higher. 00105 #define TIXML_SNPRINTF _snprintf_s 00106 #define TIXML_SNSCANF _snscanf_s 00107 #elif defined(_MSC_VER) && (_MSC_VER >= 1200 ) 00108 // Microsoft visual studio, version 6 and higher. 00109 //#pragma message( "Using _sn* functions." ) 00110 #define TIXML_SNPRINTF _snprintf 00111 #define TIXML_SNSCANF _snscanf 00112 #elif defined(__GNUC__) && (__GNUC__ >= 3 ) 00113 // GCC version 3 and higher.s 00114 //#warning( "Using sn* functions." ) 00115 #define TIXML_SNPRINTF snprintf 00116 #define TIXML_SNSCANF snscanf 00117 #endif 00118 #endif 00119 00120 namespace RTT { namespace marsh { 00121 00122 class TiXmlDocument; 00123 class TiXmlElement; 00124 class TiXmlComment; 00125 class TiXmlUnknown; 00126 class TiXmlAttribute; 00127 class TiXmlText; 00128 class TiXmlDeclaration; 00129 class TiXmlParsingData; 00130 00131 const int TIXML_MAJOR_VERSION = 2; 00132 const int TIXML_MINOR_VERSION = 4; 00133 const int TIXML_PATCH_VERSION = 3; 00134 00135 /* Internal structure for tracking location of items 00136 in the XML file. 00137 */ 00138 struct TiXmlCursor 00139 { 00140 TiXmlCursor() { Clear(); } 00141 void Clear() { row = col = -1; } 00142 00143 int row; // 0 based. 00144 int col; // 0 based. 00145 }; 00146 00147 00148 // Only used by Attribute::Query functions 00149 enum 00150 { 00151 TIXML_SUCCESS, 00152 TIXML_NO_ATTRIBUTE, 00153 TIXML_WRONG_TYPE 00154 }; 00155 00156 00157 // Used by the parsing routines. 00158 enum TiXmlEncoding 00159 { 00160 TIXML_ENCODING_UNKNOWN, 00161 TIXML_ENCODING_UTF8, 00162 TIXML_ENCODING_LEGACY 00163 }; 00164 00165 const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN; 00166 00189 class TiXmlBase 00190 { 00191 friend class TiXmlNode; 00192 friend class TiXmlElement; 00193 friend class TiXmlDocument; 00194 00195 public: 00196 TiXmlBase() : userData(0) {} 00197 virtual ~TiXmlBase() {} 00198 00204 virtual void Print( FILE* cfile, int depth ) const = 0; 00205 00212 static void SetCondenseWhiteSpace( bool condense ) { condenseWhiteSpace = condense; } 00213 00215 static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; } 00216 00235 int Row() const { return location.row + 1; } 00236 int Column() const { return location.col + 1; } 00237 00238 void SetUserData( void* user ) { userData = user; } 00239 void* GetUserData() { return userData; } 00240 00241 // Table that returs, for a given lead byte, the total number of bytes 00242 // in the UTF-8 sequence. 00243 static const int utf8ByteTable[256]; 00244 00245 virtual const char* Parse( const char* p, 00246 TiXmlParsingData* data, 00247 TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0; 00248 00249 enum 00250 { 00251 TIXML_NO_ERROR = 0, 00252 TIXML_ERROR, 00253 TIXML_ERROR_OPENING_FILE, 00254 TIXML_ERROR_OUT_OF_MEMORY, 00255 TIXML_ERROR_PARSING_ELEMENT, 00256 TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, 00257 TIXML_ERROR_READING_ELEMENT_VALUE, 00258 TIXML_ERROR_READING_ATTRIBUTES, 00259 TIXML_ERROR_PARSING_EMPTY, 00260 TIXML_ERROR_READING_END_TAG, 00261 TIXML_ERROR_PARSING_UNKNOWN, 00262 TIXML_ERROR_PARSING_COMMENT, 00263 TIXML_ERROR_PARSING_DECLARATION, 00264 TIXML_ERROR_DOCUMENT_EMPTY, 00265 TIXML_ERROR_EMBEDDED_NULL, 00266 TIXML_ERROR_PARSING_CDATA, 00267 00268 TIXML_ERROR_STRING_COUNT 00269 }; 00270 00271 protected: 00272 00273 // See STL_STRING_BUG 00274 // Utility class to overcome a bug. 00275 class StringToBuffer 00276 { 00277 public: 00278 StringToBuffer( const TIXML_STRING& str ); 00279 ~StringToBuffer(); 00280 char* buffer; 00281 }; 00282 00283 static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding ); 00284 inline static bool IsWhiteSpace( char c ) 00285 { 00286 return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); 00287 } 00288 inline static bool IsWhiteSpace( int c ) 00289 { 00290 if ( c < 256 ) 00291 return IsWhiteSpace( (char) c ); 00292 return false; // Again, only truly correct for English/Latin...but usually works. 00293 } 00294 00295 virtual void StreamOut (TIXML_OSTREAM *) const = 0; 00296 00297 #ifdef TIXML_USE_STL 00298 static bool StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag ); 00299 static bool StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag ); 00300 #endif 00301 00302 /* Reads an XML name into the string provided. Returns 00303 a pointer just past the last character of the name, 00304 or 0 if the function has an error. 00305 */ 00306 static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding ); 00307 00308 /* Reads text. Returns a pointer past the given end tag. 00309 Wickedly complex options, but it keeps the (sensitive) code in one place. 00310 */ 00311 static const char* ReadText( const char* in, // where to start 00312 TIXML_STRING* text, // the string read 00313 bool ignoreWhiteSpace, // whether to keep the white space 00314 const char* endTag, // what ends this text 00315 bool ignoreCase, // whether to ignore case in the end tag 00316 TiXmlEncoding encoding ); // the current encoding 00317 00318 // If an entity has been found, transform it into a character. 00319 static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding ); 00320 00321 // Get a character, while interpreting entities. 00322 // The length can be from 0 to 4 bytes. 00323 inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding ) 00324 { 00325 assert( p ); 00326 if ( encoding == TIXML_ENCODING_UTF8 ) 00327 { 00328 *length = utf8ByteTable[ *((unsigned char*)p) ]; 00329 assert( *length >= 0 && *length < 5 ); 00330 } 00331 else 00332 { 00333 *length = 1; 00334 } 00335 00336 if ( *length == 1 ) 00337 { 00338 if ( *p == '&' ) 00339 return GetEntity( p, _value, length, encoding ); 00340 *_value = *p; 00341 return p+1; 00342 } 00343 else if ( *length ) 00344 { 00345 //strncpy( _value, p, *length ); // lots of compilers don't like this function (unsafe), 00346 // and the null terminator isn't needed 00347 for( int i=0; p[i] && i<*length; ++i ) { 00348 _value[i] = p[i]; 00349 } 00350 return p + (*length); 00351 } 00352 else 00353 { 00354 // Not valid text. 00355 return 0; 00356 } 00357 } 00358 00359 // Puts a string to a stream, expanding entities as it goes. 00360 // Note this should not contian the '<', '>', etc, or they will be transformed into entities! 00361 static void PutString( const TIXML_STRING& str, TIXML_OSTREAM* out ); 00362 00363 static void PutString( const TIXML_STRING& str, TIXML_STRING* out ); 00364 00365 // Return true if the next characters in the stream are any of the endTag sequences. 00366 // Ignore case only works for english, and should only be relied on when comparing 00367 // to English words: StringEqual( p, "version", true ) is fine. 00368 static bool StringEqual( const char* p, 00369 const char* endTag, 00370 bool ignoreCase, 00371 TiXmlEncoding encoding ); 00372 00373 static const char* errorString[ TIXML_ERROR_STRING_COUNT ]; 00374 00375 TiXmlCursor location; 00376 00378 void* userData; 00379 00380 // None of these methods are reliable for any language except English. 00381 // Good for approximation, not great for accuracy. 00382 static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding ); 00383 static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding ); 00384 inline static int ToLower( int v, TiXmlEncoding encoding ) 00385 { 00386 if ( encoding == TIXML_ENCODING_UTF8 ) 00387 { 00388 if ( v < 128 ) return tolower( v ); 00389 return v; 00390 } 00391 else 00392 { 00393 return tolower( v ); 00394 } 00395 } 00396 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length ); 00397 00398 private: 00399 TiXmlBase( const TiXmlBase& ); // not implemented. 00400 void operator=( const TiXmlBase& base ); // not allowed. 00401 00402 struct Entity 00403 { 00404 const char* str; 00405 unsigned int strLength; 00406 char chr; 00407 }; 00408 enum 00409 { 00410 NUM_ENTITY = 5, 00411 MAX_ENTITY_LENGTH = 6 00412 00413 }; 00414 static Entity entity[ NUM_ENTITY ]; 00415 static bool condenseWhiteSpace; 00416 }; 00417 00418 00425 class TiXmlNode : public TiXmlBase 00426 { 00427 friend class TiXmlDocument; 00428 friend class TiXmlElement; 00429 00430 public: 00431 #ifdef TIXML_USE_STL 00432 00436 friend std::istream& operator >> (std::istream& in, TiXmlNode& base); 00437 00454 friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base); 00455 00457 friend std::string& operator<< (std::string& out, const TiXmlNode& base ); 00458 00459 #else 00460 // Used internally, not part of the public API. 00461 friend TIXML_OSTREAM& operator<< (TIXML_OSTREAM& out, const TiXmlNode& base); 00462 #endif 00463 00467 enum NodeType 00468 { 00469 DOCUMENT, 00470 ELEMENT, 00471 COMMENT, 00472 UNKNOWN, 00473 TEXT, 00474 DECLARATION, 00475 TYPECOUNT 00476 }; 00477 00478 virtual ~TiXmlNode(); 00479 00492 const char *Value() const { return value.c_str (); } 00493 00494 #ifdef TIXML_USE_STL 00495 00499 const std::string& ValueStr() const { return value; } 00500 #endif 00501 00511 void SetValue(const char * _value) { value = _value;} 00512 00513 #ifdef TIXML_USE_STL 00514 00515 void SetValue( const std::string& _value ) { value = _value; } 00516 #endif 00517 00519 void Clear(); 00520 00522 TiXmlNode* Parent() { return parent; } 00523 const TiXmlNode* Parent() const { return parent; } 00524 00525 const TiXmlNode* FirstChild() const { return firstChild; } 00526 TiXmlNode* FirstChild() { return firstChild; } 00527 const TiXmlNode* FirstChild( const char * value ) const; 00528 TiXmlNode* FirstChild( const char * value ); 00529 00530 const TiXmlNode* LastChild() const { return lastChild; } 00531 TiXmlNode* LastChild() { return lastChild; } 00532 const TiXmlNode* LastChild( const char * value ) const; 00533 TiXmlNode* LastChild( const char * value ); 00534 00535 #ifdef TIXML_USE_STL 00536 const TiXmlNode* FirstChild( const std::string& _value ) const { return FirstChild (_value.c_str ()); } 00537 TiXmlNode* FirstChild( const std::string& _value ) { return FirstChild (_value.c_str ()); } 00538 const TiXmlNode* LastChild( const std::string& _value ) const { return LastChild (_value.c_str ()); } 00539 TiXmlNode* LastChild( const std::string& _value ) { return LastChild (_value.c_str ()); } 00540 #endif 00541 00558 const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const; 00559 TiXmlNode* IterateChildren( TiXmlNode* previous ); 00560 00562 const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const; 00563 TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous ); 00564 00565 #ifdef TIXML_USE_STL 00566 const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const { return IterateChildren (_value.c_str (), previous); } 00567 TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) { return IterateChildren (_value.c_str (), previous); } 00568 #endif 00569 00573 TiXmlNode* InsertEndChild( const TiXmlNode& addThis ); 00574 00575 00585 TiXmlNode* LinkEndChild( TiXmlNode* addThis ); 00586 00590 TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis ); 00591 00595 TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis ); 00596 00600 TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis ); 00601 00603 bool RemoveChild( TiXmlNode* removeThis ); 00604 00606 const TiXmlNode* PreviousSibling() const { return prev; } 00607 TiXmlNode* PreviousSibling() { return prev; } 00608 00610 const TiXmlNode* PreviousSibling( const char * ) const; 00611 TiXmlNode* PreviousSibling( const char * ); 00612 00613 #ifdef TIXML_USE_STL 00614 const TiXmlNode* PreviousSibling( const std::string& _value ) const { return PreviousSibling (_value.c_str ()); } 00615 TiXmlNode* PreviousSibling( const std::string& _value ) { return PreviousSibling (_value.c_str ()); } 00616 const TiXmlNode* NextSibling( const std::string& _value) const { return NextSibling (_value.c_str ()); } 00617 TiXmlNode* NextSibling( const std::string& _value) { return NextSibling (_value.c_str ()); } 00618 #endif 00619 00621 const TiXmlNode* NextSibling() const { return next; } 00622 TiXmlNode* NextSibling() { return next; } 00623 00625 const TiXmlNode* NextSibling( const char * ) const; 00626 TiXmlNode* NextSibling( const char * ); 00627 00632 const TiXmlElement* NextSiblingElement() const; 00633 TiXmlElement* NextSiblingElement(); 00634 00639 const TiXmlElement* NextSiblingElement( const char * ) const; 00640 TiXmlElement* NextSiblingElement( const char * ); 00641 00642 #ifdef TIXML_USE_STL 00643 const TiXmlElement* NextSiblingElement( const std::string& _value) const { return NextSiblingElement (_value.c_str ()); } 00644 TiXmlElement* NextSiblingElement( const std::string& _value) { return NextSiblingElement (_value.c_str ()); } 00645 #endif 00646 00648 const TiXmlElement* FirstChildElement() const; 00649 TiXmlElement* FirstChildElement(); 00650 00652 const TiXmlElement* FirstChildElement( const char * value ) const; 00653 TiXmlElement* FirstChildElement( const char * value ); 00654 00655 #ifdef TIXML_USE_STL 00656 const TiXmlElement* FirstChildElement( const std::string& _value ) const { return FirstChildElement (_value.c_str ()); } 00657 TiXmlElement* FirstChildElement( const std::string& _value ) { return FirstChildElement (_value.c_str ()); } 00658 #endif 00659 00664 int Type() const { return type; } 00665 00669 const TiXmlDocument* GetDocument() const; 00670 TiXmlDocument* GetDocument(); 00671 00673 bool NoChildren() const { return !firstChild; } 00674 00675 virtual const TiXmlDocument* ToDocument() const { return 0; } 00676 virtual const TiXmlElement* ToElement() const { return 0; } 00677 virtual const TiXmlComment* ToComment() const { return 0; } 00678 virtual const TiXmlUnknown* ToUnknown() const { return 0; } 00679 virtual const TiXmlText* ToText() const { return 0; } 00680 virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } 00681 00682 virtual TiXmlDocument* ToDocument() { return 0; } 00683 virtual TiXmlElement* ToElement() { return 0; } 00684 virtual TiXmlComment* ToComment() { return 0; } 00685 virtual TiXmlUnknown* ToUnknown() { return 0; } 00686 virtual TiXmlText* ToText() { return 0; } 00687 virtual TiXmlDeclaration* ToDeclaration() { return 0; } 00688 00692 virtual TiXmlNode* Clone() const = 0; 00693 00694 protected: 00695 TiXmlNode( NodeType _type ); 00696 00697 // Copy to the allocated object. Shared functionality between Clone, Copy constructor, 00698 // and the assignment operator. 00699 void CopyTo( TiXmlNode* target ) const; 00700 00701 #ifdef TIXML_USE_STL 00702 // The real work of the input operator. 00703 virtual void StreamIn( TIXML_ISTREAM* in, TIXML_STRING* tag ) = 0; 00704 #endif 00705 00706 // Figure out what is at *p, and parse it. Returns null if it is not an xml node. 00707 TiXmlNode* Identify( const char* start, TiXmlEncoding encoding ); 00708 00709 TiXmlNode* parent; 00710 NodeType type; 00711 00712 TiXmlNode* firstChild; 00713 TiXmlNode* lastChild; 00714 00715 TIXML_STRING value; 00716 00717 TiXmlNode* prev; 00718 TiXmlNode* next; 00719 00720 private: 00721 TiXmlNode( const TiXmlNode& ); // not implemented. 00722 void operator=( const TiXmlNode& base ); // not allowed. 00723 }; 00724 00725 00733 class TiXmlAttribute : public TiXmlBase 00734 { 00735 friend class TiXmlAttributeSet; 00736 00737 public: 00739 TiXmlAttribute() : TiXmlBase() 00740 { 00741 document = 0; 00742 prev = next = 0; 00743 } 00744 00745 #ifdef TIXML_USE_STL 00746 00747 TiXmlAttribute( const std::string& _name, const std::string& _value ) 00748 { 00749 name = _name; 00750 value = _value; 00751 document = 0; 00752 prev = next = 0; 00753 } 00754 #endif 00755 00757 TiXmlAttribute( const char * _name, const char * _value ) 00758 { 00759 name = _name; 00760 value = _value; 00761 document = 0; 00762 prev = next = 0; 00763 } 00764 00765 const char* Name() const { return name.c_str (); } 00766 const char* Value() const { return value.c_str (); } 00767 int IntValue() const; 00768 double DoubleValue() const; 00769 00770 // Get the tinyxml string representation 00771 const TIXML_STRING& NameTStr() const { return name; } 00772 00782 int QueryIntValue( int* _value ) const; 00784 int QueryDoubleValue( double* _value ) const; 00785 00786 void SetName( const char* _name ) { name = _name; } 00787 void SetValue( const char* _value ) { value = _value; } 00788 00789 void SetIntValue( int _value ); 00790 void SetDoubleValue( double _value ); 00791 00792 #ifdef TIXML_USE_STL 00793 00794 void SetName( const std::string& _name ) { name = _name; } 00796 void SetValue( const std::string& _value ) { value = _value; } 00797 #endif 00798 00800 const TiXmlAttribute* Next() const; 00801 TiXmlAttribute* Next(); 00803 const TiXmlAttribute* Previous() const; 00804 TiXmlAttribute* Previous(); 00805 00806 bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; } 00807 bool operator<( const TiXmlAttribute& rhs ) const { return name < rhs.name; } 00808 bool operator>( const TiXmlAttribute& rhs ) const { return name > rhs.name; } 00809 00810 /* Attribute parsing starts: first letter of the name 00811 returns: the next char after the value end quote 00812 */ 00813 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 00814 00815 // Prints this Attribute to a FILE stream. 00816 virtual void Print( FILE* cfile, int depth ) const; 00817 00818 virtual void StreamOut( TIXML_OSTREAM * out ) const; 00819 // [internal use] 00820 // Set the document pointer so the attribute can report errors. 00821 void SetDocument( TiXmlDocument* doc ) { document = doc; } 00822 00823 private: 00824 TiXmlAttribute( const TiXmlAttribute& ); // not implemented. 00825 void operator=( const TiXmlAttribute& base ); // not allowed. 00826 00827 TiXmlDocument* document; // A pointer back to a document, for error reporting. 00828 TIXML_STRING name; 00829 TIXML_STRING value; 00830 TiXmlAttribute* prev; 00831 TiXmlAttribute* next; 00832 }; 00833 00834 00835 /* A class used to manage a group of attributes. 00836 It is only used internally, both by the ELEMENT and the DECLARATION. 00837 00838 The set can be changed transparent to the Element and Declaration 00839 classes that use it, but NOT transparent to the Attribute 00840 which has to implement a next() and previous() method. Which makes 00841 it a bit problematic and prevents the use of STL. 00842 00843 This version is implemented with circular lists because: 00844 - I like circular lists 00845 - it demonstrates some independence from the (typical) doubly linked list. 00846 */ 00847 class TiXmlAttributeSet 00848 { 00849 public: 00850 TiXmlAttributeSet(); 00851 ~TiXmlAttributeSet(); 00852 00853 void Add( TiXmlAttribute* attribute ); 00854 void Remove( TiXmlAttribute* attribute ); 00855 00856 const TiXmlAttribute* First() const { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; } 00857 TiXmlAttribute* First() { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; } 00858 const TiXmlAttribute* Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; } 00859 TiXmlAttribute* Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; } 00860 00861 const TiXmlAttribute* Find( const TIXML_STRING& name ) const; 00862 TiXmlAttribute* Find( const TIXML_STRING& name ); 00863 00864 private: 00865 //*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element), 00866 //*ME: this class must be also use a hidden/disabled copy-constructor !!! 00867 TiXmlAttributeSet( const TiXmlAttributeSet& ); // not allowed 00868 void operator=( const TiXmlAttributeSet& ); // not allowed (as TiXmlAttribute) 00869 00870 TiXmlAttribute sentinel; 00871 }; 00872 00873 00878 class TiXmlElement : public TiXmlNode 00879 { 00880 public: 00882 TiXmlElement (const char * in_value); 00883 00884 #ifdef TIXML_USE_STL 00885 00886 TiXmlElement( const std::string& _value ); 00887 #endif 00888 00889 TiXmlElement( const TiXmlElement& ); 00890 00891 void operator=( const TiXmlElement& base ); 00892 00893 virtual ~TiXmlElement(); 00894 00898 const char* Attribute( const char* name ) const; 00899 00906 const char* Attribute( const char* name, int* i ) const; 00907 00914 const char* Attribute( const char* name, double* d ) const; 00915 00923 int QueryIntAttribute( const char* name, int* _value ) const; 00925 int QueryDoubleAttribute( const char* name, double* _value ) const; 00927 int QueryFloatAttribute( const char* name, float* _value ) const { 00928 double d; 00929 int result = QueryDoubleAttribute( name, &d ); 00930 if ( result == TIXML_SUCCESS ) { 00931 *_value = (float)d; 00932 } 00933 return result; 00934 } 00935 00939 void SetAttribute( const char* name, const char * _value ); 00940 00941 #ifdef TIXML_USE_STL 00942 const char* Attribute( const std::string& name ) const { return Attribute( name.c_str() ); } 00943 const char* Attribute( const std::string& name, int* i ) const { return Attribute( name.c_str(), i ); } 00944 const char* Attribute( const std::string& name, double* d ) const { return Attribute( name.c_str(), d ); } 00945 int QueryIntAttribute( const std::string& name, int* _value ) const { return QueryIntAttribute( name.c_str(), _value ); } 00946 int QueryDoubleAttribute( const std::string& name, double* _value ) const { return QueryDoubleAttribute( name.c_str(), _value ); } 00947 00949 void SetAttribute( const std::string& name, const std::string& _value ); 00951 void SetAttribute( const std::string& name, int _value ); 00952 #endif 00953 00957 void SetAttribute( const char * name, int value ); 00958 00962 void SetDoubleAttribute( const char * name, double value ); 00963 00966 void RemoveAttribute( const char * name ); 00967 #ifdef TIXML_USE_STL 00968 void RemoveAttribute( const std::string& name ) { RemoveAttribute (name.c_str ()); } 00969 #endif 00970 00971 const TiXmlAttribute* FirstAttribute() const { return attributeSet.First(); } 00972 TiXmlAttribute* FirstAttribute() { return attributeSet.First(); } 00973 const TiXmlAttribute* LastAttribute() const { return attributeSet.Last(); } 00974 TiXmlAttribute* LastAttribute() { return attributeSet.Last(); } 00975 01008 const char* GetText() const; 01009 01011 virtual TiXmlNode* Clone() const; 01012 // Print the Element to a FILE stream. 01013 virtual void Print( FILE* cfile, int depth ) const; 01014 01015 /* Attribtue parsing starts: next char past '<' 01016 returns: next char past '>' 01017 */ 01018 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01019 01020 virtual const TiXmlElement* ToElement() const { return this; } 01021 virtual TiXmlElement* ToElement() { return this; } 01022 01023 protected: 01024 01025 void CopyTo( TiXmlElement* target ) const; 01026 void ClearThis(); // like clear, but initializes 'this' object as well 01027 01028 // Used to be public [internal use] 01029 #ifdef TIXML_USE_STL 01030 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag ); 01031 #endif 01032 virtual void StreamOut( TIXML_OSTREAM * out ) const; 01033 01034 /* [internal use] 01035 Reads the "value" of the element -- another element, or text. 01036 This should terminate with the current end tag. 01037 */ 01038 const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding ); 01039 01040 private: 01041 01042 TiXmlAttributeSet attributeSet; 01043 }; 01044 01045 01048 class TiXmlComment : public TiXmlNode 01049 { 01050 public: 01052 TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {} 01053 TiXmlComment( const TiXmlComment& ); 01054 void operator=( const TiXmlComment& base ); 01055 01056 virtual ~TiXmlComment() {} 01057 01059 virtual TiXmlNode* Clone() const; 01061 virtual void Print( FILE* cfile, int depth ) const; 01062 01063 /* Attribtue parsing starts: at the ! of the !-- 01064 returns: next char past '>' 01065 */ 01066 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01067 01068 virtual const TiXmlComment* ToComment() const { return this; } 01069 virtual TiXmlComment* ToComment() { return this; } 01070 01071 protected: 01072 void CopyTo( TiXmlComment* target ) const; 01073 01074 // used to be public 01075 #ifdef TIXML_USE_STL 01076 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag ); 01077 #endif 01078 virtual void StreamOut( TIXML_OSTREAM * out ) const; 01079 01080 private: 01081 01082 }; 01083 01084 01090 class TiXmlText : public TiXmlNode 01091 { 01092 friend class TiXmlElement; 01093 public: 01098 TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT) 01099 { 01100 SetValue( initValue ); 01101 cdata = false; 01102 } 01103 virtual ~TiXmlText() {} 01104 01105 #ifdef TIXML_USE_STL 01106 01107 TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT) 01108 { 01109 SetValue( initValue ); 01110 cdata = false; 01111 } 01112 #endif 01113 01114 TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT ) { copy.CopyTo( this ); } 01115 void operator=( const TiXmlText& base ) { base.CopyTo( this ); } 01116 01118 virtual void Print( FILE* cfile, int depth ) const; 01119 01121 bool CDATA() { return cdata; } 01123 void SetCDATA( bool _cdata ) { cdata = _cdata; } 01124 01125 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01126 01127 virtual const TiXmlText* ToText() const { return this; } 01128 virtual TiXmlText* ToText() { return this; } 01129 01130 protected : 01132 virtual TiXmlNode* Clone() const; 01133 void CopyTo( TiXmlText* target ) const; 01134 01135 virtual void StreamOut ( TIXML_OSTREAM * out ) const; 01136 bool Blank() const; // returns true if all white space and new lines 01137 // [internal use] 01138 #ifdef TIXML_USE_STL 01139 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag ); 01140 #endif 01141 01142 private: 01143 bool cdata; // true if this should be input and output as a CDATA style text element 01144 }; 01145 01146 01160 class TiXmlDeclaration : public TiXmlNode 01161 { 01162 public: 01164 TiXmlDeclaration() : TiXmlNode( TiXmlNode::DECLARATION ) {} 01165 01166 #ifdef TIXML_USE_STL 01167 01168 TiXmlDeclaration( const std::string& _version, 01169 const std::string& _encoding, 01170 const std::string& _standalone ); 01171 #endif 01172 01174 TiXmlDeclaration( const char* _version, 01175 const char* _encoding, 01176 const char* _standalone ); 01177 01178 TiXmlDeclaration( const TiXmlDeclaration& copy ); 01179 void operator=( const TiXmlDeclaration& copy ); 01180 01181 virtual ~TiXmlDeclaration() {} 01182 01184 const char *Version() const { return version.c_str (); } 01186 const char *Encoding() const { return encoding.c_str (); } 01188 const char *Standalone() const { return standalone.c_str (); } 01189 01191 virtual TiXmlNode* Clone() const; 01193 virtual void Print( FILE* cfile, int depth ) const; 01194 01195 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01196 01197 virtual const TiXmlDeclaration* ToDeclaration() const { return this; } 01198 virtual TiXmlDeclaration* ToDeclaration() { return this; } 01199 01200 protected: 01201 void CopyTo( TiXmlDeclaration* target ) const; 01202 // used to be public 01203 #ifdef TIXML_USE_STL 01204 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag ); 01205 #endif 01206 virtual void StreamOut ( TIXML_OSTREAM * out) const; 01207 01208 private: 01209 01210 TIXML_STRING version; 01211 TIXML_STRING encoding; 01212 TIXML_STRING standalone; 01213 }; 01214 01215 01223 class TiXmlUnknown : public TiXmlNode 01224 { 01225 public: 01226 TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN ) {} 01227 virtual ~TiXmlUnknown() {} 01228 01229 TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN ) { copy.CopyTo( this ); } 01230 void operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); } 01231 01233 virtual TiXmlNode* Clone() const; 01235 virtual void Print( FILE* cfile, int depth ) const; 01236 01237 virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ); 01238 01239 virtual const TiXmlUnknown* ToUnknown() const { return this; } 01240 virtual TiXmlUnknown* ToUnknown() { return this; } 01241 01242 protected: 01243 void CopyTo( TiXmlUnknown* target ) const; 01244 01245 #ifdef TIXML_USE_STL 01246 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag ); 01247 #endif 01248 virtual void StreamOut ( TIXML_OSTREAM * out ) const; 01249 01250 private: 01251 01252 }; 01253 01254 01259 class TiXmlDocument : public TiXmlNode 01260 { 01261 public: 01263 TiXmlDocument(); 01265 TiXmlDocument( const char * documentName ); 01266 01267 #ifdef TIXML_USE_STL 01268 01269 TiXmlDocument( const std::string& documentName ); 01270 #endif 01271 01272 TiXmlDocument( const TiXmlDocument& copy ); 01273 void operator=( const TiXmlDocument& copy ); 01274 01275 virtual ~TiXmlDocument() {} 01276 01281 bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); 01283 bool SaveFile() const; 01285 bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); 01287 bool SaveFile( const char * filename ) const; 01293 bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); 01295 bool SaveFile( FILE* ) const; 01296 01297 #ifdef TIXML_USE_STL 01298 bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ) 01299 { 01300 StringToBuffer f( filename ); 01301 return ( f.buffer && LoadFile( f.buffer, encoding )); 01302 } 01303 bool SaveFile( const std::string& filename ) const 01304 { 01305 StringToBuffer f( filename ); 01306 return ( f.buffer && SaveFile( f.buffer )); 01307 } 01308 #endif 01309 01314 virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING ); 01315 01320 const TiXmlElement* RootElement() const { return FirstChildElement(); } 01321 TiXmlElement* RootElement() { return FirstChildElement(); } 01322 01328 bool Error() const { return error; } 01329 01331 const char * ErrorDesc() const { return errorDesc.c_str (); } 01332 01336 int ErrorId() const { return errorId; } 01337 01345 int ErrorRow() { return errorLocation.row+1; } 01346 int ErrorCol() { return errorLocation.col+1; } 01347 01372 void SetTabSize( int _tabsize ) { tabsize = _tabsize; } 01373 01374 int TabSize() const { return tabsize; } 01375 01379 void ClearError() { error = false; 01380 errorId = 0; 01381 errorDesc = ""; 01382 errorLocation.row = errorLocation.col = 0; 01383 //errorLocation.last = 0; 01384 } 01385 01387 void Print() const { Print( stdout, 0 ); } 01388 01390 virtual void Print( FILE* cfile, int depth = 0 ) const; 01391 // [internal use] 01392 void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding ); 01393 01394 virtual const TiXmlDocument* ToDocument() const { return this; } 01395 virtual TiXmlDocument* ToDocument() { return this; } 01396 01397 protected : 01398 virtual void StreamOut ( TIXML_OSTREAM * out) const; 01399 // [internal use] 01400 virtual TiXmlNode* Clone() const; 01401 #ifdef TIXML_USE_STL 01402 virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag ); 01403 #endif 01404 01405 private: 01406 void CopyTo( TiXmlDocument* target ) const; 01407 01408 bool error; 01409 int errorId; 01410 TIXML_STRING errorDesc; 01411 int tabsize; 01412 TiXmlCursor errorLocation; 01413 bool useMicrosoftBOM; // the UTF-8 BOM were found when read. Note this, and try to write. 01414 }; 01415 01416 01497 class TiXmlHandle 01498 { 01499 public: 01501 TiXmlHandle( TiXmlNode* _node ) { this->node = _node; } 01503 TiXmlHandle( const TiXmlHandle& ref ) { this->node = ref.node; } 01504 TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; } 01505 01507 TiXmlHandle FirstChild() const; 01509 TiXmlHandle FirstChild( const char * value ) const; 01511 TiXmlHandle FirstChildElement() const; 01513 TiXmlHandle FirstChildElement( const char * value ) const; 01514 01518 TiXmlHandle Child( const char* value, int index ) const; 01522 TiXmlHandle Child( int index ) const; 01527 TiXmlHandle ChildElement( const char* value, int index ) const; 01532 TiXmlHandle ChildElement( int index ) const; 01533 01534 #ifdef TIXML_USE_STL 01535 TiXmlHandle FirstChild( const std::string& _value ) const { return FirstChild( _value.c_str() ); } 01536 TiXmlHandle FirstChildElement( const std::string& _value ) const { return FirstChildElement( _value.c_str() ); } 01537 01538 TiXmlHandle Child( const std::string& _value, int index ) const { return Child( _value.c_str(), index ); } 01539 TiXmlHandle ChildElement( const std::string& _value, int index ) const { return ChildElement( _value.c_str(), index ); } 01540 #endif 01541 01543 TiXmlNode* Node() const { return node; } 01545 TiXmlElement* Element() const { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); } 01547 TiXmlText* Text() const { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); } 01549 TiXmlUnknown* Unknown() const { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); } 01550 01551 private: 01552 TiXmlNode* node; 01553 }; 01554 01555 }} 01556 01557 #ifdef _MSC_VER 01558 #pragma warning( pop ) 01559 #endif 01560 01561 #endif 01562