blob: f571032f4955b3d52ed8c1a7f328baf6c24eae5f [file] [log] [blame]
Lee Thomason (grinliz)28129862012-02-25 21:11:20 -08001/*
2Original code by Lee Thomason (www.grinninglizard.com)
3
4This software is provided 'as-is', without any express or implied
5warranty. In no event will the authors be held liable for any
6damages arising from the use of this software.
7
8Permission is granted to anyone to use this software for any
9purpose, including commercial applications, and to alter it and
10redistribute it freely, subject to the following restrictions:
11
121. The origin of this software must not be misrepresented; you must
13not claim that you wrote the original software. If you use this
14software in a product, an acknowledgment in the product documentation
15would be appreciated but is not required.
16
172. Altered source versions must be plainly marked as such, and
18must not be misrepresented as being the original software.
19
203. This notice may not be removed or altered from any source
21distribution.
22*/
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -080023
Lee Thomason7d00b9a2012-02-27 17:54:22 -080024#ifndef TINYXML2_INCLUDED
U-Lama\Leee13c3e62011-12-28 14:36:55 -080025#define TINYXML2_INCLUDED
26
Anton Indrawanf59e2d62014-11-18 20:50:42 +010027#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070028# include <ctype.h>
29# include <limits.h>
30# include <stdio.h>
31# include <stdlib.h>
32# include <string.h>
33# include <stdarg.h>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070034#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -070035# include <cctype>
36# include <climits>
37# include <cstdio>
38# include <cstdlib>
39# include <cstring>
40# include <cstdarg>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070041#endif
Lee Thomason (grinliz)6a22be22012-04-04 12:39:05 -070042
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -070043/*
Lee Thomason7d00b9a2012-02-27 17:54:22 -080044 TODO: intern strings instead of allocation.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080045*/
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080046/*
Lee Thomasona9cf3f92012-10-11 16:56:51 -070047 gcc:
Lee Thomason5b0a6772012-11-19 13:54:42 -080048 g++ -Wall -DDEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
MortenMacFly4ee49f12013-01-14 20:03:14 +010049
Lee Thomasona9cf3f92012-10-11 16:56:51 -070050 Formatting, Artistic Style:
51 AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080052*/
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080053
U-Lama\Lee4cee6112011-12-31 14:58:18 -080054#if defined( _DEBUG ) || defined( DEBUG ) || defined (__DEBUG__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070055# ifndef DEBUG
56# define DEBUG
57# endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080058#endif
59
PKEuS95060352013-07-26 10:42:44 +020060#ifdef _MSC_VER
61# pragma warning(push)
62# pragma warning(disable: 4251)
63#endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080064
PKEuS16ed47d2013-07-06 12:02:43 +020065#ifdef _WIN32
66# ifdef TINYXML2_EXPORT
67# define TINYXML2_LIB __declspec(dllexport)
68# elif defined(TINYXML2_IMPORT)
69# define TINYXML2_LIB __declspec(dllimport)
70# else
71# define TINYXML2_LIB
72# endif
73#else
74# define TINYXML2_LIB
75#endif
76
77
U-Lama\Lee4cee6112011-12-31 14:58:18 -080078#if defined(DEBUG)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070079# if defined(_MSC_VER)
Dmitry-Me4bcbf142014-12-25 19:05:18 +030080# // "(void)0," is for suppressing C4127 warning in "assert(false)", "assert(true)" and the like
81# define TIXMLASSERT( x ) if ( !((void)0,(x))) { __debugbreak(); } //if ( !(x)) WinDebugBreak()
Lee Thomasona9cf3f92012-10-11 16:56:51 -070082# elif defined (ANDROID_NDK)
83# include <android/log.h>
84# define TIXMLASSERT( x ) if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
85# else
86# include <assert.h>
87# define TIXMLASSERT assert
88# endif
89# else
90# define TIXMLASSERT( x ) {}
U-Lama\Lee4cee6112011-12-31 14:58:18 -080091#endif
92
U-Lama\Leee13c3e62011-12-28 14:36:55 -080093
pffang91d34a02014-07-10 10:02:35 +080094#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070095// Microsoft visual studio, version 2005 and higher.
96/*int _snprintf_s(
97 char *buffer,
98 size_t sizeOfBuffer,
99 size_t count,
100 const char *format [,
101 argument] ...
102);*/
103inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
104{
105 va_list va;
106 va_start( va, format );
107 int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
108 va_end( va );
109 return result;
110}
111#define TIXML_SSCANF sscanf_s
pffang91d34a02014-07-10 10:02:35 +0800112#elif defined WINCE
113#define TIXML_SNPRINTF _snprintf
114#define TIXML_SSCANF sscanf
Lee Thomason (grinliz)b9e791f2012-04-06 21:27:10 -0700115#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700116// GCC version 3 and higher
117//#warning( "Using sn* functions." )
118#define TIXML_SNPRINTF snprintf
119#define TIXML_SSCANF sscanf
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800120#endif
Lee Thomason1ff38e02012-02-14 18:18:16 -0800121
Lee Thomasonc18eb232014-02-21 17:31:17 -0800122/* Versioning, past 1.0.14:
Lee Thomason85afe9c2014-02-23 21:42:16 -0800123 http://semver.org/
Lee Thomasonc18eb232014-02-21 17:31:17 -0800124*/
Lee Thomasonf07b9522014-10-30 13:25:12 -0700125static const int TIXML2_MAJOR_VERSION = 2;
126static const int TIXML2_MINOR_VERSION = 2;
127static const int TIXML2_PATCH_VERSION = 0;
Lee Thomason1ff38e02012-02-14 18:18:16 -0800128
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800129namespace tinyxml2
130{
Lee Thomasonce0763e2012-01-11 15:43:54 -0800131class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800132class XMLElement;
133class XMLAttribute;
134class XMLComment;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800135class XMLText;
Lee Thomason50f97b22012-02-11 16:33:40 -0800136class XMLDeclaration;
137class XMLUnknown;
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800138class XMLPrinter;
Lee Thomason5cae8972012-01-24 18:03:07 -0800139
U-Stream\Leeae25a442012-02-17 17:48:16 -0800140/*
141 A class that wraps strings. Normally stores the start and end
142 pointers into the XML file itself, and will apply normalization
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800143 and entity translation if actually read. Can also store (and memory
U-Stream\Leeae25a442012-02-17 17:48:16 -0800144 manage) a traditional char[]
145*/
PKEuS95060352013-07-26 10:42:44 +0200146class StrPair
Lee Thomason39ede242012-01-20 11:27:56 -0800147{
Lee Thomasond34f52c2012-01-20 12:55:24 -0800148public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700149 enum {
150 NEEDS_ENTITY_PROCESSING = 0x01,
151 NEEDS_NEWLINE_NORMALIZATION = 0x02,
selfpoisede77e1952013-03-13 14:08:29 +0800152 COLLAPSE_WHITESPACE = 0x04,
Lee Thomason18d68bd2012-01-26 18:17:26 -0800153
selfpoisede77e1952013-03-13 14:08:29 +0800154 TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700155 TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
selfpoisede77e1952013-03-13 14:08:29 +0800156 ATTRIBUTE_NAME = 0,
157 ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
158 ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
159 COMMENT = NEEDS_NEWLINE_NORMALIZATION
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700160 };
Lee Thomason39ede242012-01-20 11:27:56 -0800161
Lee Thomason120b3a62012-10-12 10:06:59 -0700162 StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700163 ~StrPair();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800164
Lee Thomason120b3a62012-10-12 10:06:59 -0700165 void Set( char* start, char* end, int flags ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700166 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700167 _start = start;
168 _end = end;
169 _flags = flags | NEEDS_FLUSH;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700170 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700171
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700172 const char* GetStr();
Lee Thomason120b3a62012-10-12 10:06:59 -0700173
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700174 bool Empty() const {
Lee Thomason120b3a62012-10-12 10:06:59 -0700175 return _start == _end;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700176 }
Lee Thomason39ede242012-01-20 11:27:56 -0800177
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700178 void SetInternedStr( const char* str ) {
179 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700180 _start = const_cast<char*>(str);
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700181 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700182
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700183 void SetStr( const char* str, int flags=0 );
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800184
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700185 char* ParseText( char* in, const char* endTag, int strFlags );
186 char* ParseName( char* in );
Lee Thomason56bdd022012-02-09 18:16:58 -0800187
Lee Thomason29658802014-11-27 22:31:11 -0800188 void TransferTo( StrPair* other );
Dmitry-Me08b40dd2014-11-10 11:17:21 +0300189
Lee Thomason39ede242012-01-20 11:27:56 -0800190private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700191 void Reset();
192 void CollapseWhitespace();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800193
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700194 enum {
195 NEEDS_FLUSH = 0x100,
196 NEEDS_DELETE = 0x200
197 };
Lee Thomasone4422302012-01-20 17:59:50 -0800198
selfpoised4dd59bc2013-03-13 16:54:15 +0800199 // After parsing, if *_end != 0, it can be set to zero.
Lee Thomason120b3a62012-10-12 10:06:59 -0700200 int _flags;
201 char* _start;
202 char* _end;
Dmitry-Me08b40dd2014-11-10 11:17:21 +0300203
204 StrPair( const StrPair& other ); // not supported
205 void operator=( StrPair& other ); // not supported, use TransferTo()
Lee Thomason39ede242012-01-20 11:27:56 -0800206};
207
U-Lama\Lee560bd472011-12-28 19:42:49 -0800208
U-Stream\Leeae25a442012-02-17 17:48:16 -0800209/*
210 A dynamic array of Plain Old Data. Doesn't support constructors, etc.
211 Has a small initial memory pool, so that low or no usage will not
212 cause a call to new/delete
213*/
Lee Thomason2c85a712012-01-31 08:24:24 -0800214template <class T, int INIT>
PKEuS95060352013-07-26 10:42:44 +0200215class DynArray
Lee Thomason2c85a712012-01-31 08:24:24 -0800216{
217public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700218 DynArray< T, INIT >() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700219 _mem = _pool;
220 _allocated = INIT;
221 _size = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700222 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700223
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700224 ~DynArray() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700225 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700226 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700227 }
228 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700229
Lee Thomasonce0510b2013-11-26 21:29:37 -0800230 void Clear() {
Reinhard Klambauer4e74b132013-11-22 14:01:58 +0100231 _size = 0;
232 }
233
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700234 void Push( T t ) {
Dmitry-Meed7a7dc2015-01-14 08:36:12 +0300235 TIXMLASSERT( _size < INT_MAX );
Lee Thomason624d43f2012-10-12 10:58:48 -0700236 EnsureCapacity( _size+1 );
237 _mem[_size++] = t;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700238 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800239
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700240 T* PushArr( int count ) {
Dmitry-Me74fb8702015-01-13 10:27:36 +0300241 TIXMLASSERT( count >= 0 );
Dmitry-Meed7a7dc2015-01-14 08:36:12 +0300242 TIXMLASSERT( _size <= INT_MAX - count );
Lee Thomason624d43f2012-10-12 10:58:48 -0700243 EnsureCapacity( _size+count );
244 T* ret = &_mem[_size];
245 _size += count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700246 return ret;
247 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700248
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700249 T Pop() {
Dmitry-Me74fb8702015-01-13 10:27:36 +0300250 TIXMLASSERT( _size > 0 );
Lee Thomason624d43f2012-10-12 10:58:48 -0700251 return _mem[--_size];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700252 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700253
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700254 void PopArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700255 TIXMLASSERT( _size >= count );
256 _size -= count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700257 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800258
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700259 bool Empty() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700260 return _size == 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700261 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700262
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700263 T& operator[](int i) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700264 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700265 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700266 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700267
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700268 const T& operator[](int i) const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700269 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700270 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700271 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700272
Lee Thomasonf07b9522014-10-30 13:25:12 -0700273 const T& PeekTop() const {
Dennis Jenkins59c75d32013-10-08 13:10:07 -0500274 TIXMLASSERT( _size > 0 );
275 return _mem[ _size - 1];
276 }
277
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700278 int Size() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700279 return _size;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700280 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700281
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700282 int Capacity() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700283 return _allocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700284 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700285
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700286 const T* Mem() const {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700287 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700288 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700289
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700290 T* Mem() {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700291 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700292 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800293
Lee Thomason2c85a712012-01-31 08:24:24 -0800294private:
Dmitry-Me3e0af372015-01-09 15:30:00 +0300295 DynArray( const DynArray& ); // not supported
296 void operator=( const DynArray& ); // not supported
297
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700298 void EnsureCapacity( int cap ) {
Dmitry-Me9fae8692014-12-22 17:59:59 +0300299 TIXMLASSERT( cap > 0 );
Lee Thomason624d43f2012-10-12 10:58:48 -0700300 if ( cap > _allocated ) {
Dmitry-Me9fae8692014-12-22 17:59:59 +0300301 TIXMLASSERT( cap <= INT_MAX / 2 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700302 int newAllocated = cap * 2;
303 T* newMem = new T[newAllocated];
Lee Thomason624d43f2012-10-12 10:58:48 -0700304 memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
305 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700306 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700307 }
Lee Thomasoned5c8792012-10-12 10:09:48 -0700308 _mem = newMem;
Lee Thomason624d43f2012-10-12 10:58:48 -0700309 _allocated = newAllocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700310 }
311 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800312
Lee Thomason624d43f2012-10-12 10:58:48 -0700313 T* _mem;
314 T _pool[INIT];
315 int _allocated; // objects allocated
316 int _size; // number objects in use
Lee Thomason2c85a712012-01-31 08:24:24 -0800317};
318
Lee Thomason50adb4c2012-02-13 15:07:09 -0800319
U-Stream\Leeae25a442012-02-17 17:48:16 -0800320/*
Thomas Roß08bdf502012-05-12 14:21:23 +0200321 Parent virtual class of a pool for fast allocation
U-Stream\Leeae25a442012-02-17 17:48:16 -0800322 and deallocation of objects.
323*/
PKEuS95060352013-07-26 10:42:44 +0200324class MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800325{
326public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700327 MemPool() {}
328 virtual ~MemPool() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800329
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700330 virtual int ItemSize() const = 0;
331 virtual void* Alloc() = 0;
332 virtual void Free( void* ) = 0;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800333 virtual void SetTracked() = 0;
Lee Thomasonf07b9522014-10-30 13:25:12 -0700334 virtual void Clear() = 0;
Lee Thomasond1983222012-02-06 08:41:24 -0800335};
336
Lee Thomason50adb4c2012-02-13 15:07:09 -0800337
U-Stream\Leeae25a442012-02-17 17:48:16 -0800338/*
339 Template child class to create pools of the correct type.
340*/
Lee Thomasond1983222012-02-06 08:41:24 -0800341template< int SIZE >
PKEuS95060352013-07-26 10:42:44 +0200342class MemPoolT : public MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800343{
344public:
Lee Thomason5b0a6772012-11-19 13:54:42 -0800345 MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700346 ~MemPoolT() {
Lee Thomasonf07b9522014-10-30 13:25:12 -0700347 Clear();
348 }
349
350 void Clear() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700351 // Delete the blocks.
Lee Thomasonf07b9522014-10-30 13:25:12 -0700352 while( !_blockPtrs.Empty()) {
353 Block* b = _blockPtrs.Pop();
354 delete b;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700355 }
Lee Thomasonf07b9522014-10-30 13:25:12 -0700356 _root = 0;
357 _currentAllocs = 0;
358 _nAllocs = 0;
359 _maxAllocs = 0;
360 _nUntracked = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700361 }
Lee Thomasond1983222012-02-06 08:41:24 -0800362
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700363 virtual int ItemSize() const {
364 return SIZE;
365 }
366 int CurrentAllocs() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700367 return _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700368 }
Lee Thomasond1983222012-02-06 08:41:24 -0800369
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700370 virtual void* Alloc() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700371 if ( !_root ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700372 // Need a new block.
373 Block* block = new Block();
Lee Thomason624d43f2012-10-12 10:58:48 -0700374 _blockPtrs.Push( block );
Lee Thomasond1983222012-02-06 08:41:24 -0800375
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700376 for( int i=0; i<COUNT-1; ++i ) {
377 block->chunk[i].next = &block->chunk[i+1];
378 }
379 block->chunk[COUNT-1].next = 0;
Lee Thomason624d43f2012-10-12 10:58:48 -0700380 _root = block->chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700381 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700382 void* result = _root;
383 _root = _root->next;
Lee Thomason455c9d42012-02-06 09:14:14 -0800384
Lee Thomason624d43f2012-10-12 10:58:48 -0700385 ++_currentAllocs;
386 if ( _currentAllocs > _maxAllocs ) {
387 _maxAllocs = _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700388 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700389 _nAllocs++;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800390 _nUntracked++;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700391 return result;
392 }
Lee Thomasonf07b9522014-10-30 13:25:12 -0700393
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700394 virtual void Free( void* mem ) {
395 if ( !mem ) {
396 return;
397 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700398 --_currentAllocs;
Dmitry-Me56571762014-08-15 11:03:47 +0400399 Chunk* chunk = static_cast<Chunk*>( mem );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700400#ifdef DEBUG
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700401 memset( chunk, 0xfe, sizeof(Chunk) );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700402#endif
Lee Thomason624d43f2012-10-12 10:58:48 -0700403 chunk->next = _root;
404 _root = chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700405 }
406 void Trace( const char* name ) {
407 printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
Lee Thomason624d43f2012-10-12 10:58:48 -0700408 name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700409 }
Lee Thomasond1983222012-02-06 08:41:24 -0800410
Lee Thomason5b0a6772012-11-19 13:54:42 -0800411 void SetTracked() {
412 _nUntracked--;
413 }
414
415 int Untracked() const {
416 return _nUntracked;
417 }
418
Lee Thomason (grinliz)ac83b4e2013-02-01 09:02:34 -0800419 // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
420 // The test file is large, 170k.
421 // Release: VS2010 gcc(no opt)
422 // 1k: 4000
423 // 2k: 4000
424 // 4k: 3900 21000
425 // 16k: 5200
426 // 32k: 4300
427 // 64k: 4000 21000
428 enum { COUNT = (4*1024)/SIZE }; // Some compilers do not accept to use COUNT in private part if COUNT is private
Jerome Martinez7921df12012-10-24 11:45:44 +0200429
Lee Thomasond1983222012-02-06 08:41:24 -0800430private:
Dmitry-Me3e0af372015-01-09 15:30:00 +0300431 MemPoolT( const MemPoolT& ); // not supported
432 void operator=( const MemPoolT& ); // not supported
433
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700434 union Chunk {
Lee Thomason624d43f2012-10-12 10:58:48 -0700435 Chunk* next;
436 char mem[SIZE];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700437 };
438 struct Block {
Lee Thomason (grinliz)856da212012-10-19 09:08:15 -0700439 Chunk chunk[COUNT];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700440 };
Lee Thomason624d43f2012-10-12 10:58:48 -0700441 DynArray< Block*, 10 > _blockPtrs;
442 Chunk* _root;
Lee Thomason455c9d42012-02-06 09:14:14 -0800443
Lee Thomason624d43f2012-10-12 10:58:48 -0700444 int _currentAllocs;
445 int _nAllocs;
446 int _maxAllocs;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800447 int _nUntracked;
Lee Thomasond1983222012-02-06 08:41:24 -0800448};
449
Lee Thomason2c85a712012-01-31 08:24:24 -0800450
Lee Thomason56bdd022012-02-09 18:16:58 -0800451
452/**
453 Implements the interface to the "Visitor pattern" (see the Accept() method.)
454 If you call the Accept() method, it requires being passed a XMLVisitor
455 class to handle callbacks. For nodes that contain other nodes (Document, Element)
Thomas Roß08bdf502012-05-12 14:21:23 +0200456 you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
Lee Thomason56bdd022012-02-09 18:16:58 -0800457 are simply called with Visit().
458
459 If you return 'true' from a Visit method, recursive parsing will continue. If you return
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700460 false, <b>no children of this node or its siblings</b> will be visited.
Lee Thomason56bdd022012-02-09 18:16:58 -0800461
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700462 All flavors of Visit methods have a default implementation that returns 'true' (continue
Lee Thomason56bdd022012-02-09 18:16:58 -0800463 visiting). You need to only override methods that are interesting to you.
464
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600465 Generally Accept() is called on the XMLDocument, although all nodes support visiting.
Lee Thomason56bdd022012-02-09 18:16:58 -0800466
467 You should never change the document from a callback.
468
469 @sa XMLNode::Accept()
470*/
PKEuS16ed47d2013-07-06 12:02:43 +0200471class TINYXML2_LIB XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800472{
473public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700474 virtual ~XMLVisitor() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800475
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700476 /// Visit a document.
477 virtual bool VisitEnter( const XMLDocument& /*doc*/ ) {
478 return true;
479 }
480 /// Visit a document.
481 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
482 return true;
483 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800484
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700485 /// Visit an element.
486 virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ ) {
487 return true;
488 }
489 /// Visit an element.
490 virtual bool VisitExit( const XMLElement& /*element*/ ) {
491 return true;
492 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800493
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700494 /// Visit a declaration.
495 virtual bool Visit( const XMLDeclaration& /*declaration*/ ) {
496 return true;
497 }
498 /// Visit a text node.
499 virtual bool Visit( const XMLText& /*text*/ ) {
500 return true;
501 }
502 /// Visit a comment node.
503 virtual bool Visit( const XMLComment& /*comment*/ ) {
504 return true;
505 }
506 /// Visit an unknown node.
507 virtual bool Visit( const XMLUnknown& /*unknown*/ ) {
508 return true;
509 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800510};
511
Dmitry-Me66d2a842014-11-08 15:24:52 +0300512// WARNING: must match XMLDocument::_errorNames[]
numatrumpetbb5ffac2014-09-06 22:56:46 +0900513enum XMLError {
numatrumpetcd8550c2014-09-08 16:59:39 +0900514 XML_SUCCESS = 0,
515 XML_NO_ERROR = 0,
516 XML_NO_ATTRIBUTE,
517 XML_WRONG_ATTRIBUTE_TYPE,
518 XML_ERROR_FILE_NOT_FOUND,
519 XML_ERROR_FILE_COULD_NOT_BE_OPENED,
520 XML_ERROR_FILE_READ_ERROR,
521 XML_ERROR_ELEMENT_MISMATCH,
522 XML_ERROR_PARSING_ELEMENT,
523 XML_ERROR_PARSING_ATTRIBUTE,
524 XML_ERROR_IDENTIFYING_TAG,
525 XML_ERROR_PARSING_TEXT,
526 XML_ERROR_PARSING_CDATA,
527 XML_ERROR_PARSING_COMMENT,
528 XML_ERROR_PARSING_DECLARATION,
529 XML_ERROR_PARSING_UNKNOWN,
530 XML_ERROR_EMPTY_DOCUMENT,
531 XML_ERROR_MISMATCHED_ELEMENT,
532 XML_ERROR_PARSING,
533 XML_CAN_NOT_CONVERT_TEXT,
Lee Thomason331596e2014-09-11 14:56:43 -0700534 XML_NO_TEXT_NODE,
535
536 XML_ERROR_COUNT
numatrumpetbb5ffac2014-09-06 22:56:46 +0900537};
numatrumpetbb5ffac2014-09-06 22:56:46 +0900538
numatrumpetcd8550c2014-09-08 16:59:39 +0900539
U-Stream\Leeae25a442012-02-17 17:48:16 -0800540/*
541 Utility functionality.
542*/
Lee Thomason56bdd022012-02-09 18:16:58 -0800543class XMLUtil
544{
Lee Thomasond1983222012-02-06 08:41:24 -0800545public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700546 static const char* SkipWhiteSpace( const char* p ) {
Dmitry-Mebb836dc2014-12-24 11:54:05 +0300547 TIXMLASSERT( p );
Dmitry-Mefa20b222014-10-31 12:53:04 +0300548 while( IsWhiteSpace(*p) ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700549 ++p;
550 }
Dmitry-Mebb836dc2014-12-24 11:54:05 +0300551 TIXMLASSERT( p );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700552 return p;
553 }
554 static char* SkipWhiteSpace( char* p ) {
Dmitry-Me9de541f2014-09-24 14:21:36 +0400555 return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p) ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700556 }
Dmitry-Mefa20b222014-10-31 12:53:04 +0300557
558 // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
559 // correct, but simple, and usually works.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700560 static bool IsWhiteSpace( char p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100561 return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700562 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200563
564 inline static bool IsNameStartChar( unsigned char ch ) {
Dmitry-Meea617f92015-01-01 16:32:01 +0300565 if ( ch >= 128 ) {
566 // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
567 return true;
568 }
569 if ( isalpha( ch ) ) {
570 return true;
571 }
572 return ch == ':' || ch == '_';
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200573 }
574
575 inline static bool IsNameChar( unsigned char ch ) {
576 return IsNameStartChar( ch )
577 || isdigit( ch )
578 || ch == '.'
579 || ch == '-';
580 }
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800581
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700582 inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700583 if ( p == q ) {
584 return true;
585 }
Dmitry-Me5b4a5162014-12-23 17:36:28 +0300586 int n = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700587 while( *p && *q && *p == *q && n<nChar ) {
588 ++p;
589 ++q;
590 ++n;
591 }
592 if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
593 return true;
594 }
595 return false;
596 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200597
Dmitry-Me72bb0ec2014-09-24 16:14:24 +0400598 inline static bool IsUTF8Continuation( const char p ) {
599 return ( p & 0x80 ) != 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700600 }
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800601
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700602 static const char* ReadBOM( const char* p, bool* hasBOM );
603 // p is the starting location,
604 // the UTF-8 value of the entity will be placed in value, and length filled in.
605 static const char* GetCharacterRef( const char* p, char* value, int* length );
606 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
Lee Thomason21be8822012-07-15 17:27:22 -0700607
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700608 // converts primitive types to strings
609 static void ToStr( int v, char* buffer, int bufferSize );
610 static void ToStr( unsigned v, char* buffer, int bufferSize );
611 static void ToStr( bool v, char* buffer, int bufferSize );
612 static void ToStr( float v, char* buffer, int bufferSize );
613 static void ToStr( double v, char* buffer, int bufferSize );
Lee Thomason21be8822012-07-15 17:27:22 -0700614
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700615 // converts strings to primitive types
616 static bool ToInt( const char* str, int* value );
617 static bool ToUnsigned( const char* str, unsigned* value );
618 static bool ToBool( const char* str, bool* value );
619 static bool ToFloat( const char* str, float* value );
620 static bool ToDouble( const char* str, double* value );
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800621};
622
Lee Thomason5cae8972012-01-24 18:03:07 -0800623
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800624/** XMLNode is a base class for every object that is in the
625 XML Document Object Model (DOM), except XMLAttributes.
626 Nodes have siblings, a parent, and children which can
627 be navigated. A node is always in a XMLDocument.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700628 The type of a XMLNode can be queried, and it can
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800629 be cast to its more defined type.
630
Thomas Roß08bdf502012-05-12 14:21:23 +0200631 A XMLDocument allocates memory for all its Nodes.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800632 When the XMLDocument gets deleted, all its Nodes
633 will also be deleted.
634
635 @verbatim
636 A Document can contain: Element (container or leaf)
637 Comment (leaf)
638 Unknown (leaf)
639 Declaration( leaf )
640
641 An Element can contain: Element (container or leaf)
642 Text (leaf)
643 Attributes (not on tree)
644 Comment (leaf)
645 Unknown (leaf)
646
647 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800648*/
PKEuS16ed47d2013-07-06 12:02:43 +0200649class TINYXML2_LIB XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800650{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700651 friend class XMLDocument;
652 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800653public:
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800654
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700655 /// Get the XMLDocument that owns this XMLNode.
656 const XMLDocument* GetDocument() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700657 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700658 }
659 /// Get the XMLDocument that owns this XMLNode.
660 XMLDocument* GetDocument() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700661 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700662 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800663
Lee Thomason2fa81722012-11-09 12:37:46 -0800664 /// Safely cast to an Element, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700665 virtual XMLElement* ToElement() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100666 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700667 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800668 /// Safely cast to Text, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700669 virtual XMLText* ToText() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100670 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700671 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800672 /// Safely cast to a Comment, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700673 virtual XMLComment* ToComment() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100674 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700675 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800676 /// Safely cast to a Document, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700677 virtual XMLDocument* ToDocument() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100678 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700679 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800680 /// Safely cast to a Declaration, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700681 virtual XMLDeclaration* ToDeclaration() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100682 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700683 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800684 /// Safely cast to an Unknown, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700685 virtual XMLUnknown* ToUnknown() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100686 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700687 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800688
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700689 virtual const XMLElement* ToElement() const {
690 return 0;
691 }
692 virtual const XMLText* ToText() const {
693 return 0;
694 }
695 virtual const XMLComment* ToComment() const {
696 return 0;
697 }
698 virtual const XMLDocument* ToDocument() const {
699 return 0;
700 }
701 virtual const XMLDeclaration* ToDeclaration() const {
702 return 0;
703 }
704 virtual const XMLUnknown* ToUnknown() const {
705 return 0;
706 }
Lee Thomason751da522012-02-10 08:50:51 -0800707
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700708 /** The meaning of 'value' changes for the specific type.
709 @verbatim
710 Document: empty
711 Element: name of the element
712 Comment: the comment text
713 Unknown: the tag contents
714 Text: the text string
715 @endverbatim
716 */
Michael Daumling21626882013-10-22 17:03:37 +0200717 const char* Value() const;
MortenMacFly4ee49f12013-01-14 20:03:14 +0100718
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700719 /** Set the Value of an XML node.
720 @sa Value()
721 */
722 void SetValue( const char* val, bool staticMem=false );
Lee Thomason2c85a712012-01-31 08:24:24 -0800723
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700724 /// Get the parent of this node on the DOM.
725 const XMLNode* Parent() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700726 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700727 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100728
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700729 XMLNode* Parent() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700730 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700731 }
Lee Thomason751da522012-02-10 08:50:51 -0800732
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700733 /// Returns true if this node has no children.
734 bool NoChildren() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700735 return !_firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700736 }
Lee Thomason751da522012-02-10 08:50:51 -0800737
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700738 /// Get the first child node, or null if none exists.
739 const XMLNode* FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700740 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700741 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100742
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700743 XMLNode* FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700744 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700745 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100746
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700747 /** Get the first child element, or optionally the first child
748 element with the specified name.
749 */
750 const XMLElement* FirstChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700751
752 XMLElement* FirstChildElement( const char* value=0 ) {
753 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700754 }
Lee Thomason3f57d272012-01-11 15:30:03 -0800755
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700756 /// Get the last child node, or null if none exists.
757 const XMLNode* LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700758 return _lastChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700759 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700760
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700761 XMLNode* LastChild() {
762 return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
763 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800764
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700765 /** Get the last child element or optionally the last child
766 element with the specified name.
767 */
768 const XMLElement* LastChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700769
770 XMLElement* LastChildElement( const char* value=0 ) {
771 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700772 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700773
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700774 /// Get the previous (left) sibling node of this node.
775 const XMLNode* PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700776 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700777 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700778
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700779 XMLNode* PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700780 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700781 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800782
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700783 /// Get the previous (left) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700784 const XMLElement* PreviousSiblingElement( const char* value=0 ) const ;
Lee Thomason624d43f2012-10-12 10:58:48 -0700785
786 XMLElement* PreviousSiblingElement( const char* value=0 ) {
787 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700788 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700789
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700790 /// Get the next (right) sibling node of this node.
791 const XMLNode* NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700792 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700793 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700794
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700795 XMLNode* NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700796 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700797 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700798
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700799 /// Get the next (right) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700800 const XMLElement* NextSiblingElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700801
802 XMLElement* NextSiblingElement( const char* value=0 ) {
803 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700804 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800805
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700806 /**
807 Add a child node as the last (right) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200808 If the child node is already part of the document,
809 it is moved from its old location to the new location.
810 Returns the addThis argument or 0 if the node does not
811 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700812 */
813 XMLNode* InsertEndChild( XMLNode* addThis );
Lee Thomason618dbf82012-02-28 12:34:27 -0800814
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700815 XMLNode* LinkEndChild( XMLNode* addThis ) {
816 return InsertEndChild( addThis );
817 }
818 /**
819 Add a child node as the first (left) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200820 If the child node is already part of the document,
821 it is moved from its old location to the new location.
822 Returns the addThis argument or 0 if the node does not
823 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700824 */
825 XMLNode* InsertFirstChild( XMLNode* addThis );
826 /**
827 Add a node after the specified child node.
Michael Daumlinged523282013-10-23 07:47:29 +0200828 If the child node is already part of the document,
829 it is moved from its old location to the new location.
830 Returns the addThis argument or 0 if the afterThis node
831 is not a child of this node, or if the node does not
832 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700833 */
834 XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700835
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700836 /**
837 Delete all the children of this node.
838 */
839 void DeleteChildren();
U-Stream\Leeae25a442012-02-17 17:48:16 -0800840
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700841 /**
842 Delete a child of this node.
843 */
844 void DeleteChild( XMLNode* node );
Lee Thomason56bdd022012-02-09 18:16:58 -0800845
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700846 /**
847 Make a copy of this node, but not its children.
848 You may pass in a Document pointer that will be
849 the owner of the new Node. If the 'document' is
850 null, then the node returned will be allocated
851 from the current Document. (this->GetDocument())
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800852
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700853 Note: if called on a XMLDocument, this will return null.
854 */
855 virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800856
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700857 /**
858 Test if 2 nodes are the same, but don't test children.
859 The 2 nodes do not need to be in the same Document.
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800860
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700861 Note: if called on a XMLDocument, this will return false.
862 */
863 virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800864
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600865 /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700866 XML tree will be conditionally visited and the host will be called back
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600867 via the XMLVisitor interface.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800868
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600869 This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
870 the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700871 interface versus any other.)
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800872
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700873 The interface has been based on ideas from:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800874
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700875 - http://www.saxproject.org/
876 - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800877
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700878 Which are both good references for "visiting".
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800879
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700880 An example of using Accept():
881 @verbatim
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600882 XMLPrinter printer;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700883 tinyxmlDoc.Accept( &printer );
884 const char* xmlcstr = printer.CStr();
885 @endverbatim
886 */
887 virtual bool Accept( XMLVisitor* visitor ) const = 0;
Lee Thomason56bdd022012-02-09 18:16:58 -0800888
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700889 // internal
890 virtual char* ParseDeep( char*, StrPair* );
Lee Thomason3f57d272012-01-11 15:30:03 -0800891
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800892protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700893 XMLNode( XMLDocument* );
894 virtual ~XMLNode();
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700895
Lee Thomason624d43f2012-10-12 10:58:48 -0700896 XMLDocument* _document;
897 XMLNode* _parent;
898 mutable StrPair _value;
Lee Thomason3f57d272012-01-11 15:30:03 -0800899
Lee Thomason624d43f2012-10-12 10:58:48 -0700900 XMLNode* _firstChild;
901 XMLNode* _lastChild;
Lee Thomason3f57d272012-01-11 15:30:03 -0800902
Lee Thomason624d43f2012-10-12 10:58:48 -0700903 XMLNode* _prev;
904 XMLNode* _next;
Lee Thomason3f57d272012-01-11 15:30:03 -0800905
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800906private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700907 MemPool* _memPool;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700908 void Unlink( XMLNode* child );
Dmitry-Mee3225b12014-09-03 11:03:11 +0400909 static void DeleteNode( XMLNode* node );
Lee Thomason3cebdc42015-01-05 17:16:28 -0800910 void InsertChildPreamble( XMLNode* insertThis ) const;
Dmitry-Mef547a992015-01-09 15:17:09 +0300911
912 XMLNode( const XMLNode& ); // not supported
913 XMLNode& operator=( const XMLNode& ); // not supported
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800914};
915
916
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800917/** XML text.
918
919 Note that a text node can have child element nodes, for example:
920 @verbatim
921 <root>This is <b>bold</b></root>
922 @endverbatim
923
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700924 A text node can have 2 ways to output the next. "normal" output
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800925 and CDATA. It will default to the mode it was parsed from the XML file and
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700926 you generally want to leave it alone, but you can change the output mode with
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600927 SetCData() and query it with CData().
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800928*/
PKEuS16ed47d2013-07-06 12:02:43 +0200929class TINYXML2_LIB XMLText : public XMLNode
Lee Thomason5492a1c2012-01-23 15:32:10 -0800930{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700931 friend class XMLBase;
932 friend class XMLDocument;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800933public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700934 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -0800935
Lee Thomason624d43f2012-10-12 10:58:48 -0700936 virtual XMLText* ToText() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700937 return this;
938 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700939 virtual const XMLText* ToText() const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700940 return this;
941 }
Lee Thomason5492a1c2012-01-23 15:32:10 -0800942
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700943 /// Declare whether this should be CDATA or standard text.
Lee Thomason624d43f2012-10-12 10:58:48 -0700944 void SetCData( bool isCData ) {
945 _isCData = isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700946 }
947 /// Returns true if this is a CDATA text element.
948 bool CData() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700949 return _isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700950 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800951
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700952 char* ParseDeep( char*, StrPair* endTag );
953 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
954 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800955
Lee Thomason5492a1c2012-01-23 15:32:10 -0800956protected:
Lee Thomason624d43f2012-10-12 10:58:48 -0700957 XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700958 virtual ~XMLText() {}
Lee Thomason5492a1c2012-01-23 15:32:10 -0800959
960private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700961 bool _isCData;
Dmitry-Mef547a992015-01-09 15:17:09 +0300962
963 XMLText( const XMLText& ); // not supported
964 XMLText& operator=( const XMLText& ); // not supported
Lee Thomason5492a1c2012-01-23 15:32:10 -0800965};
966
967
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800968/** An XML Comment. */
PKEuS16ed47d2013-07-06 12:02:43 +0200969class TINYXML2_LIB XMLComment : public XMLNode
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800970{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700971 friend class XMLDocument;
Lee Thomason3f57d272012-01-11 15:30:03 -0800972public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700973 virtual XMLComment* ToComment() {
974 return this;
975 }
976 virtual const XMLComment* ToComment() const {
977 return this;
978 }
Lee Thomasonce0763e2012-01-11 15:43:54 -0800979
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700980 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800981
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700982 char* ParseDeep( char*, StrPair* endTag );
983 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
984 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomasonce0763e2012-01-11 15:43:54 -0800985
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800986protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700987 XMLComment( XMLDocument* doc );
988 virtual ~XMLComment();
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800989
Lee Thomason3f57d272012-01-11 15:30:03 -0800990private:
Dmitry-Mef547a992015-01-09 15:17:09 +0300991 XMLComment( const XMLComment& ); // not supported
992 XMLComment& operator=( const XMLComment& ); // not supported
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800993};
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800994
995
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800996/** In correct XML the declaration is the first entry in the file.
997 @verbatim
998 <?xml version="1.0" standalone="yes"?>
999 @endverbatim
1000
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001001 TinyXML-2 will happily read or write files without a declaration,
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001002 however.
1003
1004 The text of the declaration isn't interpreted. It is parsed
1005 and written as a string.
1006*/
PKEuS16ed47d2013-07-06 12:02:43 +02001007class TINYXML2_LIB XMLDeclaration : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -08001008{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001009 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -08001010public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001011 virtual XMLDeclaration* ToDeclaration() {
1012 return this;
1013 }
1014 virtual const XMLDeclaration* ToDeclaration() const {
1015 return this;
1016 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001017
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001018 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001019
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001020 char* ParseDeep( char*, StrPair* endTag );
1021 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1022 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001023
1024protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001025 XMLDeclaration( XMLDocument* doc );
1026 virtual ~XMLDeclaration();
Dmitry-Mef547a992015-01-09 15:17:09 +03001027
1028private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001029 XMLDeclaration( const XMLDeclaration& ); // not supported
1030 XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001031};
1032
1033
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001034/** Any tag that TinyXML-2 doesn't recognize is saved as an
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001035 unknown. It is a tag of text, but should not be modified.
1036 It will be written back to the XML, unchanged, when the file
1037 is saved.
1038
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001039 DTD tags get thrown into XMLUnknowns.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001040*/
PKEuS16ed47d2013-07-06 12:02:43 +02001041class TINYXML2_LIB XMLUnknown : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -08001042{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001043 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -08001044public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001045 virtual XMLUnknown* ToUnknown() {
1046 return this;
1047 }
1048 virtual const XMLUnknown* ToUnknown() const {
1049 return this;
1050 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001051
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001052 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001053
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001054 char* ParseDeep( char*, StrPair* endTag );
1055 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1056 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001057
1058protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001059 XMLUnknown( XMLDocument* doc );
1060 virtual ~XMLUnknown();
Dmitry-Mef547a992015-01-09 15:17:09 +03001061
1062private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001063 XMLUnknown( const XMLUnknown& ); // not supported
1064 XMLUnknown& operator=( const XMLUnknown& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001065};
1066
1067
Lee Thomason1ff38e02012-02-14 18:18:16 -08001068
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001069/** An attribute is a name-value pair. Elements have an arbitrary
1070 number of attributes, each with a unique name.
1071
1072 @note The attributes are not XMLNodes. You may only query the
1073 Next() attribute in a list.
1074*/
PKEuS16ed47d2013-07-06 12:02:43 +02001075class TINYXML2_LIB XMLAttribute
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001076{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001077 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001078public:
Lee Thomason2fa81722012-11-09 12:37:46 -08001079 /// The name of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001080 const char* Name() const;
1081
Lee Thomason2fa81722012-11-09 12:37:46 -08001082 /// The value of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001083 const char* Value() const;
1084
Lee Thomason2fa81722012-11-09 12:37:46 -08001085 /// The next attribute in the list.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001086 const XMLAttribute* Next() const {
MortenMacFly4ee49f12013-01-14 20:03:14 +01001087 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001088 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001089
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001090 /** IntValue interprets the attribute as an integer, and returns the value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001091 If the value isn't an integer, 0 will be returned. There is no error checking;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001092 use QueryIntValue() if you need error checking.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001093 */
1094 int IntValue() const {
1095 int i=0;
1096 QueryIntValue( &i );
1097 return i;
1098 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001099 /// Query as an unsigned integer. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001100 unsigned UnsignedValue() const {
1101 unsigned i=0;
1102 QueryUnsignedValue( &i );
1103 return i;
1104 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001105 /// Query as a boolean. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001106 bool BoolValue() const {
1107 bool b=false;
1108 QueryBoolValue( &b );
1109 return b;
1110 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001111 /// Query as a double. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001112 double DoubleValue() const {
1113 double d=0;
1114 QueryDoubleValue( &d );
1115 return d;
1116 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001117 /// Query as a float. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001118 float FloatValue() const {
1119 float f=0;
1120 QueryFloatValue( &f );
1121 return f;
1122 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001123
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001124 /** QueryIntValue interprets the attribute as an integer, and returns the value
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001125 in the provided parameter. The function will return XML_NO_ERROR on success,
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001126 and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
1127 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001128 XMLError QueryIntValue( int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001129 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001130 XMLError QueryUnsignedValue( unsigned int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001131 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001132 XMLError QueryBoolValue( bool* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001133 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001134 XMLError QueryDoubleValue( double* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001135 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001136 XMLError QueryFloatValue( float* value ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -08001137
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001138 /// Set the attribute to a string value.
1139 void SetAttribute( const char* value );
1140 /// Set the attribute to value.
1141 void SetAttribute( int value );
1142 /// Set the attribute to value.
1143 void SetAttribute( unsigned value );
1144 /// Set the attribute to value.
1145 void SetAttribute( bool value );
1146 /// Set the attribute to value.
1147 void SetAttribute( double value );
1148 /// Set the attribute to value.
1149 void SetAttribute( float value );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001150
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001151private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001152 enum { BUF_SIZE = 200 };
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001153
Thomas Roß61892312013-05-12 14:07:38 +02001154 XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001155 virtual ~XMLAttribute() {}
Lee Thomason624d43f2012-10-12 10:58:48 -07001156
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001157 XMLAttribute( const XMLAttribute& ); // not supported
1158 void operator=( const XMLAttribute& ); // not supported
1159 void SetName( const char* name );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001160
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001161 char* ParseDeep( char* p, bool processEntities );
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001162
Lee Thomason624d43f2012-10-12 10:58:48 -07001163 mutable StrPair _name;
1164 mutable StrPair _value;
1165 XMLAttribute* _next;
1166 MemPool* _memPool;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001167};
1168
1169
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001170/** The element is a container class. It has a value, the element name,
1171 and can contain other elements, text, comments, and unknowns.
1172 Elements also contain an arbitrary number of attributes.
1173*/
PKEuS16ed47d2013-07-06 12:02:43 +02001174class TINYXML2_LIB XMLElement : public XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001175{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001176 friend class XMLBase;
1177 friend class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001178public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001179 /// Get the name of an element (which is the Value() of the node.)
1180 const char* Name() const {
1181 return Value();
1182 }
1183 /// Set the name of the element.
1184 void SetName( const char* str, bool staticMem=false ) {
1185 SetValue( str, staticMem );
1186 }
Lee Thomason2c85a712012-01-31 08:24:24 -08001187
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001188 virtual XMLElement* ToElement() {
1189 return this;
1190 }
1191 virtual const XMLElement* ToElement() const {
1192 return this;
1193 }
1194 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001195
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001196 /** Given an attribute name, Attribute() returns the value
1197 for the attribute of that name, or null if none
1198 exists. For example:
Lee Thomason92258152012-03-24 13:05:39 -07001199
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001200 @verbatim
1201 const char* value = ele->Attribute( "foo" );
1202 @endverbatim
Lee Thomason92258152012-03-24 13:05:39 -07001203
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001204 The 'value' parameter is normally null. However, if specified,
1205 the attribute will only be returned if the 'name' and 'value'
1206 match. This allow you to write code:
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001207
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001208 @verbatim
1209 if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
1210 @endverbatim
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001211
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001212 rather than:
1213 @verbatim
1214 if ( ele->Attribute( "foo" ) ) {
1215 if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
1216 }
1217 @endverbatim
1218 */
1219 const char* Attribute( const char* name, const char* value=0 ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001220
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001221 /** Given an attribute name, IntAttribute() returns the value
1222 of the attribute interpreted as an integer. 0 will be
1223 returned if there is an error. For a method with error
1224 checking, see QueryIntAttribute()
1225 */
1226 int IntAttribute( const char* name ) const {
1227 int i=0;
1228 QueryIntAttribute( name, &i );
1229 return i;
1230 }
1231 /// See IntAttribute()
1232 unsigned UnsignedAttribute( const char* name ) const {
1233 unsigned i=0;
1234 QueryUnsignedAttribute( name, &i );
1235 return i;
1236 }
1237 /// See IntAttribute()
1238 bool BoolAttribute( const char* name ) const {
1239 bool b=false;
1240 QueryBoolAttribute( name, &b );
1241 return b;
1242 }
1243 /// See IntAttribute()
1244 double DoubleAttribute( const char* name ) const {
1245 double d=0;
1246 QueryDoubleAttribute( name, &d );
1247 return d;
1248 }
1249 /// See IntAttribute()
1250 float FloatAttribute( const char* name ) const {
1251 float f=0;
1252 QueryFloatAttribute( name, &f );
1253 return f;
1254 }
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001255
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001256 /** Given an attribute name, QueryIntAttribute() returns
1257 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1258 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1259 doesn't exist. If successful, the result of the conversion
1260 will be written to 'value'. If not successful, nothing will
1261 be written to 'value'. This allows you to provide default
1262 value:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001263
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001264 @verbatim
1265 int value = 10;
1266 QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1267 @endverbatim
1268 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001269 XMLError QueryIntAttribute( const char* name, int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001270 const XMLAttribute* a = FindAttribute( name );
1271 if ( !a ) {
1272 return XML_NO_ATTRIBUTE;
1273 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001274 return a->QueryIntValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001275 }
1276 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001277 XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001278 const XMLAttribute* a = FindAttribute( name );
1279 if ( !a ) {
1280 return XML_NO_ATTRIBUTE;
1281 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001282 return a->QueryUnsignedValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001283 }
1284 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001285 XMLError QueryBoolAttribute( const char* name, bool* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001286 const XMLAttribute* a = FindAttribute( name );
1287 if ( !a ) {
1288 return XML_NO_ATTRIBUTE;
1289 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001290 return a->QueryBoolValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001291 }
1292 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001293 XMLError QueryDoubleAttribute( const char* name, double* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001294 const XMLAttribute* a = FindAttribute( name );
1295 if ( !a ) {
1296 return XML_NO_ATTRIBUTE;
1297 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001298 return a->QueryDoubleValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001299 }
1300 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001301 XMLError QueryFloatAttribute( const char* name, float* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001302 const XMLAttribute* a = FindAttribute( name );
1303 if ( !a ) {
1304 return XML_NO_ATTRIBUTE;
1305 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001306 return a->QueryFloatValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001307 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001308
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001309
1310 /** Given an attribute name, QueryAttribute() returns
1311 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1312 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1313 doesn't exist. It is overloaded for the primitive types,
1314 and is a generally more convenient replacement of
1315 QueryIntAttribute() and related functions.
1316
1317 If successful, the result of the conversion
1318 will be written to 'value'. If not successful, nothing will
1319 be written to 'value'. This allows you to provide default
1320 value:
1321
1322 @verbatim
1323 int value = 10;
1324 QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1325 @endverbatim
1326 */
1327 int QueryAttribute( const char* name, int* value ) const {
1328 return QueryIntAttribute( name, value );
1329 }
1330
1331 int QueryAttribute( const char* name, unsigned int* value ) const {
1332 return QueryUnsignedAttribute( name, value );
1333 }
1334
1335 int QueryAttribute( const char* name, bool* value ) const {
1336 return QueryBoolAttribute( name, value );
1337 }
1338
1339 int QueryAttribute( const char* name, double* value ) const {
1340 return QueryDoubleAttribute( name, value );
1341 }
1342
1343 int QueryAttribute( const char* name, float* value ) const {
1344 return QueryFloatAttribute( name, value );
1345 }
1346
1347 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001348 void SetAttribute( const char* name, const char* value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001349 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001350 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001351 }
1352 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001353 void SetAttribute( const char* name, int value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001354 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001355 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001356 }
1357 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001358 void SetAttribute( const char* name, unsigned value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001359 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001360 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001361 }
1362 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001363 void SetAttribute( const char* name, bool value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001364 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001365 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001366 }
1367 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001368 void SetAttribute( const char* name, double value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001369 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001370 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001371 }
Lee Thomasonc3708cc2014-01-14 12:30:03 -08001372 /// Sets the named attribute to value.
1373 void SetAttribute( const char* name, float value ) {
1374 XMLAttribute* a = FindOrCreateAttribute( name );
1375 a->SetAttribute( value );
1376 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001377
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001378 /**
1379 Delete an attribute.
1380 */
1381 void DeleteAttribute( const char* name );
Lee Thomason751da522012-02-10 08:50:51 -08001382
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001383 /// Return the first attribute in the list.
1384 const XMLAttribute* FirstAttribute() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001385 return _rootAttribute;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001386 }
1387 /// Query a specific attribute in the list.
1388 const XMLAttribute* FindAttribute( const char* name ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001389
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001390 /** Convenience function for easy access to the text inside an element. Although easy
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001391 and concise, GetText() is limited compared to getting the XMLText child
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001392 and accessing it directly.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001393
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001394 If the first child of 'this' is a XMLText, the GetText()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001395 returns the character string of the Text node, else null is returned.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001396
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001397 This is a convenient method for getting the text of simple contained text:
1398 @verbatim
1399 <foo>This is text</foo>
1400 const char* str = fooElement->GetText();
1401 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001402
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001403 'str' will be a pointer to "This is text".
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001404
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001405 Note that this function can be misleading. If the element foo was created from
1406 this XML:
1407 @verbatim
1408 <foo><b>This is text</b></foo>
1409 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001410
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001411 then the value of str would be null. The first child node isn't a text node, it is
1412 another element. From this XML:
1413 @verbatim
1414 <foo>This is <b>text</b></foo>
1415 @endverbatim
1416 GetText() will return "This is ".
1417 */
1418 const char* GetText() const;
Lee Thomason751da522012-02-10 08:50:51 -08001419
Uli Kusterer85fff5e2014-01-21 01:35:30 +01001420 /** Convenience function for easy access to the text inside an element. Although easy
1421 and concise, SetText() is limited compared to creating an XMLText child
1422 and mutating it directly.
1423
1424 If the first child of 'this' is a XMLText, SetText() sets its value to
1425 the given string, otherwise it will create a first child that is an XMLText.
1426
1427 This is a convenient method for setting the text of simple contained text:
1428 @verbatim
1429 <foo>This is text</foo>
1430 fooElement->SetText( "Hullaballoo!" );
1431 <foo>Hullaballoo!</foo>
1432 @endverbatim
1433
1434 Note that this function can be misleading. If the element foo was created from
1435 this XML:
1436 @verbatim
1437 <foo><b>This is text</b></foo>
1438 @endverbatim
1439
1440 then it will not change "This is text", but rather prefix it with a text element:
1441 @verbatim
1442 <foo>Hullaballoo!<b>This is text</b></foo>
1443 @endverbatim
1444
1445 For this XML:
1446 @verbatim
1447 <foo />
1448 @endverbatim
1449 SetText() will generate
1450 @verbatim
1451 <foo>Hullaballoo!</foo>
1452 @endverbatim
1453 */
Lee Thomason5bb2d802014-01-24 10:42:57 -08001454 void SetText( const char* inText );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001455 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001456 void SetText( int value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001457 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001458 void SetText( unsigned value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001459 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001460 void SetText( bool value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001461 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001462 void SetText( double value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001463 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001464 void SetText( float value );
Uli Kusterer8fe342a2014-01-21 01:12:47 +01001465
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001466 /**
1467 Convenience method to query the value of a child text node. This is probably best
1468 shown by example. Given you have a document is this form:
1469 @verbatim
1470 <point>
1471 <x>1</x>
1472 <y>1.4</y>
1473 </point>
1474 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001475
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001476 The QueryIntText() and similar functions provide a safe and easier way to get to the
1477 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001478
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001479 @verbatim
1480 int x = 0;
1481 float y = 0; // types of x and y are contrived for example
1482 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1483 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1484 xElement->QueryIntText( &x );
1485 yElement->QueryFloatText( &y );
1486 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001487
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001488 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1489 to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001490
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001491 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001492 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001493 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001494 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001495 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001496 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001497 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001498 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001499 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001500 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001501
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001502 // internal:
1503 enum {
1504 OPEN, // <foo>
1505 CLOSED, // <foo/>
1506 CLOSING // </foo>
1507 };
1508 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001509 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001510 }
1511 char* ParseDeep( char* p, StrPair* endTag );
1512 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1513 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001514
Lee Thomason50adb4c2012-02-13 15:07:09 -08001515private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001516 XMLElement( XMLDocument* doc );
1517 virtual ~XMLElement();
1518 XMLElement( const XMLElement& ); // not supported
1519 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001520
Dmitry-Me1227d512014-12-05 13:41:45 +03001521 XMLAttribute* FindAttribute( const char* name ) {
1522 return const_cast<XMLAttribute*>(const_cast<const XMLElement*>(this)->FindAttribute( name ));
1523 }
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001524 XMLAttribute* FindOrCreateAttribute( const char* name );
1525 //void LinkAttribute( XMLAttribute* attrib );
1526 char* ParseAttributes( char* p );
Dmitry-Mee3225b12014-09-03 11:03:11 +04001527 static void DeleteAttribute( XMLAttribute* attribute );
Lee Thomason67d61312012-01-24 16:01:51 -08001528
Lee Thomason5bb2d802014-01-24 10:42:57 -08001529 enum { BUF_SIZE = 200 };
Lee Thomason624d43f2012-10-12 10:58:48 -07001530 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001531 // The attribute list is ordered; there is no 'lastAttribute'
1532 // because the list needs to be scanned for dupes before adding
1533 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001534 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001535};
1536
1537
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001538enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001539 PRESERVE_WHITESPACE,
1540 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001541};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001542
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001543
1544/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001545 It can be saved, loaded, and printed to the screen.
1546 All Nodes are connected and allocated to a Document.
1547 If the Document is deleted, all its Nodes are also deleted.
1548*/
PKEuS16ed47d2013-07-06 12:02:43 +02001549class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001550{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001551 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001552public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001553 /// constructor
1554 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1555 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001556
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001557 virtual XMLDocument* ToDocument() {
1558 return this;
1559 }
1560 virtual const XMLDocument* ToDocument() const {
1561 return this;
1562 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001563
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001564 /**
1565 Parse an XML file from a character string.
1566 Returns XML_NO_ERROR (0) on success, or
1567 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001568
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001569 You may optionally pass in the 'nBytes', which is
1570 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001571 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001572 null terminated string.
1573 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001574 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001575
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001576 /**
1577 Load an XML file from disk.
1578 Returns XML_NO_ERROR (0) on success, or
1579 an errorID.
1580 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001581 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001582
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001583 /**
1584 Load an XML file from disk. You are responsible
Lee Thomasoncd011bc2014-12-17 10:41:34 -08001585 for providing and closing the FILE*.
1586
1587 NOTE: The file should be opened as binary ("rb")
1588 not text in order for TinyXML-2 to correctly
1589 do newline normalization.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001590
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001591 Returns XML_NO_ERROR (0) on success, or
1592 an errorID.
1593 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001594 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001595
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001596 /**
1597 Save the XML file to disk.
1598 Returns XML_NO_ERROR (0) on success, or
1599 an errorID.
1600 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001601 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001602
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001603 /**
1604 Save the XML file to disk. You are responsible
1605 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001606
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001607 Returns XML_NO_ERROR (0) on success, or
1608 an errorID.
1609 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001610 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001611
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001612 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001613 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001614 }
1615 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001616 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001617 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001618
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001619 /**
1620 Returns true if this document has a leading Byte Order Mark of UTF8.
1621 */
1622 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001623 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001624 }
1625 /** Sets whether to write the BOM when writing the file.
1626 */
1627 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001628 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001629 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001630
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001631 /** Return the root element of DOM. Equivalent to FirstChildElement().
1632 To get the first node, use FirstChild().
1633 */
1634 XMLElement* RootElement() {
1635 return FirstChildElement();
1636 }
1637 const XMLElement* RootElement() const {
1638 return FirstChildElement();
1639 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001640
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001641 /** Print the Document. If the Printer is not provided, it will
1642 print to stdout. If you provide Printer, this can print to a file:
1643 @verbatim
1644 XMLPrinter printer( fp );
1645 doc.Print( &printer );
1646 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001647
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001648 Or you can use a printer to print to memory:
1649 @verbatim
1650 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001651 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001652 // printer.CStr() has a const char* to the XML
1653 @endverbatim
1654 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001655 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001656 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001657
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001658 /**
1659 Create a new Element associated with
1660 this Document. The memory for the Element
1661 is managed by the Document.
1662 */
1663 XMLElement* NewElement( const char* name );
1664 /**
1665 Create a new Comment associated with
1666 this Document. The memory for the Comment
1667 is managed by the Document.
1668 */
1669 XMLComment* NewComment( const char* comment );
1670 /**
1671 Create a new Text associated with
1672 this Document. The memory for the Text
1673 is managed by the Document.
1674 */
1675 XMLText* NewText( const char* text );
1676 /**
1677 Create a new Declaration associated with
1678 this Document. The memory for the object
1679 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001680
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001681 If the 'text' param is null, the standard
1682 declaration is used.:
1683 @verbatim
1684 <?xml version="1.0" encoding="UTF-8"?>
1685 @endverbatim
1686 */
1687 XMLDeclaration* NewDeclaration( const char* text=0 );
1688 /**
1689 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001690 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001691 is managed by the Document.
1692 */
1693 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001694
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001695 /**
1696 Delete a node associated with this document.
1697 It will be unlinked from the DOM.
1698 */
Lee Thomasoncd011bc2014-12-17 10:41:34 -08001699 void DeleteNode( XMLNode* node );
U-Stream\Leeae25a442012-02-17 17:48:16 -08001700
Lee Thomason2fa81722012-11-09 12:37:46 -08001701 void SetError( XMLError error, const char* str1, const char* str2 );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001702
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001703 /// Return true if there was an error parsing the document.
1704 bool Error() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001705 return _errorID != XML_NO_ERROR;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001706 }
1707 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001708 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001709 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001710 }
Lee Thomason331596e2014-09-11 14:56:43 -07001711 const char* ErrorName() const;
1712
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001713 /// Return a possibly helpful diagnostic location or string.
1714 const char* GetErrorStr1() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001715 return _errorStr1;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001716 }
1717 /// Return a possibly helpful secondary diagnostic location or string.
1718 const char* GetErrorStr2() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001719 return _errorStr2;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001720 }
1721 /// If there is an error, print it to stdout.
1722 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001723
1724 /// Clear the document, resetting it to the initial state.
1725 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001726
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001727 // internal
1728 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001729
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001730 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1731 return 0;
1732 }
1733 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1734 return false;
1735 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001736
Lee Thomason3f57d272012-01-11 15:30:03 -08001737private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001738 XMLDocument( const XMLDocument& ); // not supported
1739 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001740
Lee Thomason2fa81722012-11-09 12:37:46 -08001741 bool _writeBOM;
1742 bool _processEntities;
1743 XMLError _errorID;
1744 Whitespace _whitespace;
Lee Thomason624d43f2012-10-12 10:58:48 -07001745 const char* _errorStr1;
1746 const char* _errorStr2;
Lee Thomason2fa81722012-11-09 12:37:46 -08001747 char* _charBuffer;
Lee Thomasond1983222012-02-06 08:41:24 -08001748
Lee Thomason624d43f2012-10-12 10:58:48 -07001749 MemPoolT< sizeof(XMLElement) > _elementPool;
1750 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1751 MemPoolT< sizeof(XMLText) > _textPool;
1752 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason331596e2014-09-11 14:56:43 -07001753
1754 static const char* _errorNames[XML_ERROR_COUNT];
Dmitry-Me97476b72015-01-01 16:15:57 +03001755
1756 void Parse();
Lee Thomason5cae8972012-01-24 18:03:07 -08001757};
1758
Lee Thomason7c913cd2012-01-26 18:32:34 -08001759
Lee Thomason3ffdd392012-03-28 17:27:55 -07001760/**
1761 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001762 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001763 DOM structure. It is a separate utility class.
1764
1765 Take an example:
1766 @verbatim
1767 <Document>
1768 <Element attributeA = "valueA">
1769 <Child attributeB = "value1" />
1770 <Child attributeB = "value2" />
1771 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001772 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001773 @endverbatim
1774
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001775 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001776 easy to write a *lot* of code that looks like:
1777
1778 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001779 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001780 if ( root )
1781 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001782 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001783 if ( element )
1784 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001785 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001786 if ( child )
1787 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001788 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001789 if ( child2 )
1790 {
1791 // Finally do something useful.
1792 @endverbatim
1793
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001794 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001795 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001796 and correct to use:
1797
1798 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001799 XMLHandle docHandle( &document );
Dmitry-Mea317bd62014-12-08 10:35:37 +03001800 XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001801 if ( child2 )
1802 {
1803 // do something useful
1804 @endverbatim
1805
1806 Which is MUCH more concise and useful.
1807
1808 It is also safe to copy handles - internally they are nothing more than node pointers.
1809 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001810 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001811 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001812
1813 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001814*/
PKEuS16ed47d2013-07-06 12:02:43 +02001815class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001816{
1817public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001818 /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
Lee Thomason624d43f2012-10-12 10:58:48 -07001819 XMLHandle( XMLNode* node ) {
1820 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001821 }
1822 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001823 XMLHandle( XMLNode& node ) {
1824 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001825 }
1826 /// Copy constructor
1827 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001828 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001829 }
1830 /// Assignment
1831 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001832 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001833 return *this;
1834 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001835
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001836 /// Get the first child of this handle.
1837 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001838 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001839 }
1840 /// Get the first child element of this handle.
1841 XMLHandle FirstChildElement( const char* value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001842 return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001843 }
1844 /// Get the last child of this handle.
1845 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001846 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001847 }
1848 /// Get the last child element of this handle.
1849 XMLHandle LastChildElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001850 return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001851 }
1852 /// Get the previous sibling of this handle.
1853 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001854 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001855 }
1856 /// Get the previous sibling element of this handle.
1857 XMLHandle PreviousSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001858 return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001859 }
1860 /// Get the next sibling of this handle.
1861 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001862 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001863 }
1864 /// Get the next sibling element of this handle.
1865 XMLHandle NextSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001866 return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001867 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001868
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001869 /// Safe cast to XMLNode. This can return null.
1870 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001871 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001872 }
1873 /// Safe cast to XMLElement. This can return null.
1874 XMLElement* ToElement() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001875 return ( ( _node == 0 ) ? 0 : _node->ToElement() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001876 }
1877 /// Safe cast to XMLText. This can return null.
1878 XMLText* ToText() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001879 return ( ( _node == 0 ) ? 0 : _node->ToText() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001880 }
1881 /// Safe cast to XMLUnknown. This can return null.
1882 XMLUnknown* ToUnknown() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001883 return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001884 }
1885 /// Safe cast to XMLDeclaration. This can return null.
1886 XMLDeclaration* ToDeclaration() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001887 return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001888 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001889
1890private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001891 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001892};
1893
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001894
1895/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001896 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1897 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001898*/
PKEuS16ed47d2013-07-06 12:02:43 +02001899class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001900{
1901public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001902 XMLConstHandle( const XMLNode* node ) {
1903 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001904 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001905 XMLConstHandle( const XMLNode& node ) {
1906 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001907 }
1908 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001909 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001910 }
Lee Thomason8b899812012-04-04 15:58:16 -07001911
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001912 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001913 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001914 return *this;
1915 }
Lee Thomason8b899812012-04-04 15:58:16 -07001916
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001917 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001918 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001919 }
1920 const XMLConstHandle FirstChildElement( const char* value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001921 return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001922 }
1923 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001924 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001925 }
1926 const XMLConstHandle LastChildElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001927 return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001928 }
1929 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001930 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001931 }
1932 const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001933 return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001934 }
1935 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001936 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001937 }
1938 const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001939 return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001940 }
Lee Thomason8b899812012-04-04 15:58:16 -07001941
1942
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001943 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001944 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001945 }
1946 const XMLElement* ToElement() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001947 return ( ( _node == 0 ) ? 0 : _node->ToElement() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001948 }
1949 const XMLText* ToText() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001950 return ( ( _node == 0 ) ? 0 : _node->ToText() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001951 }
1952 const XMLUnknown* ToUnknown() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001953 return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001954 }
1955 const XMLDeclaration* ToDeclaration() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001956 return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001957 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08001958
Lee Thomason5cae8972012-01-24 18:03:07 -08001959private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001960 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08001961};
Lee Thomason6f381b72012-03-02 12:59:39 -08001962
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001963
1964/**
1965 Printing functionality. The XMLPrinter gives you more
1966 options than the XMLDocument::Print() method.
1967
1968 It can:
1969 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02001970 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001971 -# Print XML without a XMLDocument.
1972
1973 Print to Memory
1974
1975 @verbatim
1976 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001977 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02001978 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001979 @endverbatim
1980
1981 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001982
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001983 You provide the file pointer.
1984 @verbatim
1985 XMLPrinter printer( fp );
1986 doc.Print( &printer );
1987 @endverbatim
1988
1989 Print without a XMLDocument
1990
1991 When loading, an XML parser is very useful. However, sometimes
1992 when saving, it just gets in the way. The code is often set up
1993 for streaming, and constructing the DOM is just overhead.
1994
1995 The Printer supports the streaming case. The following code
1996 prints out a trivially simple XML file without ever creating
1997 an XML document.
1998
1999 @verbatim
2000 XMLPrinter printer( fp );
2001 printer.OpenElement( "foo" );
2002 printer.PushAttribute( "foo", "bar" );
2003 printer.CloseElement();
2004 @endverbatim
2005*/
PKEuS16ed47d2013-07-06 12:02:43 +02002006class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002007{
2008public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002009 /** Construct the printer. If the FILE* is specified,
2010 this will print to the FILE. Else it will print
2011 to memory, and the result is available in CStr().
2012 If 'compact' is set to true, then output is created
2013 with only required whitespace and newlines.
2014 */
PKEuS1bfb9542013-08-04 13:51:17 +02002015 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002016 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002017
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002018 /** If streaming, write the BOM and declaration. */
2019 void PushHeader( bool writeBOM, bool writeDeclaration );
2020 /** If streaming, start writing an element.
2021 The element must be closed with CloseElement()
2022 */
Lee Thomason256adb62014-04-06 14:41:46 -07002023 void OpenElement( const char* name, bool compactMode=false );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002024 /// If streaming, add an attribute to an open element.
2025 void PushAttribute( const char* name, const char* value );
2026 void PushAttribute( const char* name, int value );
2027 void PushAttribute( const char* name, unsigned value );
2028 void PushAttribute( const char* name, bool value );
2029 void PushAttribute( const char* name, double value );
2030 /// If streaming, close the Element.
Lee Thomason256adb62014-04-06 14:41:46 -07002031 virtual void CloseElement( bool compactMode=false );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002032
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002033 /// Add a text node.
2034 void PushText( const char* text, bool cdata=false );
2035 /// Add a text node from an integer.
2036 void PushText( int value );
2037 /// Add a text node from an unsigned.
2038 void PushText( unsigned value );
2039 /// Add a text node from a bool.
2040 void PushText( bool value );
2041 /// Add a text node from a float.
2042 void PushText( float value );
2043 /// Add a text node from a double.
2044 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07002045
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002046 /// Add a comment
2047 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002048
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002049 void PushDeclaration( const char* value );
2050 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002051
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002052 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
2053 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
2054 return true;
2055 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002056
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002057 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
2058 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002059
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002060 virtual bool Visit( const XMLText& text );
2061 virtual bool Visit( const XMLComment& comment );
2062 virtual bool Visit( const XMLDeclaration& declaration );
2063 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002064
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002065 /**
2066 If in print to memory mode, return a pointer to
2067 the XML file in memory.
2068 */
2069 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002070 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002071 }
2072 /**
2073 If in print to memory mode, return the size
2074 of the XML file in memory. (Note the size returned
2075 includes the terminating null.)
2076 */
2077 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002078 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002079 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002080 /**
2081 If in print to memory mode, reset the buffer to the
2082 beginning.
2083 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08002084 void ClearBuffer() {
2085 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002086 _buffer.Push(0);
2087 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002088
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002089protected:
Alexander Maid740b642014-05-20 22:04:42 +02002090 virtual bool CompactMode( const XMLElement& ) { return _compactMode; }
Uli Kusterer5d1d27e2014-02-20 11:50:22 +01002091
Lee Thomasonc18eb232014-02-21 17:31:17 -08002092 /** Prints out the space before an element. You may override to change
2093 the space and tabs used. A PrintSpace() override should call Print().
2094 */
2095 virtual void PrintSpace( int depth );
2096 void Print( const char* format, ... );
2097
Dmitry-Mea092bc12014-12-23 17:57:05 +03002098 void SealElementIfJustOpened();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002099 bool _elementJustOpened;
2100 DynArray< const char*, 10 > _stack;
2101
2102private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002103 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002104
Lee Thomason624d43f2012-10-12 10:58:48 -07002105 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01002106 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07002107 int _depth;
2108 int _textDepth;
2109 bool _processEntities;
Lee Thomasonc18eb232014-02-21 17:31:17 -08002110 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002111
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002112 enum {
2113 ENTITY_RANGE = 64,
2114 BUF_SIZE = 200
2115 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002116 bool _entityFlag[ENTITY_RANGE];
2117 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002118
Lee Thomason624d43f2012-10-12 10:58:48 -07002119 DynArray< char, 20 > _buffer;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002120};
2121
2122
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002123} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002124
PKEuS95060352013-07-26 10:42:44 +02002125#if defined(_MSC_VER)
2126# pragma warning(pop)
2127#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002128
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002129#endif // TINYXML2_INCLUDED