Orocos Real-Time Toolkit  2.5.0
tinyxml.h
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