zenilib  0.5.3.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
tinyxml.h
Go to the documentation of this file.
1 /*
2 www.sourceforge.net/projects/tinyxml
3 Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
4 
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the authors be held liable for any
7 damages arising from the use of this software.
8 
9 Permission is granted to anyone to use this software for any
10 purpose, including commercial applications, and to alter it and
11 redistribute it freely, subject to the following restrictions:
12 
13 1. The origin of this software must not be misrepresented; you must
14 not claim that you wrote the original software. If you use this
15 software in a product, an acknowledgment in the product documentation
16 would be appreciated but is not required.
17 
18 2. Altered source versions must be plainly marked as such, and
19 must not be misrepresented as being the original software.
20 
21 3. This notice may not be removed or altered from any source
22 distribution.
23 */
24 
25 
26 #ifndef TINYXML_INCLUDED
27 #define TINYXML_INCLUDED
28 
29 #ifdef _MSC_VER
30 #pragma warning( push )
31 #pragma warning( disable : 4530 )
32 #pragma warning( disable : 4786 )
33 #endif
34 
35 #include <ctype.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <assert.h>
40 
41 // Help out windows:
42 #if defined( _DEBUG ) && !defined( DEBUG )
43 #define DEBUG
44 #endif
45 
46 #ifdef TIXML_USE_STL
47  #include <string>
48  #include <iostream>
49  #include <sstream>
50  #define TIXML_STRING std::string
51 #else
52  #include "tinystr.h"
53  #define TIXML_STRING TiXmlString
54 #endif
55 
56 // Deprecated library function hell. Compilers want to use the
57 // new safe versions. This probably doesn't fully address the problem,
58 // but it gets closer. There are too many compilers for me to fully
59 // test. If you get compilation troubles, undefine TIXML_SAFE
60 #define TIXML_SAFE
61 
62 #ifdef TIXML_SAFE
63  #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
64  // Microsoft visual studio, version 2005 and higher.
65  #define TIXML_SNPRINTF _snprintf_s
66  #define TIXML_SSCANF sscanf_s
67  #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
68  // Microsoft visual studio, version 6 and higher.
69  //#pragma message( "Using _sn* functions." )
70  #define TIXML_SNPRINTF _snprintf
71  #define TIXML_SSCANF sscanf
72  #elif defined(__GNUC__) && (__GNUC__ >= 3 )
73  // GCC version 3 and higher.s
74  //#warning( "Using sn* functions." )
75  #define TIXML_SNPRINTF snprintf
76  #define TIXML_SSCANF sscanf
77  #else
78  #define TIXML_SNPRINTF snprintf
79  #define TIXML_SSCANF sscanf
80  #endif
81 #endif
82 
83 class TiXmlDocument;
84 class TiXmlElement;
85 class TiXmlComment;
86 class TiXmlUnknown;
87 class TiXmlAttribute;
88 class TiXmlText;
89 class TiXmlDeclaration;
90 class TiXmlParsingData;
91 
92 const int TIXML_MAJOR_VERSION = 2;
93 const int TIXML_MINOR_VERSION = 6;
94 const int TIXML_PATCH_VERSION = 1;
95 
96 /* Internal structure for tracking location of items
97  in the XML file.
98 */
99 struct TINYXML_DLL TiXmlCursor
100 {
101  TiXmlCursor() { Clear(); }
102  void Clear() { row = col = -1; }
103 
104  int row; // 0 based.
105  int col; // 0 based.
106 };
107 
108 
128 class TINYXML_DLL TiXmlVisitor
129 {
130 public:
131  virtual ~TiXmlVisitor() {}
132 
134  virtual bool VisitEnter( const TiXmlDocument& /*doc*/ ) { return true; }
136  virtual bool VisitExit( const TiXmlDocument& /*doc*/ ) { return true; }
137 
139  virtual bool VisitEnter( const TiXmlElement& /*element*/, const TiXmlAttribute* /*firstAttribute*/ ) { return true; }
141  virtual bool VisitExit( const TiXmlElement& /*element*/ ) { return true; }
142 
144  virtual bool Visit( const TiXmlDeclaration& /*declaration*/ ) { return true; }
146  virtual bool Visit( const TiXmlText& /*text*/ ) { return true; }
148  virtual bool Visit( const TiXmlComment& /*comment*/ ) { return true; }
150  virtual bool Visit( const TiXmlUnknown& /*unknown*/ ) { return true; }
151 };
152 
153 // Only used by Attribute::Query functions
154 enum
155 {
159 };
160 
161 
162 // Used by the parsing routines.
164 {
168 };
169 
171 
194 class TINYXML_DLL TiXmlBase
195 {
196  friend class TiXmlNode;
197  friend class TiXmlElement;
198  friend class TiXmlDocument;
199 
200 public:
201  TiXmlBase() : userData(0) {}
202  virtual ~TiXmlBase() {}
203 
213  virtual void Print( FILE* cfile, int depth ) const = 0;
214 
221  static void SetCondenseWhiteSpace( bool condense ) { condenseWhiteSpace = condense; }
222 
224  static bool IsWhiteSpaceCondensed() { return condenseWhiteSpace; }
225 
244  int Row() const { return location.row + 1; }
245  int Column() const { return location.col + 1; }
246 
247  void SetUserData( void* user ) { userData = user; }
248  void* GetUserData() { return userData; }
249  const void* GetUserData() const { return userData; }
250 
251  // Table that returs, for a given lead byte, the total number of bytes
252  // in the UTF-8 sequence.
253  static const int utf8ByteTable[256];
254 
255  virtual const char* Parse( const char* p,
256  TiXmlParsingData* data,
257  TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
258 
262  static void EncodeString( const TIXML_STRING& str, TIXML_STRING* out );
263 
264  enum
265  {
282 
284  };
285 
286 protected:
287 
288  static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding );
289 
290  inline static bool IsWhiteSpace( char c )
291  {
292  return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );
293  }
294  inline static bool IsWhiteSpace( int c )
295  {
296  if ( c < 256 )
297  return IsWhiteSpace( (char) c );
298  return false; // Again, only truly correct for English/Latin...but usually works.
299  }
300 
301  #ifdef TIXML_USE_STL
302  static bool StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );
303  static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag );
304  #endif
305 
306  /* Reads an XML name into the string provided. Returns
307  a pointer just past the last character of the name,
308  or 0 if the function has an error.
309  */
310  static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );
311 
312  /* Reads text. Returns a pointer past the given end tag.
313  Wickedly complex options, but it keeps the (sensitive) code in one place.
314  */
315  static const char* ReadText( const char* in, // where to start
316  TIXML_STRING* text, // the string read
317  bool ignoreWhiteSpace, // whether to keep the white space
318  const char* endTag, // what ends this text
319  bool ignoreCase, // whether to ignore case in the end tag
320  TiXmlEncoding encoding ); // the current encoding
321 
322  // If an entity has been found, transform it into a character.
323  static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding );
324 
325  // Get a character, while interpreting entities.
326  // The length can be from 0 to 4 bytes.
327  inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
328  {
329  assert( p );
330  if ( encoding == TIXML_ENCODING_UTF8 )
331  {
332  *length = utf8ByteTable[ *((const unsigned char*)p) ];
333  assert( *length >= 0 && *length < 5 );
334  }
335  else
336  {
337  *length = 1;
338  }
339 
340  if ( *length == 1 )
341  {
342  if ( *p == '&' )
343  return GetEntity( p, _value, length, encoding );
344  *_value = *p;
345  return p+1;
346  }
347  else if ( *length )
348  {
349  //strncpy( _value, p, *length ); // lots of compilers don't like this function (unsafe),
350  // and the null terminator isn't needed
351  for( int i=0; p[i] && i<*length; ++i ) {
352  _value[i] = p[i];
353  }
354  return p + (*length);
355  }
356  else
357  {
358  // Not valid text.
359  return 0;
360  }
361  }
362 
363  // Return true if the next characters in the stream are any of the endTag sequences.
364  // Ignore case only works for english, and should only be relied on when comparing
365  // to English words: StringEqual( p, "version", true ) is fine.
366  static bool StringEqual( const char* p,
367  const char* endTag,
368  bool ignoreCase,
369  TiXmlEncoding encoding );
370 
371  static const char* errorString[ TIXML_ERROR_STRING_COUNT ];
372 
374 
376  void* userData;
377 
378  // None of these methods are reliable for any language except English.
379  // Good for approximation, not great for accuracy.
380  static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
381  static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
382  inline static int ToLower( int v, TiXmlEncoding encoding )
383  {
384  if ( encoding == TIXML_ENCODING_UTF8 )
385  {
386  if ( v < 128 ) return tolower( v );
387  return v;
388  }
389  else
390  {
391  return tolower( v );
392  }
393  }
394  static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
395 
396 private:
397  TiXmlBase( const TiXmlBase& ); // not implemented.
398  void operator=( const TiXmlBase& base ); // not allowed.
399 
400  struct Entity
401  {
402  const char* str;
403  unsigned int strLength;
404  char chr;
405  };
406  enum
407  {
408  NUM_ENTITY = 5,
409  MAX_ENTITY_LENGTH = 6
410 
411  };
412  static Entity entity[ NUM_ENTITY ];
413  static bool condenseWhiteSpace;
414 };
415 
416 
423 class TINYXML_DLL TiXmlNode : public TiXmlBase
424 {
425  friend class TiXmlDocument;
426  friend class TiXmlElement;
427 
428 public:
429  #ifdef TIXML_USE_STL
430 
434  friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
435 
452  friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
453 
455  friend std::string& operator<< (std::string& out, const TiXmlNode& base );
456 
457  #endif
458 
462  enum NodeType
463  {
471  };
472 
473  virtual ~TiXmlNode();
474 
487  const char *Value() const { return value.c_str (); }
488 
489  #ifdef TIXML_USE_STL
490 
494  const std::string& ValueStr() const { return value; }
495  #endif
496 
497  const TIXML_STRING& ValueTStr() const { return value; }
498 
508  void SetValue(const char * _value) { value = _value;}
509 
510  #ifdef TIXML_USE_STL
511  void SetValue( const std::string& _value ) { value = _value; }
513  #endif
514 
516  void Clear();
517 
519  TiXmlNode* Parent() { return parent; }
520  const TiXmlNode* Parent() const { return parent; }
521 
522  const TiXmlNode* FirstChild() const { return firstChild; }
524  const TiXmlNode* FirstChild( const char * value ) const;
525  TiXmlNode* FirstChild( const char * _value ) {
527  // Call through to the const version - safe since nothing is changed. Exiting syntax: cast this to a const (always safe)
528  // call the method, cast the return back to non-const.
529  return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild( _value ));
530  }
531  const TiXmlNode* LastChild() const { return lastChild; }
533 
534  const TiXmlNode* LastChild( const char * value ) const;
535  TiXmlNode* LastChild( const char * _value ) {
536  return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild( _value ));
537  }
538 
539  #ifdef TIXML_USE_STL
540  const TiXmlNode* FirstChild( const std::string& _value ) const { return FirstChild (_value.c_str ()); }
541  TiXmlNode* FirstChild( const std::string& _value ) { return FirstChild (_value.c_str ()); }
542  const TiXmlNode* LastChild( const std::string& _value ) const { return LastChild (_value.c_str ()); }
543  TiXmlNode* LastChild( const std::string& _value ) { return LastChild (_value.c_str ()); }
544  #endif
545 
562  const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
563  TiXmlNode* IterateChildren( const TiXmlNode* previous ) {
564  return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( previous ) );
565  }
566 
568  const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
569  TiXmlNode* IterateChildren( const char * _value, const TiXmlNode* previous ) {
570  return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( _value, previous ) );
571  }
572 
573  #ifdef TIXML_USE_STL
574  const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const { return IterateChildren (_value.c_str (), previous); }
575  TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) { return IterateChildren (_value.c_str (), previous); }
576  #endif
577 
581  TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
582 
583 
593  TiXmlNode* LinkEndChild( TiXmlNode* addThis );
594 
598  TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
599 
603  TiXmlNode* InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis );
604 
608  TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
609 
611  bool RemoveChild( TiXmlNode* removeThis );
612 
614  const TiXmlNode* PreviousSibling() const { return prev; }
616 
618  const TiXmlNode* PreviousSibling( const char * ) const;
619  TiXmlNode* PreviousSibling( const char *_prev ) {
620  return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->PreviousSibling( _prev ) );
621  }
622 
623  #ifdef TIXML_USE_STL
624  const TiXmlNode* PreviousSibling( const std::string& _value ) const { return PreviousSibling (_value.c_str ()); }
625  TiXmlNode* PreviousSibling( const std::string& _value ) { return PreviousSibling (_value.c_str ()); }
626  const TiXmlNode* NextSibling( const std::string& _value) const { return NextSibling (_value.c_str ()); }
627  TiXmlNode* NextSibling( const std::string& _value) { return NextSibling (_value.c_str ()); }
628  #endif
629 
631  const TiXmlNode* NextSibling() const { return next; }
632  TiXmlNode* NextSibling() { return next; }
633 
635  const TiXmlNode* NextSibling( const char * ) const;
636  TiXmlNode* NextSibling( const char* _next ) {
637  return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->NextSibling( _next ) );
638  }
639 
644  const TiXmlElement* NextSiblingElement() const;
646  return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() );
647  }
648 
653  const TiXmlElement* NextSiblingElement( const char * ) const;
654  TiXmlElement* NextSiblingElement( const char *_next ) {
655  return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement( _next ) );
656  }
657 
658  #ifdef TIXML_USE_STL
659  const TiXmlElement* NextSiblingElement( const std::string& _value) const { return NextSiblingElement (_value.c_str ()); }
660  TiXmlElement* NextSiblingElement( const std::string& _value) { return NextSiblingElement (_value.c_str ()); }
661  #endif
662 
664  const TiXmlElement* FirstChildElement() const;
666  return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() );
667  }
668 
670  const TiXmlElement* FirstChildElement( const char * _value ) const;
671  TiXmlElement* FirstChildElement( const char * _value ) {
672  return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement( _value ) );
673  }
674 
675  #ifdef TIXML_USE_STL
676  const TiXmlElement* FirstChildElement( const std::string& _value ) const { return FirstChildElement (_value.c_str ()); }
677  TiXmlElement* FirstChildElement( const std::string& _value ) { return FirstChildElement (_value.c_str ()); }
678  #endif
679 
684  int Type() const { return type; }
685 
689  const TiXmlDocument* GetDocument() const;
691  return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() );
692  }
693 
695  bool NoChildren() const { return !firstChild; }
696 
697  virtual const TiXmlDocument* ToDocument() const { return 0; }
698  virtual const TiXmlElement* ToElement() const { return 0; }
699  virtual const TiXmlComment* ToComment() const { return 0; }
700  virtual const TiXmlUnknown* ToUnknown() const { return 0; }
701  virtual const TiXmlText* ToText() const { return 0; }
702  virtual const TiXmlDeclaration* ToDeclaration() const { return 0; }
703 
704  virtual TiXmlDocument* ToDocument() { return 0; }
705  virtual TiXmlElement* ToElement() { return 0; }
706  virtual TiXmlComment* ToComment() { return 0; }
707  virtual TiXmlUnknown* ToUnknown() { return 0; }
708  virtual TiXmlText* ToText() { return 0; }
709  virtual TiXmlDeclaration* ToDeclaration() { return 0; }
710 
714  virtual TiXmlNode* Clone() const = 0;
715 
738  virtual bool Accept( TiXmlVisitor* visitor ) const = 0;
739 
740 protected:
741  TiXmlNode( NodeType _type );
742 
743  // Copy to the allocated object. Shared functionality between Clone, Copy constructor,
744  // and the assignment operator.
745  void CopyTo( TiXmlNode* target ) const;
746 
747  #ifdef TIXML_USE_STL
748  // The real work of the input operator.
749  virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;
750  #endif
751 
752  // Figure out what is at *p, and parse it. Returns null if it is not an xml node.
753  TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );
754 
757 
760 
762 
765 
766 private:
767  TiXmlNode( const TiXmlNode& ); // not implemented.
768  void operator=( const TiXmlNode& base ); // not allowed.
769 };
770 
771 
779 class TINYXML_DLL TiXmlAttribute : public TiXmlBase
780 {
781  friend class TiXmlAttributeSet;
782 
783 public:
786  {
787  document = 0;
788  prev = next = 0;
789  }
790 
791  #ifdef TIXML_USE_STL
792  TiXmlAttribute( const std::string& _name, const std::string& _value )
794  {
795  name = _name;
796  value = _value;
797  document = 0;
798  prev = next = 0;
799  }
800  #endif
801 
803  TiXmlAttribute( const char * _name, const char * _value )
804  {
805  name = _name;
806  value = _value;
807  document = 0;
808  prev = next = 0;
809  }
810 
811  const char* Name() const { return name.c_str(); }
812  const char* Value() const { return value.c_str(); }
813  #ifdef TIXML_USE_STL
814  const std::string& ValueStr() const { return value; }
815  #endif
816  int IntValue() const;
817  double DoubleValue() const;
818 
819  // Get the tinyxml string representation
820  const TIXML_STRING& NameTStr() const { return name; }
821 
831  int QueryIntValue( int* _value ) const;
833  int QueryDoubleValue( double* _value ) const;
834 
835  void SetName( const char* _name ) { name = _name; }
836  void SetValue( const char* _value ) { value = _value; }
837 
838  void SetIntValue( int _value );
839  void SetDoubleValue( double _value );
840 
841  #ifdef TIXML_USE_STL
842  void SetName( const std::string& _name ) { name = _name; }
845  void SetValue( const std::string& _value ) { value = _value; }
846  #endif
847 
849  const TiXmlAttribute* Next() const;
851  return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() );
852  }
853 
855  const TiXmlAttribute* Previous() const;
857  return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Previous() );
858  }
859 
860  bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
861  bool operator<( const TiXmlAttribute& rhs ) const { return name < rhs.name; }
862  bool operator>( const TiXmlAttribute& rhs ) const { return name > rhs.name; }
863 
864  /* Attribute parsing starts: first letter of the name
865  returns: the next char after the value end quote
866  */
867  virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
868 
869  // Prints this Attribute to a FILE stream.
870  virtual void Print( FILE* cfile, int depth ) const {
871  Print( cfile, depth, 0 );
872  }
873  void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
874 
875  // [internal use]
876  // Set the document pointer so the attribute can report errors.
877  void SetDocument( TiXmlDocument* doc ) { document = doc; }
878 
879 private:
880  TiXmlAttribute( const TiXmlAttribute& ); // not implemented.
881  void operator=( const TiXmlAttribute& base ); // not allowed.
882 
883  TiXmlDocument* document; // A pointer back to a document, for error reporting.
886  TiXmlAttribute* prev;
887  TiXmlAttribute* next;
888 };
889 
890 
891 /* A class used to manage a group of attributes.
892  It is only used internally, both by the ELEMENT and the DECLARATION.
893 
894  The set can be changed transparent to the Element and Declaration
895  classes that use it, but NOT transparent to the Attribute
896  which has to implement a next() and previous() method. Which makes
897  it a bit problematic and prevents the use of STL.
898 
899  This version is implemented with circular lists because:
900  - I like circular lists
901  - it demonstrates some independence from the (typical) doubly linked list.
902 */
903 class TINYXML_DLL TiXmlAttributeSet
904 {
905 public:
908 
909  void Add( TiXmlAttribute* attribute );
910  void Remove( TiXmlAttribute* attribute );
911 
912  const TiXmlAttribute* First() const { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
913  TiXmlAttribute* First() { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
914  const TiXmlAttribute* Last() const { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
915  TiXmlAttribute* Last() { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
916 
917  TiXmlAttribute* Find( const char* _name ) const;
918  TiXmlAttribute* FindOrCreate( const char* _name );
919 
920 # ifdef TIXML_USE_STL
921  TiXmlAttribute* Find( const std::string& _name ) const;
922  TiXmlAttribute* FindOrCreate( const std::string& _name );
923 # endif
924 
925 
926 private:
927  //*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
928  //*ME: this class must be also use a hidden/disabled copy-constructor !!!
929  TiXmlAttributeSet( const TiXmlAttributeSet& ); // not allowed
930  void operator=( const TiXmlAttributeSet& ); // not allowed (as TiXmlAttribute)
931 
932  TiXmlAttribute sentinel;
933 };
934 
935 
940 class TINYXML_DLL TiXmlElement : public TiXmlNode
941 {
942 public:
944  TiXmlElement (const char * in_value);
945 
946  #ifdef TIXML_USE_STL
947  TiXmlElement( const std::string& _value );
949  #endif
950 
951  TiXmlElement( const TiXmlElement& );
952 
953  void operator=( const TiXmlElement& base );
954 
955  virtual ~TiXmlElement();
956 
960  const char* Attribute( const char* name ) const;
961 
968  const char* Attribute( const char* name, int* i ) const;
969 
976  const char* Attribute( const char* name, double* d ) const;
977 
985  int QueryIntAttribute( const char* name, int* _value ) const;
987  int QueryDoubleAttribute( const char* name, double* _value ) const;
989  int QueryFloatAttribute( const char* name, float* _value ) const {
990  double d;
991  int result = QueryDoubleAttribute( name, &d );
992  if ( result == TIXML_SUCCESS ) {
993  *_value = (float)d;
994  }
995  return result;
996  }
997 
998  #ifdef TIXML_USE_STL
999  int QueryStringAttribute( const char* name, std::string* _value ) const {
1001  const char* cstr = Attribute( name );
1002  if ( cstr ) {
1003  *_value = std::string( cstr );
1004  return TIXML_SUCCESS;
1005  }
1006  return TIXML_NO_ATTRIBUTE;
1007  }
1008 
1017  template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const
1018  {
1019  const TiXmlAttribute* node = attributeSet.Find( name );
1020  if ( !node )
1021  return TIXML_NO_ATTRIBUTE;
1022 
1023  std::stringstream sstream( node->ValueStr() );
1024  sstream >> *outValue;
1025  if ( !sstream.fail() )
1026  return TIXML_SUCCESS;
1027  return TIXML_WRONG_TYPE;
1028  }
1029 
1030  int QueryValueAttribute( const std::string& name, std::string* outValue ) const
1031  {
1032  const TiXmlAttribute* node = attributeSet.Find( name );
1033  if ( !node )
1034  return TIXML_NO_ATTRIBUTE;
1035  *outValue = node->ValueStr();
1036  return TIXML_SUCCESS;
1037  }
1038  #endif
1039 
1043  void SetAttribute( const char* name, const char * _value );
1044 
1045  #ifdef TIXML_USE_STL
1046  const std::string* Attribute( const std::string& name ) const;
1047  const std::string* Attribute( const std::string& name, int* i ) const;
1048  const std::string* Attribute( const std::string& name, double* d ) const;
1049  int QueryIntAttribute( const std::string& name, int* _value ) const;
1050  int QueryDoubleAttribute( const std::string& name, double* _value ) const;
1051 
1053  void SetAttribute( const std::string& name, const std::string& _value );
1055  void SetAttribute( const std::string& name, int _value );
1057  void SetDoubleAttribute( const std::string& name, double value );
1058  #endif
1059 
1063  void SetAttribute( const char * name, int value );
1064 
1068  void SetDoubleAttribute( const char * name, double value );
1069 
1072  void RemoveAttribute( const char * name );
1073  #ifdef TIXML_USE_STL
1074  void RemoveAttribute( const std::string& name ) { RemoveAttribute (name.c_str ()); }
1075  #endif
1076 
1077  const TiXmlAttribute* FirstAttribute() const { return attributeSet.First(); }
1078  TiXmlAttribute* FirstAttribute() { return attributeSet.First(); }
1079  const TiXmlAttribute* LastAttribute() const { return attributeSet.Last(); }
1080  TiXmlAttribute* LastAttribute() { return attributeSet.Last(); }
1081 
1114  const char* GetText() const;
1115 
1117  virtual TiXmlNode* Clone() const;
1118  // Print the Element to a FILE stream.
1119  virtual void Print( FILE* cfile, int depth ) const;
1120 
1121  /* Attribtue parsing starts: next char past '<'
1122  returns: next char past '>'
1123  */
1124  virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
1125 
1126  virtual const TiXmlElement* ToElement() const { return this; }
1127  virtual TiXmlElement* ToElement() { return this; }
1128 
1131  virtual bool Accept( TiXmlVisitor* visitor ) const;
1132 
1133 protected:
1134 
1135  void CopyTo( TiXmlElement* target ) const;
1136  void ClearThis(); // like clear, but initializes 'this' object as well
1137 
1138  // Used to be public [internal use]
1139  #ifdef TIXML_USE_STL
1140  virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
1141  #endif
1142  /* [internal use]
1143  Reads the "value" of the element -- another element, or text.
1144  This should terminate with the current end tag.
1145  */
1146  const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
1147 
1148 private:
1149  TiXmlAttributeSet attributeSet;
1150 };
1151 
1152 
1155 class TINYXML_DLL TiXmlComment : public TiXmlNode
1156 {
1157 public:
1159  TiXmlComment() : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {}
1161  TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) {
1162  SetValue( _value );
1163  }
1164  TiXmlComment( const TiXmlComment& );
1165  void operator=( const TiXmlComment& base );
1166 
1167  virtual ~TiXmlComment() {}
1168 
1170  virtual TiXmlNode* Clone() const;
1171  // Write this Comment to a FILE stream.
1172  virtual void Print( FILE* cfile, int depth ) const;
1173 
1174  /* Attribtue parsing starts: at the ! of the !--
1175  returns: next char past '>'
1176  */
1177  virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
1178 
1179  virtual const TiXmlComment* ToComment() const { return this; }
1180  virtual TiXmlComment* ToComment() { return this; }
1181 
1184  virtual bool Accept( TiXmlVisitor* visitor ) const;
1185 
1186 protected:
1187  void CopyTo( TiXmlComment* target ) const;
1188 
1189  // used to be public
1190  #ifdef TIXML_USE_STL
1191  virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
1192  #endif
1193 // virtual void StreamOut( TIXML_OSTREAM * out ) const;
1194 
1195 private:
1196 
1197 };
1198 
1199 
1205 class TINYXML_DLL TiXmlText : public TiXmlNode
1206 {
1207  friend class TiXmlElement;
1208 public:
1213  TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT)
1214  {
1215  SetValue( initValue );
1216  cdata = false;
1217  }
1218  virtual ~TiXmlText() {}
1219 
1220  #ifdef TIXML_USE_STL
1221  TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TINYXML_TEXT)
1223  {
1224  SetValue( initValue );
1225  cdata = false;
1226  }
1227  #endif
1228 
1229  TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TINYXML_TEXT ) { copy.CopyTo( this ); }
1230  void operator=( const TiXmlText& base ) { base.CopyTo( this ); }
1231 
1232  // Write this text object to a FILE stream.
1233  virtual void Print( FILE* cfile, int depth ) const;
1234 
1236  bool CDATA() const { return cdata; }
1238  void SetCDATA( bool _cdata ) { cdata = _cdata; }
1239 
1240  virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
1241 
1242  virtual const TiXmlText* ToText() const { return this; }
1243  virtual TiXmlText* ToText() { return this; }
1244 
1247  virtual bool Accept( TiXmlVisitor* content ) const;
1248 
1249 protected :
1251  virtual TiXmlNode* Clone() const;
1252  void CopyTo( TiXmlText* target ) const;
1253 
1254  bool Blank() const; // returns true if all white space and new lines
1255  // [internal use]
1256  #ifdef TIXML_USE_STL
1257  virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
1258  #endif
1259 
1260 private:
1261  bool cdata; // true if this should be input and output as a CDATA style text element
1262 };
1263 
1264 
1278 class TINYXML_DLL TiXmlDeclaration : public TiXmlNode
1279 {
1280 public:
1282  TiXmlDeclaration() : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) {}
1283 
1284 #ifdef TIXML_USE_STL
1285  TiXmlDeclaration( const std::string& _version,
1287  const std::string& _encoding,
1288  const std::string& _standalone );
1289 #endif
1290 
1292  TiXmlDeclaration( const char* _version,
1293  const char* _encoding,
1294  const char* _standalone );
1295 
1296  TiXmlDeclaration( const TiXmlDeclaration& copy );
1297  void operator=( const TiXmlDeclaration& copy );
1298 
1299  virtual ~TiXmlDeclaration() {}
1300 
1302  const char *Version() const { return version.c_str (); }
1304  const char *Encoding() const { return encoding.c_str (); }
1306  const char *Standalone() const { return standalone.c_str (); }
1307 
1309  virtual TiXmlNode* Clone() const;
1310  // Print this declaration to a FILE stream.
1311  virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
1312  virtual void Print( FILE* cfile, int depth ) const {
1313  Print( cfile, depth, 0 );
1314  }
1315 
1316  virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
1317 
1318  virtual const TiXmlDeclaration* ToDeclaration() const { return this; }
1319  virtual TiXmlDeclaration* ToDeclaration() { return this; }
1320 
1323  virtual bool Accept( TiXmlVisitor* visitor ) const;
1324 
1325 protected:
1326  void CopyTo( TiXmlDeclaration* target ) const;
1327  // used to be public
1328  #ifdef TIXML_USE_STL
1329  virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
1330  #endif
1331 
1332 private:
1333 
1335  TIXML_STRING encoding;
1336  TIXML_STRING standalone;
1337 };
1338 
1339 
1347 class TINYXML_DLL TiXmlUnknown : public TiXmlNode
1348 {
1349 public:
1350  TiXmlUnknown() : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN ) {}
1351  virtual ~TiXmlUnknown() {}
1352 
1353  TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::TINYXML_UNKNOWN ) { copy.CopyTo( this ); }
1354  void operator=( const TiXmlUnknown& copy ) { copy.CopyTo( this ); }
1355 
1357  virtual TiXmlNode* Clone() const;
1358  // Print this Unknown to a FILE stream.
1359  virtual void Print( FILE* cfile, int depth ) const;
1360 
1361  virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
1362 
1363  virtual const TiXmlUnknown* ToUnknown() const { return this; }
1364  virtual TiXmlUnknown* ToUnknown() { return this; }
1365 
1368  virtual bool Accept( TiXmlVisitor* content ) const;
1369 
1370 protected:
1371  void CopyTo( TiXmlUnknown* target ) const;
1372 
1373  #ifdef TIXML_USE_STL
1374  virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
1375  #endif
1376 
1377 private:
1378 
1379 };
1380 
1381 
1386 class TINYXML_DLL TiXmlDocument : public TiXmlNode
1387 {
1388 public:
1390  TiXmlDocument();
1392  TiXmlDocument( const char * documentName );
1393 
1394  #ifdef TIXML_USE_STL
1395  TiXmlDocument( const std::string& documentName );
1397  #endif
1398 
1399  TiXmlDocument( const TiXmlDocument& copy );
1400  void operator=( const TiXmlDocument& copy );
1401 
1402  virtual ~TiXmlDocument() {}
1403 
1408  bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
1410  bool SaveFile() const;
1412  bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
1414  bool SaveFile( const char * filename ) const;
1420  bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
1422  bool SaveFile( FILE* ) const;
1423 
1424  #ifdef TIXML_USE_STL
1425  bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )
1426  {
1427  return LoadFile( filename.c_str(), encoding );
1428  }
1429  bool SaveFile( const std::string& filename ) const
1430  {
1431  return SaveFile( filename.c_str() );
1432  }
1433  #endif
1434 
1439  virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
1440 
1445  const TiXmlElement* RootElement() const { return FirstChildElement(); }
1447 
1453  bool Error() const { return error; }
1454 
1456  const char * ErrorDesc() const { return errorDesc.c_str (); }
1457 
1461  int ErrorId() const { return errorId; }
1462 
1470  int ErrorRow() const { return errorLocation.row+1; }
1471  int ErrorCol() const { return errorLocation.col+1; }
1472 
1497  void SetTabSize( int _tabsize ) { tabsize = _tabsize; }
1498 
1499  int TabSize() const { return tabsize; }
1500 
1504  void ClearError() { error = false;
1505  errorId = 0;
1506  errorDesc = "";
1507  errorLocation.row = errorLocation.col = 0;
1508  //errorLocation.last = 0;
1509  }
1510 
1512  void Print() const { Print( stdout, 0 ); }
1513 
1514  /* Write the document to a string using formatted printing ("pretty print"). This
1515  will allocate a character array (new char[]) and return it as a pointer. The
1516  calling code pust call delete[] on the return char* to avoid a memory leak.
1517  */
1518  //char* PrintToMemory() const;
1519 
1521  virtual void Print( FILE* cfile, int depth = 0 ) const;
1522  // [internal use]
1523  void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
1524 
1525  virtual const TiXmlDocument* ToDocument() const { return this; }
1526  virtual TiXmlDocument* ToDocument() { return this; }
1527 
1530  virtual bool Accept( TiXmlVisitor* content ) const;
1531 
1532 protected :
1533  // [internal use]
1534  virtual TiXmlNode* Clone() const;
1535  #ifdef TIXML_USE_STL
1536  virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
1537  #endif
1538 
1539 private:
1540  void CopyTo( TiXmlDocument* target ) const;
1541 
1542  bool error;
1543  int errorId;
1544  TIXML_STRING errorDesc;
1545  int tabsize;
1546  TiXmlCursor errorLocation;
1547  bool useMicrosoftBOM; // the UTF-8 BOM were found when read. Note this, and try to write.
1548 };
1549 
1550 
1631 class TINYXML_DLL TiXmlHandle
1632 {
1633 public:
1635  TiXmlHandle( TiXmlNode* _node ) { this->node = _node; }
1637  TiXmlHandle( const TiXmlHandle& ref ) { this->node = ref.node; }
1638  TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
1639 
1641  TiXmlHandle FirstChild() const;
1643  TiXmlHandle FirstChild( const char * value ) const;
1645  TiXmlHandle FirstChildElement() const;
1647  TiXmlHandle FirstChildElement( const char * value ) const;
1648 
1652  TiXmlHandle Child( const char* value, int index ) const;
1656  TiXmlHandle Child( int index ) const;
1661  TiXmlHandle ChildElement( const char* value, int index ) const;
1666  TiXmlHandle ChildElement( int index ) const;
1667 
1668  #ifdef TIXML_USE_STL
1669  TiXmlHandle FirstChild( const std::string& _value ) const { return FirstChild( _value.c_str() ); }
1670  TiXmlHandle FirstChildElement( const std::string& _value ) const { return FirstChildElement( _value.c_str() ); }
1671 
1672  TiXmlHandle Child( const std::string& _value, int index ) const { return Child( _value.c_str(), index ); }
1673  TiXmlHandle ChildElement( const std::string& _value, int index ) const { return ChildElement( _value.c_str(), index ); }
1674  #endif
1675 
1678  TiXmlNode* ToNode() const { return node; }
1681  TiXmlElement* ToElement() const { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
1684  TiXmlText* ToText() const { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
1687  TiXmlUnknown* ToUnknown() const { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
1688 
1692  TiXmlNode* Node() const { return ToNode(); }
1696  TiXmlElement* Element() const { return ToElement(); }
1700  TiXmlText* Text() const { return ToText(); }
1704  TiXmlUnknown* Unknown() const { return ToUnknown(); }
1705 
1706 private:
1707  TiXmlNode* node;
1708 };
1709 
1710 
1730 class TINYXML_DLL TiXmlPrinter : public TiXmlVisitor
1731 {
1732 public:
1733  TiXmlPrinter() : depth( 0 ), simpleTextPrint( false ),
1734  buffer(), indent( " " ), lineBreak( "\n" ) {}
1735 
1736  virtual bool VisitEnter( const TiXmlDocument& doc );
1737  virtual bool VisitExit( const TiXmlDocument& doc );
1738 
1739  virtual bool VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute );
1740  virtual bool VisitExit( const TiXmlElement& element );
1741 
1742  virtual bool Visit( const TiXmlDeclaration& declaration );
1743  virtual bool Visit( const TiXmlText& text );
1744  virtual bool Visit( const TiXmlComment& comment );
1745  virtual bool Visit( const TiXmlUnknown& unknown );
1746 
1750  void SetIndent( const char* _indent ) { indent = _indent ? _indent : "" ; }
1752  const char* Indent() { return indent.c_str(); }
1757  void SetLineBreak( const char* _lineBreak ) { lineBreak = _lineBreak ? _lineBreak : ""; }
1759  const char* LineBreak() { return lineBreak.c_str(); }
1760 
1764  void SetStreamPrinting() { indent = "";
1765  lineBreak = "";
1766  }
1768  const char* CStr() { return buffer.c_str(); }
1770  size_t Size() { return buffer.size(); }
1771 
1772  #ifdef TIXML_USE_STL
1773  const std::string& Str() { return buffer; }
1775  #endif
1776 
1777 private:
1778  void DoIndent() {
1779  for( int i=0; i<depth; ++i )
1780  buffer += indent;
1781  }
1782  void DoLineBreak() {
1783  buffer += lineBreak;
1784  }
1785 
1786  int depth;
1787  bool simpleTextPrint;
1789  TIXML_STRING indent;
1790  TIXML_STRING lineBreak;
1791 };
1792 
1793 
1794 #ifdef _MSC_VER
1795 #pragma warning( pop )
1796 #endif
1797 
1798 #endif
1799 
void ClearError()
Definition: tinyxml.h:1504
TiXmlAttribute * LastAttribute()
Definition: tinyxml.h:1080
virtual TiXmlUnknown * ToUnknown()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1364
EGLSurface EGLint attribute
Definition: eglext.h:301
TiXmlAttribute * Next()
Definition: tinyxml.h:850
TiXmlBase()
Definition: tinyxml.h:201
TiXmlNode * Parent()
One step up the DOM.
Definition: tinyxml.h:519
TiXmlCursor()
Definition: tinyxml.h:101
void SetTabSize(int _tabsize)
Definition: tinyxml.h:1497
int ErrorId() const
Definition: tinyxml.h:1461
void operator=(const TiXmlText &base)
Definition: tinyxml.h:1230
TiXmlNode * LinkEndChild(TiXmlNode *addThis)
Definition: tinyxml.cpp:186
static const char * ReadName(const char *p, TIXML_STRING *name, TiXmlEncoding encoding)
TiXmlComment(const char *_value)
Construct a comment from text.
Definition: tinyxml.h:1161
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum type
Definition: gl2ext.h:845
TiXmlHandle operator=(const TiXmlHandle &ref)
Definition: tinyxml.h:1638
const TIXML_STRING & NameTStr() const
Definition: tinyxml.h:820
static const char * GetChar(const char *p, char *_value, int *length, TiXmlEncoding encoding)
Definition: tinyxml.h:327
void SetCDATA(bool _cdata)
Turns on or off a CDATA representation of text.
Definition: tinyxml.h:1238
virtual const TiXmlComment * ToComment() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1179
static const char * SkipWhiteSpace(const char *, TiXmlEncoding encoding)
const char * Version() const
Version. Will return an empty string if none was found.
Definition: tinyxml.h:1302
void CopyTo(TiXmlElement *target) const
Definition: tinyxml.cpp:809
int Type() const
Definition: tinyxml.h:684
virtual ~TiXmlDeclaration()
Definition: tinyxml.h:1299
const TiXmlNode * LastChild() const
Definition: tinyxml.h:531
GLuint start
Definition: glew.h:1239
bool Error() const
Definition: tinyxml.h:1453
int Column() const
See Row()
Definition: tinyxml.h:245
GLint location
Definition: gl2ext.h:1164
virtual TiXmlNode * Clone() const =0
const TiXmlAttribute * First() const
Definition: tinyxml.h:912
const char * Standalone() const
Is this a standalone document?
Definition: tinyxml.h:1306
TiXmlNode * firstChild
Definition: tinyxml.h:758
TiXmlNode * Node() const
Definition: tinyxml.h:1692
static void SetCondenseWhiteSpace(bool condense)
Definition: tinyxml.h:221
static bool IsWhiteSpace(char c)
Definition: tinyxml.h:290
GLuint in
Definition: glew.h:10672
size_t Size()
Return the length of the result string.
Definition: tinyxml.h:1770
bool RemoveChild(TiXmlNode *removeThis)
Delete a child of this node.
Definition: tinyxml.cpp:331
int const char * version
Definition: zlib.h:813
TiXmlHandle(TiXmlNode *_node)
Create a handle from any node (at any depth of the tree.) This can be a null pointer.
Definition: tinyxml.h:1635
virtual bool Accept(TiXmlVisitor *visitor) const
Definition: tinyxml.cpp:831
static void ConvertUTF32ToUTF8(unsigned long input, char *output, int *length)
virtual bool VisitEnter(const TiXmlElement &, const TiXmlAttribute *)
Visit an element.
Definition: tinyxml.h:139
TIXML_STRING value
Definition: tinyxml.h:761
TiXmlElement * FirstChildElement(const char *_value)
Definition: tinyxml.h:671
virtual const TiXmlText * ToText() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1242
EGLImageKHR EGLint * name
Definition: eglext.h:284
std::istream & operator>>(std::istream &is, Zeni::String &str)
Definition: String.cpp:582
static int IsAlpha(unsigned char anyByte, TiXmlEncoding encoding)
virtual const char * Parse(const char *p, TiXmlParsingData *data, TiXmlEncoding encoding)=0
TiXmlText * Text() const
Definition: tinyxml.h:1700
const int TIXML_PATCH_VERSION
Definition: tinyxml.h:94
void SetIndent(const char *_indent)
Definition: tinyxml.h:1750
virtual TiXmlText * ToText()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1243
return Display return Display Bool Bool int d
Definition: SDL_x11sym.h:30
#define assert(x)
Definition: SDL_malloc.c:1234
virtual TiXmlUnknown * ToUnknown()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:707
static int IsAlphaNum(unsigned char anyByte, TiXmlEncoding encoding)
const char * Value() const
Definition: tinyxml.h:487
const void * GetUserData() const
Get a pointer to arbitrary user data.
Definition: tinyxml.h:249
virtual ~TiXmlBase()
Definition: tinyxml.h:202
TiXmlElement * Element() const
Definition: tinyxml.h:1696
TiXmlDocument * GetDocument()
Definition: tinyxml.h:690
void Clear()
Definition: tinyxml.h:102
TiXmlElement * ToElement() const
Definition: tinyxml.h:1681
static bool IsWhiteSpace(int c)
Definition: tinyxml.h:294
const char * Name() const
Return the name of this attribute.
Definition: tinyxml.h:811
virtual void Print(FILE *cfile, int depth) const
Definition: tinyxml.h:1312
virtual TiXmlDocument * ToDocument()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:704
virtual TiXmlNode * Clone() const
Creates a new Element and returns it - the returned element is a copy.
Definition: tinyxml.cpp:845
void CopyTo(TiXmlText *target) const
Definition: tinyxml.cpp:1307
TiXmlAttribute * First()
Definition: tinyxml.h:913
const TiXmlAttribute * LastAttribute() const
Access the last attribute in this element.
Definition: tinyxml.h:1079
const TiXmlNode * Parent() const
Definition: tinyxml.h:520
static const char * GetEntity(const char *in, char *value, int *length, TiXmlEncoding encoding)
bool operator>(const TiXmlAttribute &rhs) const
Definition: tinyxml.h:862
TiXmlComment()
Constructs an empty comment.
Definition: tinyxml.h:1159
virtual const TiXmlDocument * ToDocument() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1525
int QueryFloatAttribute(const char *name, float *_value) const
QueryFloatAttribute examines the attribute - see QueryIntAttribute().
Definition: tinyxml.h:989
void SetStreamPrinting()
Definition: tinyxml.h:1764
EGLContext EGLenum target
Definition: eglext.h:87
int ErrorCol() const
The column where the error occured. See ErrorRow()
Definition: tinyxml.h:1471
int ErrorRow() const
Definition: tinyxml.h:1470
TiXmlNode * lastChild
Definition: tinyxml.h:759
TiXmlUnknown * ToUnknown() const
Definition: tinyxml.h:1687
const TiXmlNode * PreviousSibling() const
Navigate to a sibling node.
Definition: tinyxml.h:614
EGLContext EGLenum EGLClientBuffer buffer
Definition: eglext.h:87
TiXmlNode * ReplaceChild(TiXmlNode *replaceThis, const TiXmlNode &withThis)
Definition: tinyxml.cpp:292
TiXmlText(const char *initValue)
Definition: tinyxml.h:1213
friend class TiXmlNode
Definition: tinyxml.h:196
virtual bool VisitExit(const TiXmlElement &)
Visit an element.
Definition: tinyxml.h:141
virtual bool Visit(const TiXmlComment &)
Visit a comment node.
Definition: tinyxml.h:148
TiXmlNode * prev
Definition: tinyxml.h:763
void SetName(const char *_name)
Set the name of this attribute.
Definition: tinyxml.h:835
const TiXmlEncoding TIXML_DEFAULT_ENCODING
Definition: tinyxml.h:170
TiXmlAttribute()
Construct an empty attribute.
Definition: tinyxml.h:785
virtual ~TiXmlText()
Definition: tinyxml.h:1218
GLenum GLenum GLvoid * row
Definition: glew.h:4447
TiXmlText(const TiXmlText &copy)
Definition: tinyxml.h:1229
GLuint64EXT * result
Definition: glew.h:12708
virtual const char * Parse(const char *p, TiXmlParsingData *data=0, TiXmlEncoding encoding=TIXML_DEFAULT_ENCODING)
const GLdouble * v
Definition: glew.h:1377
virtual TiXmlDeclaration * ToDeclaration()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1319
virtual TiXmlDeclaration * ToDeclaration()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:709
const int TIXML_MAJOR_VERSION
Definition: tinyxml.h:92
bool operator==(const TiXmlAttribute &rhs) const
Definition: tinyxml.h:860
GLsizei GLsizei * length
Definition: gl2ext.h:792
virtual bool Visit(const TiXmlText &)
Visit a text node.
Definition: tinyxml.h:146
bool operator<(const TiXmlAttribute &rhs) const
Definition: tinyxml.h:861
const TiXmlAttribute * FirstAttribute() const
Access the first attribute in this element.
Definition: tinyxml.h:1077
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl2ext.h:848
void Clear()
Delete all the children of this node. Does not affect &#39;this&#39;.
Definition: tinyxml.cpp:169
FT_Error error
Definition: cffdrivr.c:407
TiXmlElement * NextSiblingElement(const char *_next)
Definition: tinyxml.h:654
TiXmlNode * next
Definition: tinyxml.h:764
virtual bool VisitEnter(const TiXmlDocument &)
Visit a document.
Definition: tinyxml.h:134
const TiXmlElement * NextSiblingElement() const
Definition: tinyxml.cpp:478
GLfloat GLfloat p
Definition: glew.h:14938
static const int utf8ByteTable[256]
Definition: tinyxml.h:253
TiXmlNode * FirstChild()
Definition: tinyxml.h:523
virtual bool Visit(const TiXmlUnknown &)
Visit an unknow node.
Definition: tinyxml.h:150
const GLfloat * c
Definition: glew.h:14913
void operator=(const TiXmlElement &base)
Definition: tinyxml.cpp:547
TiXmlDeclaration()
Construct an empty declaration.
Definition: tinyxml.h:1282
bool NoChildren() const
Returns true if this node has no children.
Definition: tinyxml.h:695
TiXmlEncoding
Definition: tinyxml.h:163
static const char * ReadText(const char *in, TIXML_STRING *text, bool ignoreWhiteSpace, const char *endTag, bool ignoreCase, TiXmlEncoding encoding)
TiXmlElement * NextSiblingElement()
Definition: tinyxml.h:645
static void EncodeString(const TIXML_STRING &str, TIXML_STRING *out)
Definition: tinyxml.cpp:52
virtual const TiXmlElement * ToElement() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1126
NodeType type
Definition: tinyxml.h:756
GLint GLenum GLsizei GLsizei GLsizei depth
Definition: gl2ext.h:845
GLuint index
Definition: glew.h:1800
virtual bool Accept(TiXmlVisitor *visitor) const =0
void * userData
Field containing a generic user pointer.
Definition: tinyxml.h:376
void SetValue(const char *_value)
Set the value.
Definition: tinyxml.h:836
friend class TiXmlDocument
Definition: tinyxml.h:425
virtual void Print(FILE *cfile, int depth) const
Definition: tinyxml.h:870
TiXmlNode * InsertAfterChild(TiXmlNode *afterThis, const TiXmlNode &addThis)
Definition: tinyxml.cpp:260
void operator=(const TiXmlDocument &copy)
Definition: tinyxml.cpp:902
virtual const TiXmlText * ToText() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:701
static int ToLower(int v, TiXmlEncoding encoding)
Definition: tinyxml.h:382
void * GetUserData()
Get a pointer to arbitrary user data.
Definition: tinyxml.h:248
friend class TiXmlElement
Definition: tinyxml.h:426
const TIXML_STRING & ValueTStr() const
Definition: tinyxml.h:497
virtual TiXmlDocument * ToDocument()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1526
const char * CStr()
Return the result.
Definition: tinyxml.h:1768
TiXmlNode * NextSibling(const char *_next)
Definition: tinyxml.h:636
std::ostream & operator<<(std::ostream &out, const Token &token)
Definition: Token.cpp:74
TiXmlElement * RootElement()
Definition: tinyxml.h:1446
const TiXmlNode * NextSibling() const
Navigate to a sibling node.
Definition: tinyxml.h:631
virtual bool Visit(const TiXmlDeclaration &)
Visit a declaration.
Definition: tinyxml.h:144
void CopyTo(TiXmlUnknown *target) const
Definition: tinyxml.cpp:1429
virtual const TiXmlElement * ToElement() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:698
const char * Indent()
Query the indention string.
Definition: tinyxml.h:1752
virtual const TiXmlDeclaration * ToDeclaration() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1318
GLenum GLenum GLenum input
Definition: glew.h:12631
EGLSurface EGLint void ** value
Definition: eglext.h:301
void SetValue(const char *_value)
Definition: tinyxml.h:508
const TiXmlNode * IterateChildren(const TiXmlNode *previous) const
Definition: tinyxml.cpp:381
const char * Encoding() const
Encoding. Will return an empty string if none was found.
Definition: tinyxml.h:1304
void Print() const
Definition: tinyxml.h:1512
static bool IsWhiteSpaceCondensed()
Return the current white space setting.
Definition: tinyxml.h:224
TiXmlAttribute * Last()
Definition: tinyxml.h:915
virtual const TiXmlUnknown * ToUnknown() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1363
static bool StringEqual(const char *p, const char *endTag, bool ignoreCase, TiXmlEncoding encoding)
TiXmlAttribute * FirstAttribute()
Definition: tinyxml.h:1078
int TabSize() const
Definition: tinyxml.h:1499
virtual void Print(FILE *cfile, int depth) const =0
TiXmlNode * InsertBeforeChild(TiXmlNode *beforeThis, const TiXmlNode &addThis)
Definition: tinyxml.cpp:228
virtual TiXmlComment * ToComment()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:706
GLsizei const GLcharARB ** string
Definition: glew.h:5638
virtual const TiXmlDocument * ToDocument() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:697
virtual ~TiXmlVisitor()
Definition: tinyxml.h:131
virtual TiXmlComment * ToComment()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1180
void SetDocument(TiXmlDocument *doc)
Definition: tinyxml.h:877
virtual const TiXmlDeclaration * ToDeclaration() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:702
TiXmlNode * parent
Definition: tinyxml.h:755
TiXmlElement * FirstChildElement()
Definition: tinyxml.h:665
int Row() const
Definition: tinyxml.h:244
const char * ErrorDesc() const
Contains a textual (english) description of the error if one occurs.
Definition: tinyxml.h:1456
TiXmlNode * PreviousSibling(const char *_prev)
Definition: tinyxml.h:619
TiXmlNode * Identify(const char *start, TiXmlEncoding encoding)
void SetLineBreak(const char *_lineBreak)
Definition: tinyxml.h:1757
TiXmlNode * LastChild(const char *_value)
The last child of this node matching &#39;value&#39;. Will be null if there are no children.
Definition: tinyxml.h:535
static const char * errorString[TIXML_ERROR_STRING_COUNT]
Definition: tinyxml.h:371
virtual ~TiXmlComment()
Definition: tinyxml.h:1167
virtual const TiXmlComment * ToComment() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:699
GLclampf ref
Definition: gl2ext.h:1455
TiXmlUnknown(const TiXmlUnknown &copy)
Definition: tinyxml.h:1353
virtual bool VisitExit(const TiXmlDocument &)
Visit a document.
Definition: tinyxml.h:136
virtual TiXmlText * ToText()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:708
TiXmlNode * PreviousSibling()
Definition: tinyxml.h:615
const char * Value() const
Return the value of this attribute.
Definition: tinyxml.h:812
#define str(s)
virtual ~TiXmlDocument()
Definition: tinyxml.h:1402
const char * LineBreak()
Query the current line breaking string.
Definition: tinyxml.h:1759
TiXmlNode * LastChild()
The last child of this node. Will be null if there are no children.
Definition: tinyxml.h:532
int i
Definition: pngrutil.c:1377
const TiXmlDocument * GetDocument() const
Definition: tinyxml.cpp:508
TiXmlCursor location
Definition: tinyxml.h:373
TiXmlNode * IterateChildren(const TiXmlNode *previous)
Definition: tinyxml.h:563
virtual const TiXmlUnknown * ToUnknown() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:700
void operator=(const TiXmlUnknown &copy)
Definition: tinyxml.h:1354
const TiXmlAttribute * Last() const
Definition: tinyxml.h:914
const TiXmlNode * FirstChild() const
The first child of this node. Will be null if there are no children.
Definition: tinyxml.h:522
TiXmlNode * IterateChildren(const char *_value, const TiXmlNode *previous)
Definition: tinyxml.h:569
TiXmlUnknown * Unknown() const
Definition: tinyxml.h:1704
void SetUserData(void *user)
Set a pointer to arbitrary user data.
Definition: tinyxml.h:247
virtual TiXmlElement * ToElement()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:705
TiXmlHandle(const TiXmlHandle &ref)
Copy constructor.
Definition: tinyxml.h:1637
virtual ~TiXmlUnknown()
Definition: tinyxml.h:1351
bool CDATA() const
Queries whether this represents text using a CDATA section.
Definition: tinyxml.h:1236
virtual ~TiXmlNode()
Definition: tinyxml.cpp:147
const TiXmlElement * RootElement() const
Definition: tinyxml.h:1445
#define false
Definition: ftrandom.c:50
TiXmlNode * ToNode() const
Definition: tinyxml.h:1678
TiXmlNode * NextSibling()
Definition: tinyxml.h:632
#define TIXML_STRING
Definition: tinyxml.h:53
const int TIXML_MINOR_VERSION
Definition: tinyxml.h:93
virtual TiXmlElement * ToElement()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1127
const TiXmlElement * FirstChildElement() const
Convenience function to get through elements.
Definition: tinyxml.cpp:448
TiXmlText * ToText() const
Definition: tinyxml.h:1684
void CopyTo(TiXmlNode *target) const
Definition: tinyxml.cpp:161
TiXmlNode * InsertEndChild(const TiXmlNode &addThis)
Definition: tinyxml.cpp:213
TiXmlAttribute * Previous()
Definition: tinyxml.h:856
TiXmlAttribute(const char *_name, const char *_value)
Construct an attribute with a name and value.
Definition: tinyxml.h:803