DD4hep - The AIDA detector description toolkit for high energy physics experiments
DD4hep  Rev:Unversioneddirectory
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator 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  F.Gaede, DESY : added #define TIXML_USE_STL for use with marlin
26 */
27 
28 #ifndef TIXML_USE_STL
29 #define TIXML_USE_STL
30 #endif
31 
32 #ifndef TINYXML_INCLUDED
33 #define TINYXML_INCLUDED
34 
35 #ifdef _MSC_VER
36 #pragma warning( push )
37 #pragma warning( disable : 4530 )
38 #pragma warning( disable : 4786 )
39 #endif
40 
41 #include <ctype.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <assert.h>
46 
47 // Help out windows:
48 #if defined( _DEBUG ) && !defined( DEBUG )
49 #define DEBUG
50 #endif
51 
52 #ifdef TIXML_USE_STL
53 #include <string>
54 #include <iostream>
55 #include <sstream>
56 #define TIXML_STRING std::string
57 #else
58 #include "tinystr.h"
59 #define TIXML_STRING TiXmlString
60 #endif
61 
62 // Deprecated library function hell. Compilers want to use the
63 // new safe versions. This probably doesn't fully address the problem,
64 // but it gets closer. There are too many compilers for me to fully
65 // test. If you get compilation troubles, undefine TIXML_SAFE
66 #define TIXML_SAFE
67 
68 #ifdef TIXML_SAFE
69 #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
70 // Microsoft visual studio, version 2005 and higher.
71 #define TIXML_SNPRINTF _snprintf_s
72 #define TIXML_SNSCANF _snscanf_s
73 #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
74 // Microsoft visual studio, version 6 and higher.
75 //#pragma message( "Using _sn* functions." )
76 #define TIXML_SNPRINTF _snprintf
77 #define TIXML_SNSCANF _snscanf
78 #elif defined(__GNUC__) && (__GNUC__ >= 3 )
79 // GCC version 3 and higher.s
80 //#warning( "Using sn* functions." )
81 #define TIXML_SNPRINTF snprintf
82 #define TIXML_SNSCANF snscanf
83 #endif
84 #endif
85 
86 class TiXmlDocument;
87 class TiXmlElement;
88 class TiXmlComment;
89 class TiXmlUnknown;
90 class TiXmlAttribute;
91 class TiXmlText;
92 class TiXmlDeclaration;
93 class TiXmlParsingData;
94 
95 const int TIXML_MAJOR_VERSION = 2;
96 const int TIXML_MINOR_VERSION = 5;
97 const int TIXML_PATCH_VERSION = 2;
98 
99 /* Internal structure for tracking location of items
100  in the XML file.
101 */
102 struct TiXmlCursor {
104  Clear();
105  }
106  void Clear() {
107  row = col = -1;
108  }
109 
110  int row; // 0 based.
111  int col; // 0 based.
112 };
113 
133 public:
134  virtual ~TiXmlVisitor() {
135  }
136 
138  virtual bool VisitEnter(const TiXmlDocument& /* doc */) {
139  return true;
140  }
142  virtual bool VisitExit(const TiXmlDocument& /* doc */) {
143  return true;
144  }
145 
147  virtual bool VisitEnter(const TiXmlElement& /* element */, const TiXmlAttribute* /* firstAttribute */) {
148  return true;
149  }
151  virtual bool VisitExit(const TiXmlElement& /* element */) {
152  return true;
153  }
154 
156  virtual bool Visit(const TiXmlDeclaration& /* declaration */) {
157  return true;
158  }
160  virtual bool Visit(const TiXmlText& /* text */) {
161  return true;
162  }
164  virtual bool Visit(const TiXmlComment& /* comment */) {
165  return true;
166  }
168  virtual bool Visit(const TiXmlUnknown& /* unknown */) {
169  return true;
170  }
171 };
172 
173 // Only used by Attribute::Query functions
174 enum {
176 };
177 
178 // Used by the parsing routines.
181 };
182 
184 
207 class TiXmlBase {
208  friend class TiXmlNode;
209  friend class TiXmlElement;
210  friend class TiXmlDocument;
211 
212 public:
214  : userData(0) {
215  }
216  virtual ~TiXmlBase() {
217  }
218 
228  virtual void Print(FILE* cfile, int depth) const = 0;
229 
236  static void SetCondenseWhiteSpace(bool condense) {
237  condenseWhiteSpace = condense;
238  }
239 
241  static bool IsWhiteSpaceCondensed() {
242  return condenseWhiteSpace;
243  }
244 
263  int Row() const {
264  return location.row + 1;
265  }
266  int Column() const {
267  return location.col + 1;
268  }
269 
270  void SetUserData(void* user) {
271  userData = user;
272  }
273  void* GetUserData() {
274  return userData;
275  }
276  const void* GetUserData() const {
277  return userData;
278  }
279 
280  // Table that returs, for a given lead byte, the total number of bytes
281  // in the UTF-8 sequence.
282  static const int utf8ByteTable[256];
283 
284  virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */) = 0;
285 
286  enum {
304 
306  };
307 
308 protected:
309 
310  static const char* SkipWhiteSpace(const char*, TiXmlEncoding encoding);
311  inline static bool IsWhiteSpace(char c) {
312  return (isspace((unsigned char) c) || c == '\n' || c == '\r');
313  }
314  inline static bool IsWhiteSpace(int c) {
315  if (c < 256)
316  return IsWhiteSpace((char) c);
317  return false; // Again, only truly correct for English/Latin...but usually works.
318  }
319 
320 #ifdef TIXML_USE_STL
321  static bool StreamWhiteSpace(std::istream * in, TIXML_STRING * tag);
322  static bool StreamTo(std::istream * in, int character, TIXML_STRING * tag);
323 #endif
324 
325  /* Reads an XML name into the string provided. Returns
326  a pointer just past the last character of the name,
327  or 0 if the function has an error.
328  */
329  static const char* ReadName(const char* p, TIXML_STRING* name, TiXmlEncoding encoding);
330 
331  /* Reads text. Returns a pointer past the given end tag.
332  Wickedly complex options, but it keeps the (sensitive) code in one place.
333  */
334  static const char* ReadText(const char* in, // where to start
335  TIXML_STRING* text, // the string read
336  bool ignoreWhiteSpace, // whether to keep the white space
337  const char* endTag, // what ends this text
338  bool ignoreCase, // whether to ignore case in the end tag
339  TiXmlEncoding encoding); // the current encoding
340 
341  // If an entity has been found, transform it into a character.
342  static const char* GetEntity(const char* in, char* value, int* length, TiXmlEncoding encoding);
343 
344  // Get a character, while interpreting entities.
345  // The length can be from 0 to 4 bytes.
346  inline static const char* GetChar(const char* p, char* _value, int* length, TiXmlEncoding encoding) {
347  assert( p);
348  if (encoding == TIXML_ENCODING_UTF8) {
349  *length = utf8ByteTable[*((const unsigned char*) p)];
350  assert( *length >= 0 && *length < 5);
351  }
352  else {
353  *length = 1;
354  }
355 
356  if (*length == 1) {
357  if (*p == '&')
358  return GetEntity(p, _value, length, encoding);
359  *_value = *p;
360  return p + 1;
361  }
362  else if (*length) {
363  //strncpy( _value, p, *length ); // lots of compilers don't like this function (unsafe),
364  // and the null terminator isn't needed
365  for (int i = 0; p[i] && i < *length; ++i) {
366  _value[i] = p[i];
367  }
368  return p + (*length);
369  }
370  else {
371  // Not valid text.
372  return 0;
373  }
374  }
375 
376  // Puts a string to a stream, expanding entities as it goes.
377  // Note this should not contian the '<', '>', etc, or they will be transformed into entities!
378  static void PutString(const TIXML_STRING& str, TIXML_STRING* out);
379 
380  // Return true if the next characters in the stream are any of the endTag sequences.
381  // Ignore case only works for english, and should only be relied on when comparing
382  // to English words: StringEqual( p, "version", true ) is fine.
383  static bool StringEqual(const char* p, const char* endTag, bool ignoreCase, TiXmlEncoding encoding);
384 
386 
388 
390  void* userData;
391 
392  // None of these methods are reliable for any language except English.
393  // Good for approximation, not great for accuracy.
394  static int IsAlpha(unsigned char anyByte, TiXmlEncoding encoding);
395  static int IsAlphaNum(unsigned char anyByte, TiXmlEncoding encoding);
396  inline static int ToLower(int v, TiXmlEncoding encoding) {
397  if (encoding == TIXML_ENCODING_UTF8) {
398  if (v < 128)
399  return tolower(v);
400  return v;
401  }
402  else {
403  return tolower(v);
404  }
405  }
406  static void ConvertUTF32ToUTF8(unsigned long input, char* output, int* length);
407 
408 private:
409  TiXmlBase(const TiXmlBase&); // not implemented.
410  void operator=(const TiXmlBase& base); // not allowed.
411 
412  struct Entity {
413  const char* str;
414  unsigned int strLength;
415  char chr;
416  };
417  enum {
419 
420  };
422  static bool condenseWhiteSpace;
423 };
424 
431 class TiXmlNode: public TiXmlBase {
432  friend class TiXmlDocument;
433  friend class TiXmlElement;
434 
435 public:
436 #ifdef TIXML_USE_STL
437 
441  friend std::istream& operator >>(std::istream& in, TiXmlNode& base);
442 
459  friend std::ostream& operator<<(std::ostream& out, const TiXmlNode& base);
460 
462  friend std::string& operator<<(std::string& out, const TiXmlNode& base);
463 
464 #endif
465 
469  enum NodeType {
471  };
472 
473  virtual ~TiXmlNode();
474 
487  const char *Value() const {
488  return value.c_str();
489  }
490 
491 #ifdef TIXML_USE_STL
492 
496  const std::string& ValueStr() const {
497  return value;
498  }
499 #endif
500 
510  void SetValue(const char * _value) {
511  value = _value;
512  }
513 
514 #ifdef TIXML_USE_STL
515  void SetValue(const std::string& _value) {
517  value = _value;
518  }
519 #endif
520 
522  void Clear();
523 
526  return parent;
527  }
528  const TiXmlNode* Parent() const {
529  return parent;
530  }
531 
532  const TiXmlNode* FirstChild() const {
533  return firstChild;
534  }
536  return firstChild;
537  }
538  const TiXmlNode* FirstChild(const char * value) const;
539  TiXmlNode* FirstChild(const char * _value) {
541  // Call through to the const version - safe since nothing is changed. Exiting syntax: cast this to a const (always safe)
542  // call the method, cast the return back to non-const.
543  return const_cast<TiXmlNode*>((const_cast<const TiXmlNode*>(this))->FirstChild(_value));
544  }
545  const TiXmlNode* LastChild() const {
546  return lastChild;
547  }
549  return lastChild;
550  }
551 
552  const TiXmlNode* LastChild(const char * value) const;
553  TiXmlNode* LastChild(const char * _value) {
554  return const_cast<TiXmlNode*>((const_cast<const TiXmlNode*>(this))->LastChild(_value));
555  }
556 
557 #ifdef TIXML_USE_STL
558  const TiXmlNode* FirstChild(const std::string& _value) const {
559  return FirstChild(_value.c_str());
560  }
561  TiXmlNode* FirstChild(const std::string& _value) {
562  return FirstChild(_value.c_str());
563  }
564  const TiXmlNode* LastChild(const std::string& _value) const {
565  return LastChild(_value.c_str());
566  }
567  TiXmlNode* LastChild(const std::string& _value) {
568  return LastChild(_value.c_str());
569  }
570 #endif
571 
588  const TiXmlNode* IterateChildren(const TiXmlNode* previous) const;
589  TiXmlNode* IterateChildren(const TiXmlNode* previous) {
590  return const_cast<TiXmlNode*>((const_cast<const TiXmlNode*>(this))->IterateChildren(previous));
591  }
592 
594  const TiXmlNode* IterateChildren(const char * value, const TiXmlNode* previous) const;
595  TiXmlNode* IterateChildren(const char * _value, const TiXmlNode* previous) {
596  return const_cast<TiXmlNode*>((const_cast<const TiXmlNode*>(this))->IterateChildren(_value, previous));
597  }
598 
599 #ifdef TIXML_USE_STL
600  const TiXmlNode* IterateChildren(const std::string& _value, const TiXmlNode* previous) const {
601  return IterateChildren(_value.c_str(), previous);
602  }
603  TiXmlNode* IterateChildren(const std::string& _value, const TiXmlNode* previous) {
604  return IterateChildren(_value.c_str(), previous);
605  }
606 #endif
607 
611  TiXmlNode* InsertEndChild(const TiXmlNode& addThis);
612 
622  TiXmlNode* LinkEndChild(TiXmlNode* addThis);
623 
627  TiXmlNode* InsertBeforeChild(TiXmlNode* beforeThis, const TiXmlNode& addThis);
628 
632  TiXmlNode* InsertAfterChild(TiXmlNode* afterThis, const TiXmlNode& addThis);
633 
637  TiXmlNode* ReplaceChild(TiXmlNode* replaceThis, const TiXmlNode& withThis);
638 
640  bool RemoveChild(TiXmlNode* removeThis);
641 
643  const TiXmlNode* PreviousSibling() const {
644  return prev;
645  }
647  return prev;
648  }
649 
651  const TiXmlNode* PreviousSibling(const char *) const;
652  TiXmlNode* PreviousSibling(const char *_prev) {
653  return const_cast<TiXmlNode*>((const_cast<const TiXmlNode*>(this))->PreviousSibling(_prev));
654  }
655 
656 #ifdef TIXML_USE_STL
657  const TiXmlNode* PreviousSibling(const std::string& _value) const {
658  return PreviousSibling(_value.c_str());
659  }
660  TiXmlNode* PreviousSibling(const std::string& _value) {
661  return PreviousSibling(_value.c_str());
662  }
663  const TiXmlNode* NextSibling(const std::string& _value) const {
664  return NextSibling(_value.c_str());
665  }
666  TiXmlNode* NextSibling(const std::string& _value) {
667  return NextSibling(_value.c_str());
668  }
669 #endif
670 
672  const TiXmlNode* NextSibling() const {
673  return next;
674  }
676  return next;
677  }
678 
680  const TiXmlNode* NextSibling(const char *) const;
681  TiXmlNode* NextSibling(const char* _next) {
682  return const_cast<TiXmlNode*>((const_cast<const TiXmlNode*>(this))->NextSibling(_next));
683  }
684 
689  const TiXmlElement* NextSiblingElement() const;
691  return const_cast<TiXmlElement*>((const_cast<const TiXmlNode*>(this))->NextSiblingElement());
692  }
693 
698  const TiXmlElement* NextSiblingElement(const char *) const;
699  TiXmlElement* NextSiblingElement(const char *_next) {
700  return const_cast<TiXmlElement*>((const_cast<const TiXmlNode*>(this))->NextSiblingElement(_next));
701  }
702 
707  const TiXmlElement* PreviousSiblingElement() const;
709  return const_cast<TiXmlElement*>((const_cast<const TiXmlNode*>(this))->PreviousSiblingElement());
710  }
711 
716  const TiXmlElement* PreviousSiblingElement(const char *) const;
717  TiXmlElement* PreviousSiblingElement(const char *_next) {
718  return const_cast<TiXmlElement*>((const_cast<const TiXmlNode*>(this))->PreviousSiblingElement(_next));
719  }
720 
721 #ifdef TIXML_USE_STL
722  const TiXmlElement* NextSiblingElement(const std::string& _value) const {
723  return NextSiblingElement(_value.c_str());
724  }
725  TiXmlElement* NextSiblingElement(const std::string& _value) {
726  return NextSiblingElement(_value.c_str());
727  }
728 #endif
729 
731  const TiXmlElement* FirstChildElement() const;
733  return const_cast<TiXmlElement*>((const_cast<const TiXmlNode*>(this))->FirstChildElement());
734  }
735 
737  const TiXmlElement* FirstChildElement(const char * _value) const;
738  TiXmlElement* FirstChildElement(const char * _value) {
739  return const_cast<TiXmlElement*>((const_cast<const TiXmlNode*>(this))->FirstChildElement(_value));
740  }
741 
742 #ifdef TIXML_USE_STL
743  const TiXmlElement* FirstChildElement(const std::string& _value) const {
744  return FirstChildElement(_value.c_str());
745  }
746  TiXmlElement* FirstChildElement(const std::string& _value) {
747  return FirstChildElement(_value.c_str());
748  }
749 #endif
750 
755  int Type() const {
756  return type;
757  }
758 
762  const TiXmlDocument* GetDocument() const;
764  return const_cast<TiXmlDocument*>((const_cast<const TiXmlNode*>(this))->GetDocument());
765  }
766 
768  bool NoChildren() const {
769  return !firstChild;
770  }
771 
772  virtual const TiXmlDocument* ToDocument() const {
773  return 0;
774  }
775  virtual const TiXmlElement* ToElement() const {
776  return 0;
777  }
778  virtual const TiXmlComment* ToComment() const {
779  return 0;
780  }
781  virtual const TiXmlUnknown* ToUnknown() const {
782  return 0;
783  }
784  virtual const TiXmlText* ToText() const {
785  return 0;
786  }
787  virtual const TiXmlDeclaration* ToDeclaration() const {
788  return 0;
789  }
790 
792  return 0;
793  }
794  virtual TiXmlElement* ToElement() {
795  return 0;
796  }
797  virtual TiXmlComment* ToComment() {
798  return 0;
799  }
800  virtual TiXmlUnknown* ToUnknown() {
801  return 0;
802  }
803  virtual TiXmlText* ToText() {
804  return 0;
805  }
807  return 0;
808  }
809 
813  virtual TiXmlNode* Clone() const = 0;
814 
837  virtual bool Accept(TiXmlVisitor* visitor) const = 0;
838 
839 protected:
840  TiXmlNode(NodeType _type);
841 
842  // Copy to the allocated object. Shared functionality between Clone, Copy constructor,
843  // and the assignment operator.
844  void CopyTo(TiXmlNode* target) const;
845 
846 #ifdef TIXML_USE_STL
847  // The real work of the input operator.
848  virtual void StreamIn(std::istream* in, TIXML_STRING* tag) = 0;
849 #endif
850 
851  // Figure out what is at *p, and parse it. Returns null if it is not an xml node.
852  TiXmlNode* Identify(const char* start, TiXmlEncoding encoding);
853 
856 
859 
861 
864 
865 private:
866  TiXmlNode(const TiXmlNode&); // not implemented.
867  void operator=(const TiXmlNode& base); // not allowed.
868 };
869 
877 class TiXmlAttribute: public TiXmlBase {
878  friend class TiXmlAttributeSet;
879 
880 public:
883  : TiXmlBase() {
884  document = 0;
885  prev = next = 0;
886  }
887 
888 #ifdef TIXML_USE_STL
889  TiXmlAttribute(const std::string& _name, const std::string& _value) {
891  name = _name;
892  value = _value;
893  document = 0;
894  prev = next = 0;
895  }
896 #endif
897 
899  TiXmlAttribute(const char * _name, const char * _value) {
900  name = _name;
901  value = _value;
902  document = 0;
903  prev = next = 0;
904  }
905 
906  const char* Name() const {
907  return name.c_str();
908  }
909  const char* Value() const {
910  return value.c_str();
911  }
912 #ifdef TIXML_USE_STL
913  const std::string& ValueStr() const {
914  return value;
915  }
916 #endif
917  int IntValue() const;
918  double DoubleValue() const;
919 
920  // Get the tinyxml string representation
921  const TIXML_STRING& NameTStr() const {
922  return name;
923  }
924 
934  int QueryIntValue(int* _value) const;
936  int QueryDoubleValue(double* _value) const;
937 
938  void SetName(const char* _name) {
939  name = _name;
940  }
941  void SetValue(const char* _value) {
942  value = _value;
943  }
944 
945  void SetIntValue(int _value);
946  void SetDoubleValue(double _value);
947 
948 #ifdef TIXML_USE_STL
949  void SetName(const std::string& _name) {
951  name = _name;
952  }
954  void SetValue(const std::string& _value) {
955  value = _value;
956  }
957 #endif
958 
960  const TiXmlAttribute* Next() const;
962  return const_cast<TiXmlAttribute*>((const_cast<const TiXmlAttribute*>(this))->Next());
963  }
964 
966  const TiXmlAttribute* Previous() const;
968  return const_cast<TiXmlAttribute*>((const_cast<const TiXmlAttribute*>(this))->Previous());
969  }
970 
971  bool operator==(const TiXmlAttribute& rhs) const {
972  return rhs.name == name;
973  }
974  bool operator<(const TiXmlAttribute& rhs) const {
975  return name < rhs.name;
976  }
977  bool operator>(const TiXmlAttribute& rhs) const {
978  return name > rhs.name;
979  }
980 
981  /* Attribute parsing starts: first letter of the name
982  returns: the next char after the value end quote
983  */
984  virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding);
985 
986  // Prints this Attribute to a FILE stream.
987  virtual void Print(FILE* cfile, int depth) const {
988  Print(cfile, depth, 0);
989  }
990  void Print(FILE* cfile, int depth, TIXML_STRING* str) const;
991 
992  // [internal use]
993  // Set the document pointer so the attribute can report errors.
995  document = doc;
996  }
997 
998 private:
999  TiXmlAttribute(const TiXmlAttribute&); // not implemented.
1000  void operator=(const TiXmlAttribute& base); // not allowed.
1001 
1002  TiXmlDocument* document; // A pointer back to a document, for error reporting.
1006 };
1007 
1008 /* A class used to manage a group of attributes.
1009  It is only used internally, both by the ELEMENT and the DECLARATION.
1010 
1011  The set can be changed transparent to the Element and Declaration
1012  classes that use it, but NOT transparent to the Attribute
1013  which has to implement a next() and previous() method. Which makes
1014  it a bit problematic and prevents the use of STL.
1015 
1016  This version is implemented with circular lists because:
1017  - I like circular lists
1018  - it demonstrates some independence from the (typical) doubly linked list.
1019 */
1021 public:
1024 
1025  void Add(TiXmlAttribute* attribute);
1026  void Remove(TiXmlAttribute* attribute);
1027 
1028  const TiXmlAttribute* First() const {
1029  return (sentinel.next == &sentinel) ? 0 : sentinel.next;
1030  }
1032  return (sentinel.next == &sentinel) ? 0 : sentinel.next;
1033  }
1034  const TiXmlAttribute* Last() const {
1035  return (sentinel.prev == &sentinel) ? 0 : sentinel.prev;
1036  }
1038  return (sentinel.prev == &sentinel) ? 0 : sentinel.prev;
1039  }
1040 
1041  const TiXmlAttribute* Find(const char* _name) const;
1042  TiXmlAttribute* Find(const char* _name) {
1043  return const_cast<TiXmlAttribute*>((const_cast<const TiXmlAttributeSet*>(this))->Find(_name));
1044  }
1045 #ifdef TIXML_USE_STL
1046  const TiXmlAttribute* Find(const std::string& _name) const;
1047  TiXmlAttribute* Find(const std::string& _name) {
1048  return const_cast<TiXmlAttribute*>((const_cast<const TiXmlAttributeSet*>(this))->Find(_name));
1049  }
1050 
1051 #endif
1052 
1053 private:
1054  //*ME: Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
1055  //*ME: this class must be also use a hidden/disabled copy-constructor !!!
1056  TiXmlAttributeSet(const TiXmlAttributeSet&); // not allowed
1057  void operator=(const TiXmlAttributeSet&); // not allowed (as TiXmlAttribute)
1058 
1060 };
1061 
1066 class TiXmlElement: public TiXmlNode {
1067 public:
1069  TiXmlElement(const char * in_value);
1070 
1071 #ifdef TIXML_USE_STL
1072  TiXmlElement(const std::string& _value);
1074 #endif
1075 
1076  TiXmlElement(const TiXmlElement&);
1077 
1078  void operator=(const TiXmlElement& base);
1079 
1080  virtual ~TiXmlElement();
1081 
1085  const TiXmlAttribute* AttributeNode(const char* name) const {
1086  return attributeSet.Find(name);
1087  }
1088 
1092  const char* Attribute(const char* name) const;
1093 
1096  void ClearAttributes();
1097 
1104  const char* Attribute(const char* name, int* i) const;
1105 
1112  const char* Attribute(const char* name, double* d) const;
1113 
1121  int QueryIntAttribute(const char* name, int* _value) const;
1123  int QueryDoubleAttribute(const char* name, double* _value) const;
1125  int QueryFloatAttribute(const char* name, float* _value) const {
1126  double d;
1127  int result = QueryDoubleAttribute(name, &d);
1128  if (result == TIXML_SUCCESS) {
1129  *_value = (float) d;
1130  }
1131  return result;
1132  }
1133 #ifdef TIXML_USE_STL
1134 
1140  template <typename T> int QueryValueAttribute(const std::string& name, T* outValue) const {
1141  const TiXmlAttribute* node = attributeSet.Find(name);
1142  if (!node)
1143  return TIXML_NO_ATTRIBUTE;
1144 
1145  std::stringstream sstream(node->ValueStr());
1146  sstream >> *outValue;
1147  if (!sstream.fail())
1148  return TIXML_SUCCESS;
1149  return TIXML_WRONG_TYPE;
1150  }
1151 #endif
1152 
1156  void SetAttribute(const char* name, const char * _value);
1157 
1158 #ifdef TIXML_USE_STL
1159  const std::string* Attribute(const std::string& name) const;
1160  const std::string* Attribute(const std::string& name, int* i) const;
1161  const std::string* Attribute(const std::string& name, double* d) const;
1162  int QueryIntAttribute(const std::string& name, int* _value) const;
1163  int QueryDoubleAttribute(const std::string& name, double* _value) const;
1164 
1166  void SetAttribute(const std::string& name, const std::string& _value);
1168  void SetAttribute(const std::string& name, int _value);
1169 #endif
1170 
1174  void SetAttribute(const char * name, int value);
1175 
1179  void SetDoubleAttribute(const char * name, double value);
1180 
1183  void RemoveAttribute(const char * name);
1184 #ifdef TIXML_USE_STL
1185  void RemoveAttribute(const std::string& name) {
1186  RemoveAttribute(name.c_str());
1187  }
1188 #endif
1189 
1191  return attributeSet.First();
1192  }
1194  return attributeSet.First();
1195  }
1197  return attributeSet.Last();
1198  }
1200  return attributeSet.Last();
1201  }
1202 
1235  const char* GetText() const;
1236 
1238  virtual TiXmlNode* Clone() const;
1239  // Print the Element to a FILE stream.
1240  virtual void Print(FILE* cfile, int depth) const;
1241 
1242  /* Attribtue parsing starts: next char past '<'
1243  returns: next char past '>'
1244  */
1245  virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding);
1246 
1247  virtual const TiXmlElement* ToElement() const {
1248  return this;
1249  }
1251  return this;
1252  }
1253 
1256  virtual bool Accept(TiXmlVisitor* visitor) const;
1257 
1258 protected:
1259 
1260  void CopyTo(TiXmlElement* target) const;
1261  void ClearThis(); // like clear, but initializes 'this' object as well
1262 
1263  // Used to be public [internal use]
1264 #ifdef TIXML_USE_STL
1265  virtual void StreamIn(std::istream * in, TIXML_STRING * tag);
1266 #endif
1267  /* [internal use]
1268  Reads the "value" of the element -- another element, or text.
1269  This should terminate with the current end tag.
1270  */
1271  const char* ReadValue(const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding);
1272 
1273 private:
1274 
1276 };
1277 
1280 class TiXmlComment: public TiXmlNode {
1281 public:
1285  }
1287  TiXmlComment(const char* _value)
1289  SetValue(_value);
1290  }
1291  TiXmlComment(const TiXmlComment&);
1292  void operator=(const TiXmlComment& base);
1293 
1294  virtual ~TiXmlComment() {
1295  }
1296 
1298  virtual TiXmlNode* Clone() const;
1299  // Write this Comment to a FILE stream.
1300  virtual void Print(FILE* cfile, int depth) const;
1301 
1302  /* Attribtue parsing starts: at the ! of the !--
1303  returns: next char past '>'
1304  */
1305  virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding);
1306 
1307  virtual const TiXmlComment* ToComment() const {
1308  return this;
1309  }
1311  return this;
1312  }
1313 
1316  virtual bool Accept(TiXmlVisitor* visitor) const;
1317 
1318 protected:
1319  void CopyTo(TiXmlComment* target) const;
1320 
1321  // used to be public
1322 #ifdef TIXML_USE_STL
1323  virtual void StreamIn(std::istream * in, TIXML_STRING * tag);
1324 #endif
1325  // virtual void StreamOut( TIXML_OSTREAM * out ) const;
1326 
1327 private:
1328 
1329 };
1330 
1336 class TiXmlText: public TiXmlNode {
1337  friend class TiXmlElement;
1338 public:
1343  TiXmlText(const char * initValue)
1344  : TiXmlNode(TiXmlNode::TEXT) {
1345  SetValue(initValue);
1346  cdata = false;
1347  }
1348  virtual ~TiXmlText() {
1349  }
1350 
1351 #ifdef TIXML_USE_STL
1352  TiXmlText(const std::string& initValue)
1354  : TiXmlNode(TiXmlNode::TEXT) {
1355  SetValue(initValue);
1356  cdata = false;
1357  }
1358 #endif
1359 
1361  : TiXmlNode(TiXmlNode::TEXT) {
1362  copy.CopyTo(this);
1363  }
1364  void operator=(const TiXmlText& base) {
1365  base.CopyTo(this);
1366  }
1367 
1368  // Write this text object to a FILE stream.
1369  virtual void Print(FILE* cfile, int depth) const;
1370 
1372  bool CDATA() const {
1373  return cdata;
1374  }
1376  void SetCDATA(bool _cdata) {
1377  cdata = _cdata;
1378  }
1379 
1380  virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding);
1381 
1382  virtual const TiXmlText* ToText() const {
1383  return this;
1384  }
1385  virtual TiXmlText* ToText() {
1386  return this;
1387  }
1388 
1391  virtual bool Accept(TiXmlVisitor* content) const;
1392 
1393 protected:
1395  virtual TiXmlNode* Clone() const;
1396  void CopyTo(TiXmlText* target) const;
1397 
1398  bool Blank() const; // returns true if all white space and new lines
1399  // [internal use]
1400 #ifdef TIXML_USE_STL
1401  virtual void StreamIn(std::istream * in, TIXML_STRING * tag);
1402 #endif
1403 
1404 private:
1405  bool cdata; // true if this should be input and output as a CDATA style text element
1406 };
1407 
1422 public:
1426  }
1427 
1428 #ifdef TIXML_USE_STL
1429  TiXmlDeclaration(const std::string& _version, const std::string& _encoding, const std::string& _standalone);
1431 #endif
1432 
1434  TiXmlDeclaration(const char* _version, const char* _encoding, const char* _standalone);
1435 
1437  void operator=(const TiXmlDeclaration& copy);
1438 
1439  virtual ~TiXmlDeclaration() {
1440  }
1441 
1443  const char *Version() const {
1444  return version.c_str();
1445  }
1447  const char *Encoding() const {
1448  return encoding.c_str();
1449  }
1451  const char *Standalone() const {
1452  return standalone.c_str();
1453  }
1454 
1456  virtual TiXmlNode* Clone() const;
1457  // Print this declaration to a FILE stream.
1458  virtual void Print(FILE* cfile, int depth, TIXML_STRING* str) const;
1459  virtual void Print(FILE* cfile, int depth) const {
1460  Print(cfile, depth, 0);
1461  }
1462 
1463  virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding);
1464 
1465  virtual const TiXmlDeclaration* ToDeclaration() const {
1466  return this;
1467  }
1469  return this;
1470  }
1471 
1474  virtual bool Accept(TiXmlVisitor* visitor) const;
1475 
1476 protected:
1477  void CopyTo(TiXmlDeclaration* target) const;
1478  // used to be public
1479 #ifdef TIXML_USE_STL
1480  virtual void StreamIn(std::istream * in, TIXML_STRING * tag);
1481 #endif
1482 
1483 private:
1484 
1486 };
1487 
1495 class TiXmlUnknown: public TiXmlNode {
1496 public:
1499  }
1500  virtual ~TiXmlUnknown() {
1501  }
1502 
1505  copy.CopyTo(this);
1506  }
1507  void operator=(const TiXmlUnknown& copy) {
1508  copy.CopyTo(this);
1509  }
1510 
1512  virtual TiXmlNode* Clone() const;
1513  // Print this Unknown to a FILE stream.
1514  virtual void Print(FILE* cfile, int depth) const;
1515 
1516  virtual const char* Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding);
1517 
1518  virtual const TiXmlUnknown* ToUnknown() const {
1519  return this;
1520  }
1522  return this;
1523  }
1524 
1527  virtual bool Accept(TiXmlVisitor* content) const;
1528 
1529 protected:
1530  void CopyTo(TiXmlUnknown* target) const;
1531 
1532 #ifdef TIXML_USE_STL
1533  virtual void StreamIn(std::istream * in, TIXML_STRING * tag);
1534 #endif
1535 
1536 private:
1537 
1538 };
1539 
1544 class TiXmlDocument: public TiXmlNode {
1545 public:
1547  TiXmlDocument();
1549  TiXmlDocument(const char * documentName);
1550 
1551 #ifdef TIXML_USE_STL
1552  TiXmlDocument(const std::string& documentName);
1554 #endif
1555 
1557  void operator=(const TiXmlDocument& copy);
1558 
1559  virtual ~TiXmlDocument() {
1560  }
1561 
1568  bool SaveFile() const;
1570  bool LoadFile(const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING);
1572  bool SaveFile(const char * filename) const;
1578  bool LoadFile(FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING);
1580  bool SaveFile(FILE*) const;
1581 
1582 #ifdef TIXML_USE_STL
1583  bool LoadFile(const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING)
1584  {
1585  // StringToBuffer f( filename );
1586  // return ( f.buffer && LoadFile( f.buffer, encoding ));
1587  return LoadFile(filename.c_str(), encoding);
1588  }
1589  bool SaveFile(const std::string& filename) const
1590  {
1591  // StringToBuffer f( filename );
1592  // return ( f.buffer && SaveFile( f.buffer ));
1593  return SaveFile(filename.c_str());
1594  }
1595 #endif
1596 
1601  virtual const char* Parse(const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING);
1602 
1607  const TiXmlElement* RootElement() const {
1608  return FirstChildElement();
1609  }
1611  return FirstChildElement();
1612  }
1613 
1619  bool Error() const {
1620  return error;
1621  }
1622 
1624  const char * ErrorDesc() const {
1625  return errorDesc.c_str();
1626  }
1627 
1631  int ErrorId() const {
1632  return errorId;
1633  }
1634 
1642  int ErrorRow() const {
1643  return errorLocation.row + 1;
1644  }
1645  int ErrorCol() const {
1646  return errorLocation.col + 1;
1647  }
1648 
1673  void SetTabSize(int _tabsize) {
1674  tabsize = _tabsize;
1675  }
1676 
1677  int TabSize() const {
1678  return tabsize;
1679  }
1680 
1684  void ClearError() {
1685  error = false;
1686  errorId = 0;
1687  errorDesc = "";
1689  //errorLocation.last = 0;
1690  }
1691 
1693  void Print() const {
1694  Print(stdout, 0);
1695  }
1696 
1697  /* Write the document to a string using formatted printing ("pretty print"). This
1698  will allocate a character array (new char[]) and return it as a pointer. The
1699  calling code pust call delete[] on the return char* to avoid a memory leak.
1700  */
1701  //char* PrintToMemory() const;
1703  virtual void Print(FILE* cfile, int depth = 0) const;
1704  // [internal use]
1705  void SetError(int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding);
1706 
1707  virtual const TiXmlDocument* ToDocument() const {
1708  return this;
1709  }
1711  return this;
1712  }
1713 
1716  virtual bool Accept(TiXmlVisitor* content) const;
1717 
1718 protected:
1719  // [internal use]
1720  virtual TiXmlNode* Clone() const;
1721 #ifdef TIXML_USE_STL
1722  virtual void StreamIn(std::istream * in, TIXML_STRING * tag);
1723 #endif
1724 
1725 private:
1726  void CopyTo(TiXmlDocument* target) const;
1727 
1728  bool error;
1730  int tabsize;
1732  bool useMicrosoftBOM; // the UTF-8 BOM were found when read. Note this, and try to write.
1733 };
1734 
1816 public:
1819  this->node = _node;
1820  }
1822  TiXmlHandle(const TiXmlHandle& ref) {
1823  this->node = ref.node;
1824  }
1826  this->node = ref.node;
1827  return *this;
1828  }
1829 
1831  TiXmlHandle FirstChild() const;
1833  TiXmlHandle FirstChild(const char * value) const;
1837  TiXmlHandle FirstChildElement(const char * value) const;
1838 
1842  TiXmlHandle Child(const char* value, int index) const;
1846  TiXmlHandle Child(int index) const;
1851  TiXmlHandle ChildElement(const char* value, int index) const;
1856  TiXmlHandle ChildElement(int index) const;
1857 
1858 #ifdef TIXML_USE_STL
1859  TiXmlHandle FirstChild(const std::string& _value) const {
1860  return FirstChild(_value.c_str());
1861  }
1862  TiXmlHandle FirstChildElement(const std::string& _value) const {
1863  return FirstChildElement(_value.c_str());
1864  }
1865 
1866  TiXmlHandle Child(const std::string& _value, int index) const {
1867  return Child(_value.c_str(), index);
1868  }
1869  TiXmlHandle ChildElement(const std::string& _value, int index) const {
1870  return ChildElement(_value.c_str(), index);
1871  }
1872 #endif
1873 
1876  TiXmlNode* ToNode() const {
1877  return node;
1878  }
1882  return ((node && node->ToElement()) ? node->ToElement() : 0);
1883  }
1886  TiXmlText* ToText() const {
1887  return ((node && node->ToText()) ? node->ToText() : 0);
1888  }
1892  return ((node && node->ToUnknown()) ? node->ToUnknown() : 0);
1893  }
1894 
1898  TiXmlNode* Node() const {
1899  return ToNode();
1900  }
1905  return ToElement();
1906  }
1910  TiXmlText* Text() const {
1911  return ToText();
1912  }
1917  return ToUnknown();
1918  }
1919 
1920 private:
1922 };
1923 
1944 public:
1946  : depth(0), simpleTextPrint(false), buffer(), indent(" "), lineBreak("\n") {
1947  }
1948 
1949  virtual bool VisitEnter(const TiXmlDocument& doc);
1950  virtual bool VisitExit(const TiXmlDocument& doc);
1951 
1952  virtual bool VisitEnter(const TiXmlElement& element, const TiXmlAttribute* firstAttribute);
1953  virtual bool VisitExit(const TiXmlElement& element);
1954 
1955  virtual bool Visit(const TiXmlDeclaration& declaration);
1956  virtual bool Visit(const TiXmlText& text);
1957  virtual bool Visit(const TiXmlComment& comment);
1958  virtual bool Visit(const TiXmlUnknown& unknown);
1959 
1963  void SetIndent(const char* _indent) {
1964  indent = _indent ? _indent : "";
1965  }
1967  const char* Indent() {
1968  return indent.c_str();
1969  }
1974  void SetLineBreak(const char* _lineBreak) {
1975  lineBreak = _lineBreak ? _lineBreak : "";
1976  }
1978  const char* LineBreak() {
1979  return lineBreak.c_str();
1980  }
1981 
1986  indent = "";
1987  lineBreak = "";
1988  }
1990  const char* CStr() {
1991  return buffer.c_str();
1992  }
1994  size_t Size() {
1995  return buffer.size();
1996  }
1997 
1998 #ifdef TIXML_USE_STL
1999  const std::string& Str() {
2001  return buffer;
2002  }
2003 #endif
2004 
2005 private:
2006  void DoIndent() {
2007  for (int i = 0; i < depth; ++i)
2008  buffer += indent;
2009  }
2010  void DoLineBreak() {
2011  buffer += lineBreak;
2012  }
2013 
2014  int depth;
2016 };
2017 
2018 #ifdef _MSC_VER
2019 #pragma warning( pop )
2020 #endif
2021 
2022 #endif
2023 
void ClearError()
Definition: tinyxml.h:1684
TiXmlAttribute * LastAttribute()
Definition: tinyxml.h:1199
virtual TiXmlUnknown * ToUnknown()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1521
virtual TiXmlNode * Clone() const
Returns a copy of this Comment.
Definition: tinyxml_inl.h:1345
TIXML_STRING encoding
Definition: tinyxml.h:1485
TiXmlAttribute * Next()
Definition: tinyxml.h:961
TiXmlElement * NextSiblingElement(const std::string &_value)
STL std::string form.
Definition: tinyxml.h:725
const std::string & ValueStr() const
Definition: tinyxml.h:496
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1544
TiXmlBase()
Definition: tinyxml.h:213
const TiXmlNode * LastChild(const std::string &_value) const
STL std::string form.
Definition: tinyxml.h:564
TiXmlNode * Parent()
One step up the DOM.
Definition: tinyxml.h:525
TiXmlCursor()
Definition: tinyxml.h:103
TiXmlHandle FirstChildElement() const
Return a handle to the first child element.
Definition: tinyxml_inl.h:1680
void SetDoubleAttribute(const char *name, double value)
Definition: tinyxml_inl.h:731
static bool StreamTo(std::istream *in, int character, TIXML_STRING *tag)
const char * str
Definition: tinyxml.h:413
void SetTabSize(int _tabsize)
Definition: tinyxml.h:1673
int QueryValueAttribute(const std::string &name, T *outValue) const
Definition: tinyxml.h:1140
int ErrorId() const
Definition: tinyxml.h:1631
virtual TiXmlNode * Clone() const
Creates a copy of this Declaration and returns it.
Definition: tinyxml_inl.h:1480
TiXmlHandle FirstChildElement(const std::string &_value) const
Definition: tinyxml.h:1862
void operator=(const TiXmlText &base)
Definition: tinyxml.h:1364
TiXmlNode * LinkEndChild(TiXmlNode *addThis)
Definition: tinyxml_inl.h:171
static const char * ReadName(const char *p, TIXML_STRING *name, TiXmlEncoding encoding)
TiXmlComment(const char *_value)
Construct a comment from text.
Definition: tinyxml.h:1287
static void PutString(const TIXML_STRING &str, TIXML_STRING *out)
Definition: tinyxml_inl.h:42
virtual const char * Parse(const char *p, TiXmlParsingData *data, TiXmlEncoding encoding)
TiXmlHandle operator=(const TiXmlHandle &ref)
Definition: tinyxml.h:1825
const TIXML_STRING & NameTStr() const
Definition: tinyxml.h:921
TiXmlNode * IterateChildren(const std::string &_value, const TiXmlNode *previous)
STL std::string form.
Definition: tinyxml.h:603
static const char * GetChar(const char *p, char *_value, int *length, TiXmlEncoding encoding)
Definition: tinyxml.h:346
void SetCDATA(bool _cdata)
Turns on or off a CDATA representation of text.
Definition: tinyxml.h:1376
virtual const TiXmlComment * ToComment() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1307
TIXML_STRING value
Definition: tinyxml.h:1003
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:1443
const std::string & ValueStr() const
Return the value of this attribute.
Definition: tinyxml.h:913
void CopyTo(TiXmlElement *target) const
Definition: tinyxml_inl.h:850
void operator=(const TiXmlComment &base)
Definition: tinyxml_inl.h:1315
int Type() const
Definition: tinyxml.h:755
virtual ~TiXmlDeclaration()
Definition: tinyxml.h:1439
virtual const char * Parse(const char *p, TiXmlParsingData *data, TiXmlEncoding encoding)
TiXmlNode * NextSibling(const std::string &_value)
STL std::string form.
Definition: tinyxml.h:666
int QueryDoubleAttribute(const char *name, double *_value) const
QueryDoubleAttribute examines the attribute - see QueryIntAttribute().
Definition: tinyxml_inl.h:689
const TiXmlNode * LastChild() const
Definition: tinyxml.h:545
void operator=(const TiXmlAttribute &base)
bool Error() const
Definition: tinyxml.h:1619
int Column() const
See Row()
Definition: tinyxml.h:266
virtual TiXmlNode * Clone() const =0
const TiXmlAttribute * First() const
Definition: tinyxml.h:1028
const char * Standalone() const
Is this a standalone document?
Definition: tinyxml.h:1451
TiXmlNode * firstChild
Definition: tinyxml.h:857
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1495
TiXmlNode * Node() const
Definition: tinyxml.h:1898
virtual void StreamIn(std::istream *in, TIXML_STRING *tag)
const TiXmlNode * NextSibling(const std::string &_value) const
STL std::string form.
Definition: tinyxml.h:663
void operator=(const TiXmlBase &base)
void operator=(const TiXmlNode &base)
static void SetCondenseWhiteSpace(bool condense)
Definition: tinyxml.h:236
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1815
bool SaveFile() const
Save a file using the current document value. Returns true if successful.
Definition: tinyxml_inl.h:959
static bool IsWhiteSpace(char c)
Definition: tinyxml.h:311
void SetDoubleValue(double _value)
Set the value from a double.
Definition: tinyxml_inl.h:1287
size_t Size()
Return the length of the result string.
Definition: tinyxml.h:1994
void RemoveAttribute(const char *name)
Definition: tinyxml_inl.h:403
TiXmlNode * node
Definition: tinyxml.h:1921
bool RemoveChild(TiXmlNode *removeThis)
Delete a child of this node.
Definition: tinyxml_inl.h:305
const TiXmlElement * FirstChildElement(const std::string &_value) const
STL std::string form.
Definition: tinyxml.h:743
TiXmlHandle(TiXmlNode *_node)
Create a handle from any node (at any depth of the tree.) This can be a null pointer.
Definition: tinyxml.h:1818
virtual bool Accept(TiXmlVisitor *visitor) const
Definition: tinyxml_inl.h:872
static void ConvertUTF32ToUTF8(unsigned long input, char *output, int *length)
virtual bool VisitEnter(const TiXmlElement &, const TiXmlAttribute *)
Visit an element.
Definition: tinyxml.h:147
const std::string & Str()
Return the result.
Definition: tinyxml.h:2000
TIXML_STRING value
Definition: tinyxml.h:860
TiXmlElement * FirstChildElement(const char *_value)
Definition: tinyxml.h:738
TiXmlHandle Child(const std::string &_value, int index) const
Definition: tinyxml.h:1866
virtual const TiXmlText * ToText() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1382
void SetIntValue(int _value)
Set the value from an integer.
Definition: tinyxml_inl.h:1276
void CopyTo(TiXmlDeclaration *target) const
Definition: tinyxml_inl.h:1464
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:1910
const int TIXML_PATCH_VERSION
Definition: tinyxml.h:97
void ClearThis()
Definition: tinyxml_inl.h:559
void operator=(const TiXmlDeclaration &copy)
Definition: tinyxml_inl.h:1435
TiXmlDocument()
Create an empty document, that has no name.
Definition: tinyxml_inl.h:910
void SetIndent(const char *_indent)
Definition: tinyxml.h:1963
virtual TiXmlText * ToText()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1385
TIXML_STRING version
Definition: tinyxml.h:1485
virtual TiXmlUnknown * ToUnknown()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:800
virtual TiXmlNode * Clone() const
Creates a copy of this Unknown and returns it.
Definition: tinyxml_inl.h:1512
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:102
static int IsAlphaNum(unsigned char anyByte, TiXmlEncoding encoding)
void copy(Alignment from, Alignment to)
Copy alignment object from source object.
const char * ReadValue(const char *in, TiXmlParsingData *prevData, TiXmlEncoding encoding)
const char * Value() const
Definition: tinyxml.h:487
const void * GetUserData() const
Get a pointer to arbitrary user data.
Definition: tinyxml.h:276
virtual ~TiXmlBase()
Definition: tinyxml.h:216
TiXmlElement * Element() const
Definition: tinyxml.h:1904
TiXmlDocument * GetDocument()
Definition: tinyxml.h:763
const TiXmlElement * NextSiblingElement(const std::string &_value) const
STL std::string form.
Definition: tinyxml.h:722
void Clear()
Definition: tinyxml.h:106
bool LoadFile(const std::string &filename, TiXmlEncoding encoding=TIXML_DEFAULT_ENCODING)
Definition: tinyxml.h:1583
TiXmlElement * ToElement() const
Definition: tinyxml.h:1881
void RemoveAttribute(const std::string &name)
STL std::string form.
Definition: tinyxml.h:1185
int IntValue() const
Return the value of this attribute, converted to an integer.
Definition: tinyxml_inl.h:1298
static bool IsWhiteSpace(int c)
Definition: tinyxml.h:314
TIXML_STRING errorDesc
Definition: tinyxml.h:1729
int QueryIntAttribute(const char *name, int *_value) const
Definition: tinyxml_inl.h:669
const char * Name() const
Return the name of this attribute.
Definition: tinyxml.h:906
const TiXmlAttribute * Previous() const
Get the previous sibling attribute in the DOM. Returns null at beginning.
Definition: tinyxml_inl.h:1216
virtual void Print(FILE *cfile, int depth) const
Definition: tinyxml.h:1459
TiXmlElement * PreviousSiblingElement(const char *_next)
Definition: tinyxml.h:717
virtual TiXmlDocument * ToDocument()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:791
virtual TiXmlNode * Clone() const
Creates a new Element and returns it - the returned element is a copy.
Definition: tinyxml_inl.h:886
void CopyTo(TiXmlText *target) const
Definition: tinyxml_inl.h:1378
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:431
TiXmlAttribute * First()
Definition: tinyxml.h:1031
TiXmlNode * PreviousSibling(const std::string &_value)
STL std::string form.
Definition: tinyxml.h:660
const TiXmlAttribute * LastAttribute() const
Access the last attribute in this element.
Definition: tinyxml.h:1196
const TiXmlNode * Parent() const
Definition: tinyxml.h:528
static const char * GetEntity(const char *in, char *value, int *length, TiXmlEncoding encoding)
TIXML_STRING lineBreak
Definition: tinyxml.h:2015
bool operator>(const TiXmlAttribute &rhs) const
Definition: tinyxml.h:977
TiXmlComment()
Constructs an empty comment.
Definition: tinyxml.h:1283
virtual const TiXmlDocument * ToDocument() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1707
TIXML_STRING standalone
Definition: tinyxml.h:1485
int QueryFloatAttribute(const char *name, float *_value) const
QueryFloatAttribute examines the attribute - see QueryIntAttribute().
Definition: tinyxml.h:1125
void Add(TiXmlAttribute *attribute)
Definition: tinyxml_inl.h:1538
void SetStreamPrinting()
Definition: tinyxml.h:1985
virtual void Print(FILE *cfile, int depth) const
Definition: tinyxml_inl.h:1322
TiXmlAttribute * Find(const char *_name)
Definition: tinyxml.h:1042
int ErrorCol() const
The column where the error occured. See ErrorRow()
Definition: tinyxml.h:1645
int ErrorRow() const
Definition: tinyxml.h:1642
TiXmlNode * lastChild
Definition: tinyxml.h:858
TiXmlUnknown * ToUnknown() const
Definition: tinyxml.h:1891
const TiXmlNode * PreviousSibling() const
Navigate to a sibling node.
Definition: tinyxml.h:643
bool useMicrosoftBOM
Definition: tinyxml.h:1732
virtual bool Accept(TiXmlVisitor *visitor) const
Definition: tinyxml_inl.h:1474
TiXmlNode * ReplaceChild(TiXmlNode *replaceThis, const TiXmlNode &withThis)
Definition: tinyxml_inl.h:277
TiXmlText(const char *initValue)
Definition: tinyxml.h:1343
friend std::istream & operator>>(std::istream &in, TiXmlNode &base)
int QueryIntValue(int *_value) const
Definition: tinyxml_inl.h:1262
virtual bool VisitExit(const TiXmlElement &)
Visit an element.
Definition: tinyxml.h:151
virtual bool Visit(const TiXmlComment &)
Visit a comment node.
Definition: tinyxml.h:164
TiXmlNode * LastChild(const std::string &_value)
STL std::string form.
Definition: tinyxml.h:567
TiXmlAttributeSet attributeSet
Definition: tinyxml.h:1275
TiXmlNode * prev
Definition: tinyxml.h:862
void SetName(const char *_name)
Set the name of this attribute.
Definition: tinyxml.h:938
const TiXmlEncoding TIXML_DEFAULT_ENCODING
Definition: tinyxml.h:183
TiXmlAttribute()
Construct an empty attribute.
Definition: tinyxml.h:882
virtual ~TiXmlText()
Definition: tinyxml.h:1348
TiXmlAttribute * next
Definition: tinyxml.h:1005
TiXmlElement * PreviousSiblingElement()
Definition: tinyxml.h:708
TiXmlText(const TiXmlText &copy)
Definition: tinyxml.h:1360
TiXmlDocument * document
Definition: tinyxml.h:1002
virtual const char * Parse(const char *p, TiXmlParsingData *data=0, TiXmlEncoding encoding=TIXML_DEFAULT_ENCODING)
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:877
void CopyTo(TiXmlComment *target) const
Definition: tinyxml_inl.h:1333
TiXmlElement * FirstChildElement(const std::string &_value)
STL std::string form.
Definition: tinyxml.h:746
virtual void StreamIn(std::istream *in, TIXML_STRING *tag)
virtual TiXmlDeclaration * ToDeclaration()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1468
TiXmlNode(NodeType _type)
Definition: tinyxml_inl.h:126
TIXML_STRING name
Definition: tinyxml.h:1003
virtual TiXmlDeclaration * ToDeclaration()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:806
const int TIXML_MAJOR_VERSION
Definition: tinyxml.h:95
bool operator==(const TiXmlAttribute &rhs) const
Definition: tinyxml.h:971
virtual bool Visit(const TiXmlText &)
Visit a text node.
Definition: tinyxml.h:160
bool operator<(const TiXmlAttribute &rhs) const
Definition: tinyxml.h:974
const TiXmlAttribute * FirstAttribute() const
Access the first attribute in this element.
Definition: tinyxml.h:1190
void Clear()
Delete all the children of this node. Does not affect 'this'.
Definition: tinyxml_inl.h:156
virtual bool Accept(TiXmlVisitor *content) const
Definition: tinyxml_inl.h:1385
void DoIndent()
Definition: tinyxml.h:2006
TiXmlAttribute * Find(const std::string &_name)
Definition: tinyxml.h:1047
void DoLineBreak()
Definition: tinyxml.h:2010
virtual void Print(FILE *cfile, int depth, TIXML_STRING *str) const
Definition: tinyxml_inl.h:1442
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:207
TiXmlElement * NextSiblingElement(const char *_next)
Definition: tinyxml.h:699
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1280
virtual void StreamIn(std::istream *in, TIXML_STRING *tag)
TiXmlNode * next
Definition: tinyxml.h:863
virtual bool VisitEnter(const TiXmlDocument &)
Visit a document.
Definition: tinyxml.h:138
TinyXML class. See http://www.grinninglizard.com/tinyxml.
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1421
const TiXmlElement * NextSiblingElement() const
Definition: tinyxml_inl.h:448
bool Blank() const
static const int utf8ByteTable[256]
Definition: tinyxml.h:282
friend std::ostream & operator<<(std::ostream &out, const TiXmlNode &base)
TiXmlNode * FirstChild()
Definition: tinyxml.h:535
virtual const char * Parse(const char *p, TiXmlParsingData *data, TiXmlEncoding encoding)
TiXmlElement(const char *in_value)
Construct an element.
Definition: tinyxml_inl.h:520
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:412
void operator=(const TiXmlAttributeSet &)
virtual bool Visit(const TiXmlUnknown &)
Visit an unknow node.
Definition: tinyxml.h:168
void operator=(const TiXmlElement &base)
Definition: tinyxml_inl.h:546
TiXmlDeclaration()
Construct an empty declaration.
Definition: tinyxml.h:1424
bool NoChildren() const
Returns true if this node has no children.
Definition: tinyxml.h:768
virtual const char * Parse(const char *p, TiXmlParsingData *data, TiXmlEncoding encoding)
TiXmlEncoding
Definition: tinyxml.h:179
virtual TiXmlNode * Clone() const
[internal use] Creates a new Element and returns it.
Definition: tinyxml_inl.h:1391
void ClearAttributes()
Definition: tinyxml_inl.h:570
static const char * ReadText(const char *in, TIXML_STRING *text, bool ignoreWhiteSpace, const char *endTag, bool ignoreCase, TiXmlEncoding encoding)
TiXmlElement * NextSiblingElement()
Definition: tinyxml.h:690
static Entity entity[NUM_ENTITY]
Definition: tinyxml.h:421
virtual const TiXmlElement * ToElement() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1247
NodeType type
Definition: tinyxml.h:855
TiXmlHandle FirstChild(const std::string &_value) const
Definition: tinyxml.h:1859
virtual const char * Parse(const char *p, TiXmlParsingData *data, TiXmlEncoding encoding)
const TiXmlNode * IterateChildren(const std::string &_value, const TiXmlNode *previous) const
STL std::string form.
Definition: tinyxml.h:600
virtual TiXmlNode * Clone() const
Definition: tinyxml_inl.h:1160
virtual bool Accept(TiXmlVisitor *visitor) const =0
TiXmlAttribute sentinel
Definition: tinyxml.h:1059
virtual void StreamIn(std::istream *in, TIXML_STRING *tag)
void * userData
Field containing a generic user pointer.
Definition: tinyxml.h:390
const char * Attribute(const char *name) const
Definition: tinyxml_inl.h:581
virtual bool Accept(TiXmlVisitor *visitor) const
Definition: tinyxml_inl.h:1339
unsigned int strLength
Definition: tinyxml.h:414
void SetValue(const char *_value)
Set the value.
Definition: tinyxml.h:941
bool cdata
Definition: tinyxml.h:1405
void SetError(int err, const char *errorLocation, TiXmlParsingData *prevData, TiXmlEncoding encoding)
virtual void Print(FILE *cfile, int depth) const
Definition: tinyxml.h:987
virtual bool Accept(TiXmlVisitor *content) const
Definition: tinyxml_inl.h:1182
virtual void StreamIn(std::istream *in, TIXML_STRING *tag)=0
TiXmlNode * InsertAfterChild(TiXmlNode *afterThis, const TiXmlNode &addThis)
Definition: tinyxml_inl.h:245
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:132
void operator=(const TiXmlDocument &copy)
Definition: tinyxml_inl.h:943
virtual const TiXmlText * ToText() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:784
static int ToLower(int v, TiXmlEncoding encoding)
Definition: tinyxml.h:396
void * GetUserData()
Get a pointer to arbitrary user data.
Definition: tinyxml.h:273
TIXML_STRING indent
Definition: tinyxml.h:2015
virtual TiXmlDocument * ToDocument()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1710
const char * CStr()
Return the result.
Definition: tinyxml.h:1990
TiXmlNode * NextSibling(const char *_next)
Definition: tinyxml.h:681
TiXmlElement * RootElement()
Definition: tinyxml.h:1610
const TiXmlNode * NextSibling() const
Navigate to a sibling node.
Definition: tinyxml.h:672
virtual bool Visit(const TiXmlDeclaration &)
Visit a declaration.
Definition: tinyxml.h:156
void CopyTo(TiXmlUnknown *target) const
Definition: tinyxml_inl.h:1500
bool simpleTextPrint
Definition: tinyxml.h:2015
virtual const TiXmlElement * ToElement() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:775
void SetAttribute(const char *name, const char *_value)
Definition: tinyxml_inl.h:743
const char * Indent()
Query the indention string.
Definition: tinyxml.h:1967
virtual const TiXmlDeclaration * ToDeclaration() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1465
void SetValue(const char *_value)
Definition: tinyxml.h:510
const TiXmlNode * IterateChildren(const TiXmlNode *previous) const
Definition: tinyxml_inl.h:351
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1336
const char * Encoding() const
Encoding. Will return an empty string if none was found.
Definition: tinyxml.h:1447
TiXmlAttribute * prev
Definition: tinyxml.h:1004
void Print() const
Definition: tinyxml.h:1693
static bool IsWhiteSpaceCondensed()
Return the current white space setting.
Definition: tinyxml.h:241
TiXmlAttribute * Last()
Definition: tinyxml.h:1037
virtual void StreamIn(std::istream *in, TIXML_STRING *tag)
virtual const TiXmlUnknown * ToUnknown() const
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1518
static bool StringEqual(const char *p, const char *endTag, bool ignoreCase, TiXmlEncoding encoding)
const char * GetText() const
Definition: tinyxml_inl.h:897
TiXmlAttribute * FirstAttribute()
Definition: tinyxml.h:1193
virtual void Print(FILE *cfile, int depth) const
Definition: tinyxml_inl.h:1492
int TabSize() const
Definition: tinyxml.h:1677
virtual void Print(FILE *cfile, int depth) const =0
TiXmlNode * InsertBeforeChild(TiXmlNode *beforeThis, const TiXmlNode &addThis)
Definition: tinyxml_inl.h:213
virtual TiXmlComment * ToComment()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:797
virtual const TiXmlDocument * ToDocument() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:772
virtual ~TiXmlVisitor()
Definition: tinyxml.h:134
virtual TiXmlComment * ToComment()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1310
void SetDocument(TiXmlDocument *doc)
Definition: tinyxml.h:994
virtual const TiXmlDeclaration * ToDeclaration() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:787
virtual bool Accept(TiXmlVisitor *content) const
Definition: tinyxml_inl.h:1506
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1020
int QueryDoubleValue(double *_value) const
QueryDoubleValue examines the value string. See QueryIntValue().
Definition: tinyxml_inl.h:1269
View * v
Definition: MultiView.cpp:30
TiXmlNode * parent
Definition: tinyxml.h:854
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1066
TiXmlElement * FirstChildElement()
Definition: tinyxml.h:732
int Row() const
Definition: tinyxml.h:263
bool LoadFile(TiXmlEncoding encoding=TIXML_DEFAULT_ENCODING)
Definition: tinyxml_inl.h:950
TiXmlHandle ChildElement(const std::string &_value, int index) const
Definition: tinyxml.h:1869
const char * ErrorDesc() const
Contains a textual (english) description of the error if one occurs.
Definition: tinyxml.h:1624
TiXmlNode * PreviousSibling(const char *_prev)
Definition: tinyxml.h:652
TiXmlNode * Identify(const char *start, TiXmlEncoding encoding)
void SetLineBreak(const char *_lineBreak)
Definition: tinyxml.h:1974
TiXmlHandle FirstChild() const
Return a handle to the first child node.
Definition: tinyxml_inl.h:1656
TiXmlNode * LastChild(const char *_value)
The last child of this node matching 'value'. Will be null if there are no children.
Definition: tinyxml.h:553
static const char * errorString[TIXML_ERROR_STRING_COUNT]
Definition: tinyxml.h:385
virtual ~TiXmlComment()
Definition: tinyxml.h:1294
virtual bool VisitExit(const TiXmlDocument &doc)
Visit a document.
Definition: tinyxml_inl.h:1785
void SetValue(const std::string &_value)
STL std::string form.
Definition: tinyxml.h:954
virtual const TiXmlComment * ToComment() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:778
TiXmlHandle Child(const char *value, int index) const
Definition: tinyxml_inl.h:1723
TiXmlUnknown(const TiXmlUnknown &copy)
Definition: tinyxml.h:1503
virtual bool VisitExit(const TiXmlDocument &)
Visit a document.
Definition: tinyxml.h:142
virtual TiXmlText * ToText()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:803
TiXmlNode * PreviousSibling()
Definition: tinyxml.h:646
static bool condenseWhiteSpace
Definition: tinyxml.h:422
void Remove(TiXmlAttribute *attribute)
Definition: tinyxml_inl.h:1553
const char * Value() const
Return the value of this attribute.
Definition: tinyxml.h:909
virtual ~TiXmlDocument()
Definition: tinyxml.h:1559
const TiXmlNode * PreviousSibling(const std::string &_value) const
STL std::string form.
Definition: tinyxml.h:657
virtual void StreamIn(std::istream *in, TIXML_STRING *tag)
TiXmlCursor errorLocation
Definition: tinyxml.h:1731
const char * LineBreak()
Query the current line breaking string.
Definition: tinyxml.h:1978
const TiXmlAttribute * Next() const
Get the next sibling attribute in the DOM. Returns null at end.
Definition: tinyxml_inl.h:1196
TiXmlNode * LastChild()
The last child of this node. Will be null if there are no children.
Definition: tinyxml.h:548
const TiXmlDocument * GetDocument() const
Definition: tinyxml_inl.h:507
const TiXmlAttribute * AttributeNode(const char *name) const
Definition: tinyxml.h:1085
virtual void Print(FILE *cfile, int depth) const
Definition: tinyxml_inl.h:1357
TinyXML class. See http://www.grinninglizard.com/tinyxml.
Definition: tinyxml.h:1943
TiXmlCursor location
Definition: tinyxml.h:387
TiXmlNode * IterateChildren(const TiXmlNode *previous)
Definition: tinyxml.h:589
TIXML_STRING buffer
Definition: tinyxml.h:2015
virtual const TiXmlUnknown * ToUnknown() const
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:781
void operator=(const TiXmlUnknown &copy)
Definition: tinyxml.h:1507
const TiXmlAttribute * Last() const
Definition: tinyxml.h:1034
const TiXmlNode * FirstChild() const
The first child of this node. Will be null if there are no children.
Definition: tinyxml.h:532
TiXmlNode * IterateChildren(const char *_value, const TiXmlNode *previous)
Definition: tinyxml.h:595
TiXmlNode * FirstChild(const std::string &_value)
STL std::string form.
Definition: tinyxml.h:561
TiXmlUnknown * Unknown() const
Definition: tinyxml.h:1916
void SetUserData(void *user)
Set a pointer to arbitrary user data.
Definition: tinyxml.h:270
const TiXmlNode * FirstChild(const std::string &_value) const
STL std::string form.
Definition: tinyxml.h:558
virtual TiXmlElement * ToElement()
Cast to a more defined type. Will return null if not of the requested type.
Definition: tinyxml.h:794
const TiXmlElement * PreviousSiblingElement() const
Definition: tinyxml_inl.h:478
TiXmlHandle(const TiXmlHandle &ref)
Copy constructor.
Definition: tinyxml.h:1822
virtual bool VisitEnter(const TiXmlDocument &doc)
Visit a document.
Definition: tinyxml_inl.h:1780
virtual void Print(FILE *cfile, int depth) const
Definition: tinyxml_inl.h:797
const TiXmlAttribute * Find(const char *_name) const
Definition: tinyxml_inl.h:1597
double DoubleValue() const
Return the value of this attribute, converted to a double.
Definition: tinyxml_inl.h:1303
virtual ~TiXmlUnknown()
Definition: tinyxml.h:1500
virtual const char * Parse(const char *p, TiXmlParsingData *data, TiXmlEncoding encoding)
bool CDATA() const
Queries whether this represents text using a CDATA section.
Definition: tinyxml.h:1372
virtual ~TiXmlElement()
Definition: tinyxml_inl.h:553
virtual ~TiXmlNode()
Definition: tinyxml_inl.h:137
void CopyTo(TiXmlDocument *target) const
Definition: tinyxml_inl.h:1145
const TiXmlElement * RootElement() const
Definition: tinyxml.h:1607
TiXmlNode * ToNode() const
Definition: tinyxml.h:1876
bool SaveFile(const std::string &filename) const
< STL std::string version.
Definition: tinyxml.h:1589
TiXmlHandle ChildElement(const char *value, int index) const
Definition: tinyxml_inl.h:1761
TiXmlNode * NextSibling()
Definition: tinyxml.h:675
#define TIXML_STRING
Definition: tinyxml.h:56
const int TIXML_MINOR_VERSION
Definition: tinyxml.h:96
virtual TiXmlElement * ToElement()
Cast to a more defined type. Will return null not of the requested type.
Definition: tinyxml.h:1250
const TiXmlElement * FirstChildElement() const
Convenience function to get through elements.
Definition: tinyxml_inl.h:418
TiXmlText * ToText() const
Definition: tinyxml.h:1886
void CopyTo(TiXmlNode *target) const
Definition: tinyxml_inl.h:149
TiXmlNode * InsertEndChild(const TiXmlNode &addThis)
Definition: tinyxml_inl.h:198
virtual bool Visit(const TiXmlDeclaration &declaration)
Visit a declaration.
Definition: tinyxml_inl.h:1877
TiXmlAttribute * Previous()
Definition: tinyxml.h:967
static bool StreamWhiteSpace(std::istream *in, TIXML_STRING *tag)
TiXmlAttribute(const char *_name, const char *_value)
Construct an attribute with a name and value.
Definition: tinyxml.h:899