edelib  2.0.0
edelib/TiXml.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 __EDELIB_TIXML_H__
00027 #define __EDELIB_TIXML_H__
00028 
00029 #include <ctype.h>
00030 #include <stdio.h>
00031 #include <stdlib.h>
00032 #include <string.h>
00033 #include <assert.h>
00034 
00035 // Help out windows:
00036 #if defined( _DEBUG ) && !defined( DEBUG )
00037 #define DEBUG
00038 #endif
00039 
00040 #ifdef TIXML_USE_STL
00041         #include <string>
00042         #include <iostream>
00043         #include <sstream>
00044         #define TIXML_STRING            std::string
00045 #else
00046         #include "String.h"
00047         #define TIXML_STRING            EDELIB_NS_PREPEND(String)
00048 #endif
00049 
00050 // Deprecated library function hell. Compilers want to use the
00051 // new safe versions. This probably doesn't fully address the problem,
00052 // but it gets closer. There are too many compilers for me to fully
00053 // test. If you get compilation troubles, undefine TIXML_SAFE
00054 #define TIXML_SAFE
00055 
00056 #ifdef TIXML_SAFE
00057         #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
00058                 // Microsoft visual studio, version 2005 and higher.
00059                 #define TIXML_SNPRINTF _snprintf_s
00060                 #define TIXML_SNSCANF  _snscanf_s
00061         #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
00062                 // Microsoft visual studio, version 6 and higher.
00063                 //#pragma message( "Using _sn* functions." )
00064                 #define TIXML_SNPRINTF _snprintf
00065                 #define TIXML_SNSCANF  _snscanf
00066         #elif defined(__GNUC__) && (__GNUC__ >= 3 )
00067                 // GCC version 3 and higher.s
00068                 //#warning( "Using sn* functions." )
00069                 #define TIXML_SNPRINTF snprintf
00070                 #define TIXML_SNSCANF  snscanf
00071         #endif
00072 #endif  
00073 
00074 class TiXmlDocument;
00075 class TiXmlElement;
00076 class TiXmlComment;
00077 class TiXmlUnknown;
00078 class TiXmlAttribute;
00079 class TiXmlText;
00080 class TiXmlDeclaration;
00081 class TiXmlParsingData;
00082 
00083 const int TIXML_MAJOR_VERSION = 2;
00084 const int TIXML_MINOR_VERSION = 5;
00085 const int TIXML_PATCH_VERSION = 2;
00086 
00087 #ifndef SKIP_DOCS
00088 /*      
00089  * Internal structure for tracking location of items 
00090  * in the XML file.
00091  */
00092 struct TiXmlCursor
00093 {
00094         TiXmlCursor()           { Clear(); }
00095         void Clear()            { row = col = -1; }
00096 
00097         int row;        // 0 based.
00098         int col;        // 0 based.
00099 };
00100 #endif
00101 
00123 class TiXmlVisitor
00124 {
00125 public:
00127         virtual ~TiXmlVisitor() {}
00128 
00130         virtual bool VisitEnter( const TiXmlDocument& doc )     { return true; }
00132         virtual bool VisitExit( const TiXmlDocument& doc )      { return true; }
00134         virtual bool VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute )    { return true; }
00136         virtual bool VisitExit( const TiXmlElement& element )                                                                                   { return true; }
00138         virtual bool Visit( const TiXmlDeclaration& declaration )               { return true; }
00140         virtual bool Visit( const TiXmlText& text )                                             { return true; }
00142         virtual bool Visit( const TiXmlComment& comment )                               { return true; }
00144         virtual bool Visit( const TiXmlUnknown& unknown )                               { return true; }
00145 };
00146 
00147 // Only used by Attribute::Query functions
00148 enum 
00149 { 
00150         TIXML_SUCCESS,
00151         TIXML_NO_ATTRIBUTE,
00152         TIXML_WRONG_TYPE
00153 };
00154 
00155 // Used by the parsing routines.
00156 enum TiXmlEncoding
00157 {
00158         TIXML_ENCODING_UNKNOWN,
00159         TIXML_ENCODING_UTF8,
00160         TIXML_ENCODING_LEGACY
00161 };
00162 
00163 const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
00164 
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 
00214         virtual void Print( FILE* cfile, int depth ) const = 0;
00215 
00223         static void SetCondenseWhiteSpace( bool condense )              { condenseWhiteSpace = condense; }
00224 
00226         static bool IsWhiteSpaceCondensed()                                             { return condenseWhiteSpace; }
00227 
00246         int Row() const                 { return location.row + 1; }
00248         int Column() const              { return location.col + 1; }
00250         void  SetUserData( void* user )                 { userData = user; }
00252         void* GetUserData()                                             { return userData; }
00254         const void* GetUserData() const                 { return userData; }
00255 #ifndef SKIP_DOCS
00256         // Table that returs, for a given lead byte, the total number of bytes
00257         // in the UTF-8 sequence.
00258         static const int utf8ByteTable[256];
00259 
00260         virtual const char* Parse(      const char* p, 
00261                                                                 TiXmlParsingData* data, 
00262                                                                 TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
00263 #endif
00264 
00265         enum
00266         {
00267                 TIXML_NO_ERROR = 0,
00268                 TIXML_ERROR,
00269                 TIXML_ERROR_OPENING_FILE,
00270                 TIXML_ERROR_OUT_OF_MEMORY,
00271                 TIXML_ERROR_PARSING_ELEMENT,
00272                 TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
00273                 TIXML_ERROR_READING_ELEMENT_VALUE,
00274                 TIXML_ERROR_READING_ATTRIBUTES,
00275                 TIXML_ERROR_PARSING_EMPTY,
00276                 TIXML_ERROR_READING_END_TAG,
00277                 TIXML_ERROR_PARSING_UNKNOWN,
00278                 TIXML_ERROR_PARSING_COMMENT,
00279                 TIXML_ERROR_PARSING_DECLARATION,
00280                 TIXML_ERROR_DOCUMENT_EMPTY,
00281                 TIXML_ERROR_EMBEDDED_NULL,
00282                 TIXML_ERROR_PARSING_CDATA,
00283                 TIXML_ERROR_DOCUMENT_TOP_ONLY,
00284 
00285                 TIXML_ERROR_STRING_COUNT
00286         };
00287 
00288 protected:
00289 #ifndef SKIP_DOCS
00290         static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding );
00291         inline static bool IsWhiteSpace( char c )               
00292         { 
00293                 return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); 
00294         }
00295         inline static bool IsWhiteSpace( int c )
00296         {
00297                 if ( c < 256 )
00298                         return IsWhiteSpace( (char) c );
00299                 return false;   // Again, only truly correct for English/Latin...but usually works.
00300         }
00301 
00302 #ifdef TIXML_USE_STL
00303         static bool     StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );
00304         static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag );
00305 #endif
00306 
00307 #endif
00308 
00314         static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );
00315 
00320         static const char* ReadText(    const char* in,                         // where to start
00321                                                                         TIXML_STRING* text,                     // the string read
00322                                                                         bool ignoreWhiteSpace,          // whether to keep the white space
00323                                                                         const char* endTag,                     // what ends this text
00324                                                                         bool ignoreCase,                        // whether to ignore case in the end tag
00325                                                                         TiXmlEncoding encoding );       // the current encoding
00326 
00328         static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding );
00329 
00334         inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
00335         {
00336                 assert( p );
00337                 if ( encoding == TIXML_ENCODING_UTF8 )
00338                 {
00339                         *length = utf8ByteTable[ *((const unsigned char*)p) ];
00340                         assert( *length >= 0 && *length < 5 );
00341                 }
00342                 else
00343                 {
00344                         *length = 1;
00345                 }
00346 
00347                 if ( *length == 1 )
00348                 {
00349                         if ( *p == '&' )
00350                                 return GetEntity( p, _value, length, encoding );
00351                         *_value = *p;
00352                         return p+1;
00353                 }
00354                 else if ( *length )
00355                 {
00356                         //strncpy( _value, p, *length );        // lots of compilers don't like this function (unsafe),
00357                                                                                                 // and the null terminator isn't needed
00358                         for( int i=0; p[i] && i<*length; ++i ) {
00359                                 _value[i] = p[i];
00360                         }
00361                         return p + (*length);
00362                 }
00363                 else
00364                 {
00365                         // Not valid text.
00366                         return 0;
00367                 }
00368         }
00369 
00374         static void PutString( const TIXML_STRING& str, TIXML_STRING* out );
00375 
00381         static bool StringEqual(        const char* p,
00382                                                                 const char* endTag,
00383                                                                 bool ignoreCase,
00384                                                                 TiXmlEncoding encoding );
00385 
00387         static const char* errorString[ TIXML_ERROR_STRING_COUNT ];
00388 
00390         TiXmlCursor location;
00391 
00393         void*                   userData;
00394         
00399         static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
00401         static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
00403         inline static int ToLower( int v, TiXmlEncoding encoding )
00404         {
00405                 if ( encoding == TIXML_ENCODING_UTF8 )
00406                 {
00407                         if ( v < 128 ) return tolower( v );
00408                         return v;
00409                 }
00410                 else
00411                 {
00412                         return tolower( v );
00413                 }
00414         }
00416         static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
00417 
00418 private:
00419         TiXmlBase( const TiXmlBase& );                          // not implemented.
00420         void operator=( const TiXmlBase& base );        // not allowed.
00421 #ifndef SKIP_DOCS
00422         struct Entity
00423         {
00424                 const char*     str;
00425                 unsigned int    strLength;
00426                 char                chr;
00427         };
00428 #endif
00429         enum
00430         {
00431                 NUM_ENTITY = 5,
00432                 MAX_ENTITY_LENGTH = 6
00433 
00434         };
00435         static Entity entity[ NUM_ENTITY ];
00436         static bool condenseWhiteSpace;
00437 };
00438 
00439 
00450 class EDELIB_API TiXmlNode : public TiXmlBase
00451 {
00452         friend class TiXmlDocument;
00453         friend class TiXmlElement;
00454 
00455 public:
00456         #ifdef TIXML_USE_STL    
00457 
00462             friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
00463 
00481             friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
00482 
00484                 friend std::string& operator<< (std::string& out, const TiXmlNode& base );
00485 
00486         #endif
00487 
00492         enum NodeType
00493         {
00494                 DOCUMENT,
00495                 ELEMENT,
00496                 COMMENT,
00497                 UNKNOWN,
00498                 TEXT,
00499                 DECLARATION,
00500                 TYPECOUNT
00501         };
00502 
00503         virtual ~TiXmlNode();
00504 
00517         const char *Value() const { return value.c_str (); }
00518 
00519 #ifdef TIXML_USE_STL
00520 
00525         const std::string& ValueStr() const { return value; }
00526 #endif
00527 
00538         void SetValue(const char * _value) { value = _value;}
00539 
00540 #ifdef TIXML_USE_STL
00541 
00542         void SetValue( const std::string& _value )      { value = _value; }
00543 #endif
00544 
00546         void Clear();
00547 
00549         TiXmlNode* Parent()                                                     { return parent; }
00551         const TiXmlNode* Parent() const                         { return parent; }
00552 
00554         const TiXmlNode* FirstChild()   const   { return firstChild; }
00556         TiXmlNode* FirstChild()                                 { return firstChild; }
00557 
00559         const TiXmlNode* FirstChild( const char * value ) const;                        
00561         TiXmlNode* FirstChild( const char * _value ) {
00562                 // Call through to the const version - safe since nothing is changed. 
00563                 // Exiting syntax: cast this to a const (always safe)
00564                 // call the method, cast the return back to non-const.
00565                 return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild( _value ));
00566         }
00567 
00569         const TiXmlNode* LastChild() const      { return lastChild; }
00570 
00572         TiXmlNode* LastChild()  { return lastChild; }
00573 
00575         const TiXmlNode* LastChild( const char * value ) const;
00576 
00578         TiXmlNode* LastChild( const char * _value ) {
00579                 return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild( _value ));
00580         }
00581 
00582 #ifdef TIXML_USE_STL
00583 
00584         const TiXmlNode* FirstChild( const std::string& _value ) const  {       return FirstChild (_value.c_str ());    }       
00586         TiXmlNode* FirstChild( const std::string& _value )                              {       return FirstChild (_value.c_str ());    }
00588         const TiXmlNode* LastChild( const std::string& _value ) const   {       return LastChild (_value.c_str ());     }
00590         TiXmlNode* LastChild( const std::string& _value )                               {       return LastChild (_value.c_str ());     }
00591 #endif
00592 
00610         const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
00611 
00613         TiXmlNode* IterateChildren( const TiXmlNode* previous ) {
00614                 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( previous ) );
00615         }
00616 
00618         const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
00620         TiXmlNode* IterateChildren( const char * _value, const TiXmlNode* previous ) {
00621                 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( _value, previous ) );
00622         }
00623 
00624 #ifdef TIXML_USE_STL
00625 
00626         const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const  {       
00627                 return IterateChildren (_value.c_str (), previous);     
00628         }
00629 
00631         TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) {
00632                 return IterateChildren (_value.c_str (), previous);     
00633         }
00634 #endif
00635 
00640         TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
00641 
00652         TiXmlNode* LinkEndChild( TiXmlNode* addThis );
00653 
00658         TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
00659 
00664         TiXmlNode* InsertAfterChild(  TiXmlNode* afterThis, const TiXmlNode& addThis );
00665 
00670         TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
00671 
00675         bool RemoveChild( TiXmlNode* removeThis );
00676 
00680         const TiXmlNode* PreviousSibling() const                        { return prev; }
00681 
00685         TiXmlNode* PreviousSibling()                                            { return prev; }
00686 
00688         const TiXmlNode* PreviousSibling( const char * ) const;
00690         TiXmlNode* PreviousSibling( const char *_prev ) {
00691                 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->PreviousSibling( _prev ) );
00692         }
00693 
00694 #ifdef TIXML_USE_STL
00695 
00696         const TiXmlNode* PreviousSibling( const std::string& _value ) const     { return PreviousSibling (_value.c_str ()); }
00698         TiXmlNode* PreviousSibling( const std::string& _value )                         { return PreviousSibling (_value.c_str ()); }
00700         const TiXmlNode* NextSibling( const std::string& _value) const          { return NextSibling (_value.c_str ()); }
00702         TiXmlNode* NextSibling( const std::string& _value)                                      { return NextSibling (_value.c_str ()); }
00703 #endif
00704 
00706         const TiXmlNode* NextSibling() const                            { return next; }
00708         TiXmlNode* NextSibling()                                                        { return next; }
00709 
00711         const TiXmlNode* NextSibling( const char * ) const;
00713         TiXmlNode* NextSibling( const char* _next ) {
00714                 return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->NextSibling( _next ) );
00715         }
00716 
00723         const TiXmlElement* NextSiblingElement() const;
00724 
00726         TiXmlElement* NextSiblingElement() {
00727                 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() );
00728         }
00729 
00736         const TiXmlElement* NextSiblingElement( const char * ) const;
00737 
00739         TiXmlElement* NextSiblingElement( const char *_next ) {
00740                 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement( _next ) );
00741         }
00742 
00743 #ifdef TIXML_USE_STL
00744 
00745         const TiXmlElement* NextSiblingElement( const std::string& _value) const {
00746                 return NextSiblingElement (_value.c_str ());
00747         }
00749         TiXmlElement* NextSiblingElement( const std::string& _value) {
00750                 return NextSiblingElement (_value.c_str ());
00751         }
00752 #endif
00753 
00755         const TiXmlElement* FirstChildElement() const;
00757         TiXmlElement* FirstChildElement() {
00758                 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() );
00759         }
00761         const TiXmlElement* FirstChildElement( const char * _value ) const;
00763         TiXmlElement* FirstChildElement( const char * _value ) {
00764                 return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement( _value ) );
00765         }
00766 
00767 #ifdef TIXML_USE_STL
00768 
00769         const TiXmlElement* FirstChildElement( const std::string& _value ) const {
00770                 return FirstChildElement (_value.c_str ());     
00771         }
00772 
00774         TiXmlElement* FirstChildElement( const std::string& _value ) {
00775                 return FirstChildElement (_value.c_str ());     
00776         }
00777 #endif
00778 
00784         int Type() const        { return type; }
00785 
00790         const TiXmlDocument* GetDocument() const;
00791 
00793         TiXmlDocument* GetDocument() {
00794                 return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() );
00795         }
00796 
00798         bool NoChildren() const                                         { return !firstChild; }
00800         virtual const TiXmlDocument*    ToDocument()    const { return 0; }
00802         virtual const TiXmlElement*     ToElement()     const { return 0; }
00804         virtual const TiXmlComment*     ToComment()     const { return 0; }
00806         virtual const TiXmlUnknown*     ToUnknown()     const { return 0; }
00808         virtual const TiXmlText*        ToText()        const { return 0; }
00810         virtual const TiXmlDeclaration* ToDeclaration() const { return 0; }
00811 
00813         virtual TiXmlDocument*          ToDocument()    { return 0; }
00815         virtual TiXmlElement*           ToElement()         { return 0; }
00817         virtual TiXmlComment*           ToComment()     { return 0; }
00819         virtual TiXmlUnknown*           ToUnknown()         { return 0; }
00821         virtual TiXmlText*                  ToText()        { return 0; }
00823         virtual TiXmlDeclaration*       ToDeclaration() { return 0; }
00824 
00829         virtual TiXmlNode* Clone() const = 0;
00830 
00854         virtual bool Accept( TiXmlVisitor* visitor ) const = 0;
00855 
00856 protected:
00858         TiXmlNode( NodeType _type );
00859 
00864         void CopyTo( TiXmlNode* target ) const;
00865 
00866 #ifdef TIXML_USE_STL
00867 
00868         virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;
00869 #endif
00870 
00872         TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );
00873 #ifndef SKIP_DOCS
00874         TiXmlNode*              parent;
00875         NodeType                type;
00876 
00877         TiXmlNode*              firstChild;
00878         TiXmlNode*              lastChild;
00879 
00880         TIXML_STRING    value;
00881 
00882         TiXmlNode*              prev;
00883         TiXmlNode*              next;
00884 #endif
00885 
00886 private:
00887         TiXmlNode( const TiXmlNode& );                          // not implemented.
00888         void operator=( const TiXmlNode& base );        // not allowed.
00889 };
00890 
00891 
00903 class EDELIB_API TiXmlAttribute : public TiXmlBase
00904 {
00905         friend class TiXmlAttributeSet;
00906 
00907 public:
00909         TiXmlAttribute() : TiXmlBase()
00910         {
00911                 document = 0;
00912                 prev = next = 0;
00913         }
00914 
00915 #ifdef TIXML_USE_STL
00916 
00917         TiXmlAttribute( const std::string& _name, const std::string& _value )
00918         {
00919                 name = _name;
00920                 value = _value;
00921                 document = 0;
00922                 prev = next = 0;
00923         }
00924 #endif
00925 
00927         TiXmlAttribute( const char * _name, const char * _value )
00928         {
00929                 name = _name;
00930                 value = _value;
00931                 document = 0;
00932                 prev = next = 0;
00933         }
00934 
00936         const char*             Name()  const           { return name.c_str(); }
00938         const char*             Value() const           { return value.c_str(); }
00939 #ifdef TIXML_USE_STL
00940 
00941         const std::string& ValueStr() const     { return value; }
00942 #endif  
00943 
00944         int                             IntValue() const;                                                               
00946         double                  DoubleValue() const;
00947 
00949         const TIXML_STRING& NameTStr() const { return name; }
00950 
00961         int QueryIntValue( int* _value ) const;
00963         int QueryDoubleValue( double* _value ) const;
00964 
00966         void SetName( const char* _name )       { name = _name; }
00968         void SetValue( const char* _value )     { value = _value; }
00969 
00971         void SetIntValue( int _value );
00973         void SetDoubleValue( double _value );
00974 
00975 #ifdef TIXML_USE_STL
00976 
00977         void SetName( const std::string& _name )        { name = _name; }       
00979         void SetValue( const std::string& _value )      { value = _value; }
00980 #endif
00981 
00983         const TiXmlAttribute* Next() const;
00985         TiXmlAttribute* Next() {
00986                 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() ); 
00987         }
00988 
00990         const TiXmlAttribute* Previous() const;
00992         TiXmlAttribute* Previous() {
00993                 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Previous() ); 
00994         }
00995 
00997         bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
00999         bool operator<( const TiXmlAttribute& rhs )      const { return name < rhs.name; }
01001         bool operator>( const TiXmlAttribute& rhs )  const { return name > rhs.name; }
01002 
01007         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01008 
01010         virtual void Print( FILE* cfile, int depth ) const {
01011                 Print( cfile, depth, 0 );
01012         }
01014         void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
01015 
01016 #ifndef SKIP_DOCS
01017         // [internal use]
01018         // Set the document pointer so the attribute can report errors.
01019         void SetDocument( TiXmlDocument* doc )  { document = doc; }
01020 #endif
01021 
01022 private:
01023         TiXmlAttribute( const TiXmlAttribute& );                                // not implemented.
01024         void operator=( const TiXmlAttribute& base );   // not allowed.
01025 
01026         TiXmlDocument*  document;       // A pointer back to a document, for error reporting.
01027         TIXML_STRING name;
01028         TIXML_STRING value;
01029         TiXmlAttribute* prev;
01030         TiXmlAttribute* next;
01031 };
01032 
01033 #ifndef SKIP_DOCS
01034 
01047 class TiXmlAttributeSet
01048 {
01049 public:
01050         TiXmlAttributeSet();
01051         ~TiXmlAttributeSet();
01052 
01053         void Add( TiXmlAttribute* attribute );
01054         void Remove( TiXmlAttribute* attribute );
01055 
01056         const TiXmlAttribute* First()   const   { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
01057         TiXmlAttribute* First()                                 { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
01058         const TiXmlAttribute* Last() const              { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
01059         TiXmlAttribute* Last()                                  { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
01060 
01061         const TiXmlAttribute*   Find( const char* _name ) const;
01062         TiXmlAttribute* Find( const char* _name ) {
01063                 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );
01064         }
01065 #ifdef TIXML_USE_STL
01066         const TiXmlAttribute*   Find( const std::string& _name ) const;
01067         TiXmlAttribute* Find( const std::string& _name ) {
01068                 return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );
01069         }
01070 #endif
01071 
01072 private:
01073         //*ME:  Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
01074         //*ME:  this class must be also use a hidden/disabled copy-constructor !!!
01075         TiXmlAttributeSet( const TiXmlAttributeSet& );  // not allowed
01076         void operator=( const TiXmlAttributeSet& );     // not allowed (as TiXmlAttribute)
01077 
01078         TiXmlAttribute sentinel;
01079 };
01080 
01081 #endif // SKIP_DOCS
01082 
01083 
01092 class EDELIB_API TiXmlElement : public TiXmlNode
01093 {
01094 public:
01096         TiXmlElement (const char * in_value);
01097 
01098 #ifdef TIXML_USE_STL
01099 
01100         TiXmlElement( const std::string& _value );
01101 #endif
01102 
01104         TiXmlElement( const TiXmlElement& );
01105 
01107         void operator=( const TiXmlElement& base );
01108 
01110         virtual ~TiXmlElement();
01111 
01116         const char* Attribute( const char* name ) const;
01117 
01125         const char* Attribute( const char* name, int* i ) const;
01126 
01134         const char* Attribute( const char* name, double* d ) const;
01135 
01144         int QueryIntAttribute( const char* name, int* _value ) const;
01146         int QueryDoubleAttribute( const char* name, double* _value ) const;
01148         int QueryFloatAttribute( const char* name, float* _value ) const {
01149                 double d;
01150                 int result = QueryDoubleAttribute( name, &d );
01151                 if ( result == TIXML_SUCCESS ) {
01152                         *_value = (float)d;
01153                 }
01154                 return result;
01155         }
01156 #ifdef TIXML_USE_STL
01157 
01164         template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const 
01165         {
01166                 const TiXmlAttribute* node = attributeSet.Find( name );
01167                 if ( !node )
01168                         return TIXML_NO_ATTRIBUTE;
01169 
01170                 std::stringstream sstream( node->ValueStr() );
01171                 sstream >> *outValue;
01172                 if ( !sstream.fail() )
01173                         return TIXML_SUCCESS;
01174                 return TIXML_WRONG_TYPE;
01175         }
01176 #endif
01177 
01182         void SetAttribute( const char* name, const char * _value );
01183 
01184 #ifdef TIXML_USE_STL
01185 
01186         const std::string* Attribute( const std::string& name ) const;
01188         const std::string* Attribute( const std::string& name, int* i ) const;
01190         const std::string* Attribute( const std::string& name, double* d ) const;
01192         int QueryIntAttribute( const std::string& name, int* _value ) const;
01194         int QueryDoubleAttribute( const std::string& name, double* _value ) const;
01195 
01197         void SetAttribute( const std::string& name, const std::string& _value );
01199         void SetAttribute( const std::string& name, int _value );
01200 #endif
01201 
01206         void SetAttribute( const char * name, int value );
01207 
01212         void SetDoubleAttribute( const char * name, double value );
01213 
01215         void RemoveAttribute( const char * name );
01216 #ifdef TIXML_USE_STL
01217 
01218         void RemoveAttribute( const std::string& name ) { RemoveAttribute (name.c_str ()); }
01219 #endif
01220 
01222         const TiXmlAttribute* FirstAttribute() const    { return attributeSet.First(); }
01224         TiXmlAttribute* FirstAttribute()                                { return attributeSet.First(); }
01225 
01227         const TiXmlAttribute* LastAttribute()   const   { return attributeSet.Last(); }         
01229         TiXmlAttribute* LastAttribute()                                 { return attributeSet.Last(); }
01230 
01264         const char* GetText() const;
01265 
01267         virtual TiXmlNode* Clone() const;
01269         virtual void Print( FILE* cfile, int depth ) const;
01270 
01275         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01276 
01278         virtual const TiXmlElement*     ToElement()     const { return this; }
01280         virtual TiXmlElement*           ToElement()               { return this; }
01281 
01283         virtual bool Accept( TiXmlVisitor* visitor ) const;
01284 
01285 protected:
01286 #ifndef SKIP_DOCS
01287         void CopyTo( TiXmlElement* target ) const;
01288         void ClearThis();       // like clear, but initializes 'this' object as well
01289 
01290         // Used to be public [internal use]
01291 #ifdef TIXML_USE_STL
01292         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01293 #endif
01294 
01299         const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
01300 #endif
01301 
01302 private:
01303 
01304         TiXmlAttributeSet attributeSet;
01305 };
01306 
01307 
01312 class EDELIB_API TiXmlComment : public TiXmlNode
01313 {
01314 public:
01316         TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
01318         TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::COMMENT ) {
01319                 SetValue( _value );
01320         }
01322         TiXmlComment( const TiXmlComment& );
01324         void operator=( const TiXmlComment& base );
01325 
01327         virtual ~TiXmlComment() {}
01328 
01330         virtual TiXmlNode* Clone() const;
01332         virtual void Print( FILE* cfile, int depth ) const;
01333 
01338         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01339 
01341         virtual const TiXmlComment*  ToComment() const { return this; }
01343         virtual TiXmlComment*  ToComment() { return this; }
01344 
01346         virtual bool Accept( TiXmlVisitor* visitor ) const;
01347 
01348 protected:
01349 #ifndef SKIP_DOCS
01350         void CopyTo( TiXmlComment* target ) const;
01351 
01352         // used to be public
01353 #ifdef TIXML_USE_STL
01354         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01355 #endif
01356 //      virtual void StreamOut( TIXML_OSTREAM * out ) const;
01357 #endif
01358 
01359 };
01360 
01361 
01371 class EDELIB_API TiXmlText : public TiXmlNode
01372 {
01373         friend class TiXmlElement;
01374 public:
01380         TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT)
01381         {
01382                 SetValue( initValue );
01383                 cdata = false;
01384         }
01385         virtual ~TiXmlText() {}
01386 
01387 #ifdef TIXML_USE_STL
01388 
01389         TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
01390         {
01391                 SetValue( initValue );
01392                 cdata = false;
01393         }
01394 #endif
01395 
01396         TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT )       { copy.CopyTo( this ); }
01398         void operator=( const TiXmlText& base )                                                         { base.CopyTo( this ); }
01399 
01401         virtual void Print( FILE* cfile, int depth ) const;
01402 
01404         bool CDATA() const                              { return cdata; }
01406         void SetCDATA( bool _cdata )    { cdata = _cdata; }
01407 
01408 #ifndef SKIP_DOCS
01409         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01410 #endif
01411 
01412         virtual const TiXmlText* ToText() const { return this; }
01414         virtual TiXmlText*       ToText()       { return this; }
01415 
01417         virtual bool Accept( TiXmlVisitor* content ) const;
01418 
01419 protected :
01420 #ifndef SKIP_DOCS
01421 
01422         virtual TiXmlNode* Clone() const;
01423         void CopyTo( TiXmlText* target ) const;
01424 
01425         bool Blank() const;     // returns true if all white space and new lines
01426         // [internal use]
01427 #ifdef TIXML_USE_STL
01428         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01429 #endif
01430 
01431 #endif
01432 
01433 private:
01434         bool cdata;                     // true if this should be input and output as a CDATA style text element
01435 };
01436 
01437 
01455 class EDELIB_API TiXmlDeclaration : public TiXmlNode
01456 {
01457 public:
01459         TiXmlDeclaration()   : TiXmlNode( TiXmlNode::DECLARATION ) {}
01460 
01461 #ifdef TIXML_USE_STL
01462 
01463         TiXmlDeclaration(       const std::string& _version,
01464                                                 const std::string& _encoding,
01465                                                 const std::string& _standalone );
01466 #endif
01467 
01469         TiXmlDeclaration(       const char* _version,
01470                                                 const char* _encoding,
01471                                                 const char* _standalone );
01472 
01474         TiXmlDeclaration( const TiXmlDeclaration& copy );
01476         void operator=( const TiXmlDeclaration& copy );
01477 
01478 #ifndef SKIP_DOCS
01479         virtual ~TiXmlDeclaration()     {}
01480 #endif
01481 
01483         const char *Version() const                     { return version.c_str (); }
01485         const char *Encoding() const            { return encoding.c_str (); }
01487         const char *Standalone() const          { return standalone.c_str (); }
01488 
01490         virtual TiXmlNode* Clone() const;
01491 
01493         virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
01495         virtual void Print( FILE* cfile, int depth ) const {
01496                 Print( cfile, depth, 0 );
01497         }
01498 #ifndef SKIP_DOCS
01499         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01500 #endif
01501 
01502         virtual const TiXmlDeclaration* ToDeclaration() const { return this; }
01504         virtual TiXmlDeclaration*       ToDeclaration()       { return this; }
01505 
01507         virtual bool Accept( TiXmlVisitor* visitor ) const;
01508 
01509 protected:
01510 #ifndef SKIP_DOCS
01511         void CopyTo( TiXmlDeclaration* target ) const;
01512         // used to be public
01513 #ifdef TIXML_USE_STL
01514         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01515 #endif
01516 
01517 #endif
01518 
01519 private:
01520 
01521         TIXML_STRING version;
01522         TIXML_STRING encoding;
01523         TIXML_STRING standalone;
01524 };
01525 
01526 
01538 class TiXmlUnknown : public TiXmlNode
01539 {
01540 public:
01542         TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN )        {}
01543 #ifndef SKIP_DOCS
01544         virtual ~TiXmlUnknown() {}
01545 #endif
01546 
01548         TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN )              { copy.CopyTo( this ); }
01550         void operator=( const TiXmlUnknown& copy )                                                                              { copy.CopyTo( this ); }
01551 
01553         virtual TiXmlNode* Clone() const;
01555         virtual void Print( FILE* cfile, int depth ) const;
01556 #ifndef SKIP_DOCS
01557         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
01558 #endif
01559 
01560         virtual const TiXmlUnknown*     ToUnknown()     const { return this; }
01562         virtual TiXmlUnknown*           ToUnknown()         { return this; }
01563 
01565         virtual bool Accept( TiXmlVisitor* content ) const;
01566 
01567 protected:
01568 #ifndef SKIP_DOCS
01569         void CopyTo( TiXmlUnknown* target ) const;
01570 
01571 #ifdef TIXML_USE_STL
01572         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01573 #endif
01574 
01575 #endif
01576 
01577 private:
01578 
01579 };
01580 
01581 
01590 class EDELIB_API TiXmlDocument : public TiXmlNode
01591 {
01592 public:
01594         TiXmlDocument();
01596         TiXmlDocument( const char * documentName );
01597 
01598 #ifdef TIXML_USE_STL
01599 
01600         TiXmlDocument( const std::string& documentName );
01601 #endif
01602 
01604         TiXmlDocument( const TiXmlDocument& copy );
01606         void operator=( const TiXmlDocument& copy );
01607 
01608 #ifndef SKIP_DOCS
01609         virtual ~TiXmlDocument() {}
01610 #endif
01611 
01617         bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01619         bool SaveFile() const;
01621         bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01623         bool SaveFile( const char * filename ) const;
01630         bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01632         bool SaveFile( FILE* ) const;
01633 
01634 #ifdef TIXML_USE_STL
01635 
01636         bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )
01637         {
01638                 return LoadFile( filename.c_str(), encoding );
01639         }
01640 
01642         bool SaveFile( const std::string& filename ) const
01643         {
01644                 return SaveFile( filename.c_str() );
01645         }
01646 #endif
01647 
01653         virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
01654 
01660         const TiXmlElement* RootElement() const         { return FirstChildElement(); }
01662         TiXmlElement* RootElement()                                     { return FirstChildElement(); }
01663 
01670         bool Error() const                                              { return error; }
01671 
01673         const char * ErrorDesc() const  { return errorDesc.c_str (); }
01674 
01679         int ErrorId()   const                           { return errorId; }
01680 
01689         int ErrorRow() const    { return errorLocation.row+1; }
01690 
01692         int ErrorCol() const    { return errorLocation.col+1; }
01693 
01719         void SetTabSize( int _tabsize )         { tabsize = _tabsize; }
01720 
01722         int TabSize() const     { return tabsize; }
01723 
01728         void ClearError()                                               {       error = false; 
01729                                                                                                 errorId = 0; 
01730                                                                                                 errorDesc = ""; 
01731                                                                                                 errorLocation.row = errorLocation.col = 0; 
01732                                                                                                 //errorLocation.last = 0; 
01733                                                                                         }
01734 
01736         void Print() const                                              { Print( stdout, 0 ); }
01737 
01743         //char* PrintToMemory() const; 
01744 
01746         virtual void Print( FILE* cfile, int depth = 0 ) const;
01747 #ifndef SKIP_DOCS 
01748         // [internal use]
01749         void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
01750 #endif
01751 
01752         virtual const TiXmlDocument*    ToDocument()    const { return this; }
01754         virtual TiXmlDocument*          ToDocument()          { return this; }
01755 
01757         virtual bool Accept( TiXmlVisitor* content ) const;
01758 
01759 protected :
01760 #ifndef SKIP_DOCS
01761         // [internal use]
01762         virtual TiXmlNode* Clone() const;
01763 #ifdef TIXML_USE_STL
01764         virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
01765 #endif
01766 
01767 #endif
01768 
01769 private:
01770         void CopyTo( TiXmlDocument* target ) const;
01771 
01772         bool error;
01773         int  errorId;
01774         TIXML_STRING errorDesc;
01775         int tabsize;
01776         TiXmlCursor errorLocation;
01777         bool useMicrosoftBOM;           // the UTF-8 BOM were found when read. Note this, and try to write.
01778 };
01779 
01780 
01866 class EDELIB_API TiXmlHandle
01867 {
01868 public:
01870         TiXmlHandle( TiXmlNode* _node )                                 { this->node = _node; }
01872         TiXmlHandle( const TiXmlHandle& ref )                   { this->node = ref.node; }
01874         TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
01875 
01877         TiXmlHandle FirstChild() const;
01879         TiXmlHandle FirstChild( const char * value ) const;
01881         TiXmlHandle FirstChildElement() const;
01883         TiXmlHandle FirstChildElement( const char * value ) const;
01884 
01889         TiXmlHandle Child( const char* value, int index ) const;
01894         TiXmlHandle Child( int index ) const;
01900         TiXmlHandle ChildElement( const char* value, int index ) const;
01906         TiXmlHandle ChildElement( int index ) const;
01907 
01908 #ifdef TIXML_USE_STL
01909 
01910         TiXmlHandle FirstChild( const std::string& _value ) const                               { return FirstChild( _value.c_str() ); }
01912         TiXmlHandle FirstChildElement( const std::string& _value ) const                { return FirstChildElement( _value.c_str() ); }
01913 
01915         TiXmlHandle Child( const std::string& _value, int index ) const                 { return Child( _value.c_str(), index ); }
01917         TiXmlHandle ChildElement( const std::string& _value, int index ) const  { return ChildElement( _value.c_str(), index ); }
01918 #endif
01919 
01921         TiXmlNode* ToNode() const                       { return node; } 
01923         TiXmlElement* ToElement() const         { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
01925         TiXmlText* ToText() const                       { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
01927         TiXmlUnknown* ToUnknown() const         { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
01928 
01933         TiXmlNode* Node() const                 { return ToNode(); } 
01938         TiXmlElement* Element() const   { return ToElement(); }
01943         TiXmlText* Text() const                 { return ToText(); }
01948         TiXmlUnknown* Unknown() const   { return ToUnknown(); }
01949 
01950 private:
01951         TiXmlNode* node;
01952 };
01953 
01954 
01978 class TiXmlPrinter : public TiXmlVisitor
01979 {
01980 public:
01982         TiXmlPrinter() : depth( 0 ), simpleTextPrint( false ),
01983                                          buffer(), indent( "    " ), lineBreak( "\n" ) {}
01984 #ifndef SKIP_DOCS
01985         virtual bool VisitEnter( const TiXmlDocument& doc );
01986         virtual bool VisitExit( const TiXmlDocument& doc );
01987 
01988         virtual bool VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute );
01989         virtual bool VisitExit( const TiXmlElement& element );
01990 
01991         virtual bool Visit( const TiXmlDeclaration& declaration );
01992         virtual bool Visit( const TiXmlText& text );
01993         virtual bool Visit( const TiXmlComment& comment );
01994         virtual bool Visit( const TiXmlUnknown& unknown );
01995 #endif
01996 
02001         void SetIndent( const char* _indent )                   { indent = _indent ? _indent : "" ; }
02003         const char* Indent()                                                    { return indent.c_str(); }
02004 
02010         void SetLineBreak( const char* _lineBreak )             { lineBreak = _lineBreak ? _lineBreak : ""; }
02011 
02013         const char* LineBreak()                                                 { return lineBreak.c_str(); }
02014 
02019         void SetStreamPrinting()                                                { indent = ""; lineBreak = ""; }        
02021         const char* CStr()                                                              { return buffer.c_str(); }
02023         size_t Size()                                                                   { return buffer.length(); }
02024 
02025 #ifdef TIXML_USE_STL
02026 
02027         const std::string& Str()                                                { return buffer; }
02028 #endif
02029 
02030 private:
02031         void DoIndent() {
02032                 for( int i=0; i<depth; ++i )
02033                         buffer += indent;
02034         }
02035         void DoLineBreak() {
02036                 buffer += lineBreak;
02037         }
02038 
02039         int depth;
02040         bool simpleTextPrint;
02041         TIXML_STRING buffer;
02042         TIXML_STRING indent;
02043         TIXML_STRING lineBreak;
02044 };
02045 
02046 
02047 #ifdef _MSC_VER
02048 #pragma warning( pop )
02049 #endif
02050 
02051 #endif