blob: 279b77859861316e5bb339e241cc2a5a7569fa31 [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 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700235 EnsureCapacity( _size+1 );
236 _mem[_size++] = t;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700237 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800238
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700239 T* PushArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700240 EnsureCapacity( _size+count );
241 T* ret = &_mem[_size];
242 _size += count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700243 return ret;
244 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700245
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700246 T Pop() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700247 return _mem[--_size];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700248 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700249
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700250 void PopArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700251 TIXMLASSERT( _size >= count );
252 _size -= count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700253 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800254
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700255 bool Empty() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700256 return _size == 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700257 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700258
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700259 T& operator[](int i) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700260 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700261 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700262 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700263
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700264 const T& operator[](int i) const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700265 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700266 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700267 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700268
Lee Thomasonf07b9522014-10-30 13:25:12 -0700269 const T& PeekTop() const {
Dennis Jenkins59c75d32013-10-08 13:10:07 -0500270 TIXMLASSERT( _size > 0 );
271 return _mem[ _size - 1];
272 }
273
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700274 int Size() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700275 return _size;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700276 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700277
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700278 int Capacity() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700279 return _allocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700280 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700281
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700282 const T* Mem() const {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700283 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700284 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700285
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700286 T* Mem() {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700287 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700288 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800289
Lee Thomason2c85a712012-01-31 08:24:24 -0800290private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700291 void EnsureCapacity( int cap ) {
Dmitry-Me9fae8692014-12-22 17:59:59 +0300292 TIXMLASSERT( cap > 0 );
Lee Thomason624d43f2012-10-12 10:58:48 -0700293 if ( cap > _allocated ) {
Dmitry-Me9fae8692014-12-22 17:59:59 +0300294 TIXMLASSERT( cap <= INT_MAX / 2 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700295 int newAllocated = cap * 2;
296 T* newMem = new T[newAllocated];
Lee Thomason624d43f2012-10-12 10:58:48 -0700297 memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
298 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700299 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700300 }
Lee Thomasoned5c8792012-10-12 10:09:48 -0700301 _mem = newMem;
Lee Thomason624d43f2012-10-12 10:58:48 -0700302 _allocated = newAllocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700303 }
304 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800305
Lee Thomason624d43f2012-10-12 10:58:48 -0700306 T* _mem;
307 T _pool[INIT];
308 int _allocated; // objects allocated
309 int _size; // number objects in use
Lee Thomason2c85a712012-01-31 08:24:24 -0800310};
311
Lee Thomason50adb4c2012-02-13 15:07:09 -0800312
U-Stream\Leeae25a442012-02-17 17:48:16 -0800313/*
Thomas Roß08bdf502012-05-12 14:21:23 +0200314 Parent virtual class of a pool for fast allocation
U-Stream\Leeae25a442012-02-17 17:48:16 -0800315 and deallocation of objects.
316*/
PKEuS95060352013-07-26 10:42:44 +0200317class MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800318{
319public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700320 MemPool() {}
321 virtual ~MemPool() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800322
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700323 virtual int ItemSize() const = 0;
324 virtual void* Alloc() = 0;
325 virtual void Free( void* ) = 0;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800326 virtual void SetTracked() = 0;
Lee Thomasonf07b9522014-10-30 13:25:12 -0700327 virtual void Clear() = 0;
Lee Thomasond1983222012-02-06 08:41:24 -0800328};
329
Lee Thomason50adb4c2012-02-13 15:07:09 -0800330
U-Stream\Leeae25a442012-02-17 17:48:16 -0800331/*
332 Template child class to create pools of the correct type.
333*/
Lee Thomasond1983222012-02-06 08:41:24 -0800334template< int SIZE >
PKEuS95060352013-07-26 10:42:44 +0200335class MemPoolT : public MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800336{
337public:
Lee Thomason5b0a6772012-11-19 13:54:42 -0800338 MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700339 ~MemPoolT() {
Lee Thomasonf07b9522014-10-30 13:25:12 -0700340 Clear();
341 }
342
343 void Clear() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700344 // Delete the blocks.
Lee Thomasonf07b9522014-10-30 13:25:12 -0700345 while( !_blockPtrs.Empty()) {
346 Block* b = _blockPtrs.Pop();
347 delete b;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700348 }
Lee Thomasonf07b9522014-10-30 13:25:12 -0700349 _root = 0;
350 _currentAllocs = 0;
351 _nAllocs = 0;
352 _maxAllocs = 0;
353 _nUntracked = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700354 }
Lee Thomasond1983222012-02-06 08:41:24 -0800355
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700356 virtual int ItemSize() const {
357 return SIZE;
358 }
359 int CurrentAllocs() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700360 return _currentAllocs;
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 void* Alloc() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700364 if ( !_root ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700365 // Need a new block.
366 Block* block = new Block();
Lee Thomason624d43f2012-10-12 10:58:48 -0700367 _blockPtrs.Push( block );
Lee Thomasond1983222012-02-06 08:41:24 -0800368
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700369 for( int i=0; i<COUNT-1; ++i ) {
370 block->chunk[i].next = &block->chunk[i+1];
371 }
372 block->chunk[COUNT-1].next = 0;
Lee Thomason624d43f2012-10-12 10:58:48 -0700373 _root = block->chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700374 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700375 void* result = _root;
376 _root = _root->next;
Lee Thomason455c9d42012-02-06 09:14:14 -0800377
Lee Thomason624d43f2012-10-12 10:58:48 -0700378 ++_currentAllocs;
379 if ( _currentAllocs > _maxAllocs ) {
380 _maxAllocs = _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700381 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700382 _nAllocs++;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800383 _nUntracked++;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700384 return result;
385 }
Lee Thomasonf07b9522014-10-30 13:25:12 -0700386
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700387 virtual void Free( void* mem ) {
388 if ( !mem ) {
389 return;
390 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700391 --_currentAllocs;
Dmitry-Me56571762014-08-15 11:03:47 +0400392 Chunk* chunk = static_cast<Chunk*>( mem );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700393#ifdef DEBUG
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700394 memset( chunk, 0xfe, sizeof(Chunk) );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700395#endif
Lee Thomason624d43f2012-10-12 10:58:48 -0700396 chunk->next = _root;
397 _root = chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700398 }
399 void Trace( const char* name ) {
400 printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
Lee Thomason624d43f2012-10-12 10:58:48 -0700401 name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700402 }
Lee Thomasond1983222012-02-06 08:41:24 -0800403
Lee Thomason5b0a6772012-11-19 13:54:42 -0800404 void SetTracked() {
405 _nUntracked--;
406 }
407
408 int Untracked() const {
409 return _nUntracked;
410 }
411
Lee Thomason (grinliz)ac83b4e2013-02-01 09:02:34 -0800412 // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
413 // The test file is large, 170k.
414 // Release: VS2010 gcc(no opt)
415 // 1k: 4000
416 // 2k: 4000
417 // 4k: 3900 21000
418 // 16k: 5200
419 // 32k: 4300
420 // 64k: 4000 21000
421 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 +0200422
Lee Thomasond1983222012-02-06 08:41:24 -0800423private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700424 union Chunk {
Lee Thomason624d43f2012-10-12 10:58:48 -0700425 Chunk* next;
426 char mem[SIZE];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700427 };
428 struct Block {
Lee Thomason (grinliz)856da212012-10-19 09:08:15 -0700429 Chunk chunk[COUNT];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700430 };
Lee Thomason624d43f2012-10-12 10:58:48 -0700431 DynArray< Block*, 10 > _blockPtrs;
432 Chunk* _root;
Lee Thomason455c9d42012-02-06 09:14:14 -0800433
Lee Thomason624d43f2012-10-12 10:58:48 -0700434 int _currentAllocs;
435 int _nAllocs;
436 int _maxAllocs;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800437 int _nUntracked;
Lee Thomasond1983222012-02-06 08:41:24 -0800438};
439
Lee Thomason2c85a712012-01-31 08:24:24 -0800440
Lee Thomason56bdd022012-02-09 18:16:58 -0800441
442/**
443 Implements the interface to the "Visitor pattern" (see the Accept() method.)
444 If you call the Accept() method, it requires being passed a XMLVisitor
445 class to handle callbacks. For nodes that contain other nodes (Document, Element)
Thomas Roß08bdf502012-05-12 14:21:23 +0200446 you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
Lee Thomason56bdd022012-02-09 18:16:58 -0800447 are simply called with Visit().
448
449 If you return 'true' from a Visit method, recursive parsing will continue. If you return
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700450 false, <b>no children of this node or its siblings</b> will be visited.
Lee Thomason56bdd022012-02-09 18:16:58 -0800451
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700452 All flavors of Visit methods have a default implementation that returns 'true' (continue
Lee Thomason56bdd022012-02-09 18:16:58 -0800453 visiting). You need to only override methods that are interesting to you.
454
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600455 Generally Accept() is called on the XMLDocument, although all nodes support visiting.
Lee Thomason56bdd022012-02-09 18:16:58 -0800456
457 You should never change the document from a callback.
458
459 @sa XMLNode::Accept()
460*/
PKEuS16ed47d2013-07-06 12:02:43 +0200461class TINYXML2_LIB XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800462{
463public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700464 virtual ~XMLVisitor() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800465
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700466 /// Visit a document.
467 virtual bool VisitEnter( const XMLDocument& /*doc*/ ) {
468 return true;
469 }
470 /// Visit a document.
471 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
472 return true;
473 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800474
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700475 /// Visit an element.
476 virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ ) {
477 return true;
478 }
479 /// Visit an element.
480 virtual bool VisitExit( const XMLElement& /*element*/ ) {
481 return true;
482 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800483
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700484 /// Visit a declaration.
485 virtual bool Visit( const XMLDeclaration& /*declaration*/ ) {
486 return true;
487 }
488 /// Visit a text node.
489 virtual bool Visit( const XMLText& /*text*/ ) {
490 return true;
491 }
492 /// Visit a comment node.
493 virtual bool Visit( const XMLComment& /*comment*/ ) {
494 return true;
495 }
496 /// Visit an unknown node.
497 virtual bool Visit( const XMLUnknown& /*unknown*/ ) {
498 return true;
499 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800500};
501
Dmitry-Me66d2a842014-11-08 15:24:52 +0300502// WARNING: must match XMLDocument::_errorNames[]
numatrumpetbb5ffac2014-09-06 22:56:46 +0900503enum XMLError {
numatrumpetcd8550c2014-09-08 16:59:39 +0900504 XML_SUCCESS = 0,
505 XML_NO_ERROR = 0,
506 XML_NO_ATTRIBUTE,
507 XML_WRONG_ATTRIBUTE_TYPE,
508 XML_ERROR_FILE_NOT_FOUND,
509 XML_ERROR_FILE_COULD_NOT_BE_OPENED,
510 XML_ERROR_FILE_READ_ERROR,
511 XML_ERROR_ELEMENT_MISMATCH,
512 XML_ERROR_PARSING_ELEMENT,
513 XML_ERROR_PARSING_ATTRIBUTE,
514 XML_ERROR_IDENTIFYING_TAG,
515 XML_ERROR_PARSING_TEXT,
516 XML_ERROR_PARSING_CDATA,
517 XML_ERROR_PARSING_COMMENT,
518 XML_ERROR_PARSING_DECLARATION,
519 XML_ERROR_PARSING_UNKNOWN,
520 XML_ERROR_EMPTY_DOCUMENT,
521 XML_ERROR_MISMATCHED_ELEMENT,
522 XML_ERROR_PARSING,
523 XML_CAN_NOT_CONVERT_TEXT,
Lee Thomason331596e2014-09-11 14:56:43 -0700524 XML_NO_TEXT_NODE,
525
526 XML_ERROR_COUNT
numatrumpetbb5ffac2014-09-06 22:56:46 +0900527};
numatrumpetbb5ffac2014-09-06 22:56:46 +0900528
numatrumpetcd8550c2014-09-08 16:59:39 +0900529
U-Stream\Leeae25a442012-02-17 17:48:16 -0800530/*
531 Utility functionality.
532*/
Lee Thomason56bdd022012-02-09 18:16:58 -0800533class XMLUtil
534{
Lee Thomasond1983222012-02-06 08:41:24 -0800535public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700536 static const char* SkipWhiteSpace( const char* p ) {
Dmitry-Mebb836dc2014-12-24 11:54:05 +0300537 TIXMLASSERT( p );
Dmitry-Mefa20b222014-10-31 12:53:04 +0300538 while( IsWhiteSpace(*p) ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700539 ++p;
540 }
Dmitry-Mebb836dc2014-12-24 11:54:05 +0300541 TIXMLASSERT( p );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700542 return p;
543 }
544 static char* SkipWhiteSpace( char* p ) {
Dmitry-Me9de541f2014-09-24 14:21:36 +0400545 return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p) ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700546 }
Dmitry-Mefa20b222014-10-31 12:53:04 +0300547
548 // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
549 // correct, but simple, and usually works.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700550 static bool IsWhiteSpace( char p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100551 return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700552 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200553
554 inline static bool IsNameStartChar( unsigned char ch ) {
555 return ( ( ch < 128 ) ? isalpha( ch ) : 1 )
556 || ch == ':'
557 || ch == '_';
558 }
559
560 inline static bool IsNameChar( unsigned char ch ) {
561 return IsNameStartChar( ch )
562 || isdigit( ch )
563 || ch == '.'
564 || ch == '-';
565 }
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800566
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700567 inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700568 if ( p == q ) {
569 return true;
570 }
Dmitry-Me5b4a5162014-12-23 17:36:28 +0300571 int n = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700572 while( *p && *q && *p == *q && n<nChar ) {
573 ++p;
574 ++q;
575 ++n;
576 }
577 if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
578 return true;
579 }
580 return false;
581 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200582
Dmitry-Me72bb0ec2014-09-24 16:14:24 +0400583 inline static bool IsUTF8Continuation( const char p ) {
584 return ( p & 0x80 ) != 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700585 }
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800586
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700587 static const char* ReadBOM( const char* p, bool* hasBOM );
588 // p is the starting location,
589 // the UTF-8 value of the entity will be placed in value, and length filled in.
590 static const char* GetCharacterRef( const char* p, char* value, int* length );
591 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
Lee Thomason21be8822012-07-15 17:27:22 -0700592
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700593 // converts primitive types to strings
594 static void ToStr( int v, char* buffer, int bufferSize );
595 static void ToStr( unsigned v, char* buffer, int bufferSize );
596 static void ToStr( bool v, char* buffer, int bufferSize );
597 static void ToStr( float v, char* buffer, int bufferSize );
598 static void ToStr( double v, char* buffer, int bufferSize );
Lee Thomason21be8822012-07-15 17:27:22 -0700599
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700600 // converts strings to primitive types
601 static bool ToInt( const char* str, int* value );
602 static bool ToUnsigned( const char* str, unsigned* value );
603 static bool ToBool( const char* str, bool* value );
604 static bool ToFloat( const char* str, float* value );
605 static bool ToDouble( const char* str, double* value );
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800606};
607
Lee Thomason5cae8972012-01-24 18:03:07 -0800608
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800609/** XMLNode is a base class for every object that is in the
610 XML Document Object Model (DOM), except XMLAttributes.
611 Nodes have siblings, a parent, and children which can
612 be navigated. A node is always in a XMLDocument.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700613 The type of a XMLNode can be queried, and it can
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800614 be cast to its more defined type.
615
Thomas Roß08bdf502012-05-12 14:21:23 +0200616 A XMLDocument allocates memory for all its Nodes.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800617 When the XMLDocument gets deleted, all its Nodes
618 will also be deleted.
619
620 @verbatim
621 A Document can contain: Element (container or leaf)
622 Comment (leaf)
623 Unknown (leaf)
624 Declaration( leaf )
625
626 An Element can contain: Element (container or leaf)
627 Text (leaf)
628 Attributes (not on tree)
629 Comment (leaf)
630 Unknown (leaf)
631
632 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800633*/
PKEuS16ed47d2013-07-06 12:02:43 +0200634class TINYXML2_LIB XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800635{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700636 friend class XMLDocument;
637 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800638public:
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800639
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700640 /// Get the XMLDocument that owns this XMLNode.
641 const XMLDocument* GetDocument() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700642 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700643 }
644 /// Get the XMLDocument that owns this XMLNode.
645 XMLDocument* GetDocument() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700646 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700647 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800648
Lee Thomason2fa81722012-11-09 12:37:46 -0800649 /// Safely cast to an Element, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700650 virtual XMLElement* ToElement() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100651 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700652 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800653 /// Safely cast to Text, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700654 virtual XMLText* ToText() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100655 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700656 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800657 /// Safely cast to a Comment, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700658 virtual XMLComment* ToComment() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100659 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700660 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800661 /// Safely cast to a Document, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700662 virtual XMLDocument* ToDocument() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100663 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700664 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800665 /// Safely cast to a Declaration, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700666 virtual XMLDeclaration* ToDeclaration() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100667 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700668 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800669 /// Safely cast to an Unknown, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700670 virtual XMLUnknown* ToUnknown() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100671 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700672 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800673
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700674 virtual const XMLElement* ToElement() const {
675 return 0;
676 }
677 virtual const XMLText* ToText() const {
678 return 0;
679 }
680 virtual const XMLComment* ToComment() const {
681 return 0;
682 }
683 virtual const XMLDocument* ToDocument() const {
684 return 0;
685 }
686 virtual const XMLDeclaration* ToDeclaration() const {
687 return 0;
688 }
689 virtual const XMLUnknown* ToUnknown() const {
690 return 0;
691 }
Lee Thomason751da522012-02-10 08:50:51 -0800692
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700693 /** The meaning of 'value' changes for the specific type.
694 @verbatim
695 Document: empty
696 Element: name of the element
697 Comment: the comment text
698 Unknown: the tag contents
699 Text: the text string
700 @endverbatim
701 */
Michael Daumling21626882013-10-22 17:03:37 +0200702 const char* Value() const;
MortenMacFly4ee49f12013-01-14 20:03:14 +0100703
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700704 /** Set the Value of an XML node.
705 @sa Value()
706 */
707 void SetValue( const char* val, bool staticMem=false );
Lee Thomason2c85a712012-01-31 08:24:24 -0800708
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700709 /// Get the parent of this node on the DOM.
710 const XMLNode* Parent() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700711 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700712 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100713
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700714 XMLNode* Parent() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700715 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700716 }
Lee Thomason751da522012-02-10 08:50:51 -0800717
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700718 /// Returns true if this node has no children.
719 bool NoChildren() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700720 return !_firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700721 }
Lee Thomason751da522012-02-10 08:50:51 -0800722
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700723 /// Get the first child node, or null if none exists.
724 const XMLNode* FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700725 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700726 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100727
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700728 XMLNode* FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700729 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700730 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100731
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700732 /** Get the first child element, or optionally the first child
733 element with the specified name.
734 */
735 const XMLElement* FirstChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700736
737 XMLElement* FirstChildElement( const char* value=0 ) {
738 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700739 }
Lee Thomason3f57d272012-01-11 15:30:03 -0800740
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700741 /// Get the last child node, or null if none exists.
742 const XMLNode* LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700743 return _lastChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700744 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700745
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700746 XMLNode* LastChild() {
747 return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
748 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800749
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700750 /** Get the last child element or optionally the last child
751 element with the specified name.
752 */
753 const XMLElement* LastChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700754
755 XMLElement* LastChildElement( const char* value=0 ) {
756 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700757 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700758
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700759 /// Get the previous (left) sibling node of this node.
760 const XMLNode* PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700761 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700762 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700763
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700764 XMLNode* PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700765 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700766 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800767
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700768 /// Get the previous (left) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700769 const XMLElement* PreviousSiblingElement( const char* value=0 ) const ;
Lee Thomason624d43f2012-10-12 10:58:48 -0700770
771 XMLElement* PreviousSiblingElement( const char* value=0 ) {
772 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700773 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700774
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700775 /// Get the next (right) sibling node of this node.
776 const XMLNode* NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700777 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700778 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700779
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700780 XMLNode* NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700781 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700782 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700783
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700784 /// Get the next (right) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700785 const XMLElement* NextSiblingElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700786
787 XMLElement* NextSiblingElement( const char* value=0 ) {
788 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700789 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800790
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700791 /**
792 Add a child node as the last (right) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200793 If the child node is already part of the document,
794 it is moved from its old location to the new location.
795 Returns the addThis argument or 0 if the node does not
796 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700797 */
798 XMLNode* InsertEndChild( XMLNode* addThis );
Lee Thomason618dbf82012-02-28 12:34:27 -0800799
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700800 XMLNode* LinkEndChild( XMLNode* addThis ) {
801 return InsertEndChild( addThis );
802 }
803 /**
804 Add a child node as the first (left) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200805 If the child node is already part of the document,
806 it is moved from its old location to the new location.
807 Returns the addThis argument or 0 if the node does not
808 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700809 */
810 XMLNode* InsertFirstChild( XMLNode* addThis );
811 /**
812 Add a node after the specified child node.
Michael Daumlinged523282013-10-23 07:47:29 +0200813 If the child node is already part of the document,
814 it is moved from its old location to the new location.
815 Returns the addThis argument or 0 if the afterThis node
816 is not a child of this node, or if the node does not
817 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700818 */
819 XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700820
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700821 /**
822 Delete all the children of this node.
823 */
824 void DeleteChildren();
U-Stream\Leeae25a442012-02-17 17:48:16 -0800825
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700826 /**
827 Delete a child of this node.
828 */
829 void DeleteChild( XMLNode* node );
Lee Thomason56bdd022012-02-09 18:16:58 -0800830
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700831 /**
832 Make a copy of this node, but not its children.
833 You may pass in a Document pointer that will be
834 the owner of the new Node. If the 'document' is
835 null, then the node returned will be allocated
836 from the current Document. (this->GetDocument())
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800837
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700838 Note: if called on a XMLDocument, this will return null.
839 */
840 virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800841
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700842 /**
843 Test if 2 nodes are the same, but don't test children.
844 The 2 nodes do not need to be in the same Document.
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800845
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700846 Note: if called on a XMLDocument, this will return false.
847 */
848 virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800849
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600850 /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700851 XML tree will be conditionally visited and the host will be called back
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600852 via the XMLVisitor interface.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800853
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600854 This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
855 the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700856 interface versus any other.)
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800857
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700858 The interface has been based on ideas from:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800859
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700860 - http://www.saxproject.org/
861 - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800862
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700863 Which are both good references for "visiting".
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800864
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700865 An example of using Accept():
866 @verbatim
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600867 XMLPrinter printer;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700868 tinyxmlDoc.Accept( &printer );
869 const char* xmlcstr = printer.CStr();
870 @endverbatim
871 */
872 virtual bool Accept( XMLVisitor* visitor ) const = 0;
Lee Thomason56bdd022012-02-09 18:16:58 -0800873
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700874 // internal
875 virtual char* ParseDeep( char*, StrPair* );
Lee Thomason3f57d272012-01-11 15:30:03 -0800876
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800877protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700878 XMLNode( XMLDocument* );
879 virtual ~XMLNode();
880 XMLNode( const XMLNode& ); // not supported
881 XMLNode& operator=( const XMLNode& ); // not supported
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700882
Lee Thomason624d43f2012-10-12 10:58:48 -0700883 XMLDocument* _document;
884 XMLNode* _parent;
885 mutable StrPair _value;
Lee Thomason3f57d272012-01-11 15:30:03 -0800886
Lee Thomason624d43f2012-10-12 10:58:48 -0700887 XMLNode* _firstChild;
888 XMLNode* _lastChild;
Lee Thomason3f57d272012-01-11 15:30:03 -0800889
Lee Thomason624d43f2012-10-12 10:58:48 -0700890 XMLNode* _prev;
891 XMLNode* _next;
Lee Thomason3f57d272012-01-11 15:30:03 -0800892
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800893private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700894 MemPool* _memPool;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700895 void Unlink( XMLNode* child );
Dmitry-Mee3225b12014-09-03 11:03:11 +0400896 static void DeleteNode( XMLNode* node );
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800897};
898
899
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800900/** XML text.
901
902 Note that a text node can have child element nodes, for example:
903 @verbatim
904 <root>This is <b>bold</b></root>
905 @endverbatim
906
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700907 A text node can have 2 ways to output the next. "normal" output
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800908 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 -0700909 you generally want to leave it alone, but you can change the output mode with
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600910 SetCData() and query it with CData().
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800911*/
PKEuS16ed47d2013-07-06 12:02:43 +0200912class TINYXML2_LIB XMLText : public XMLNode
Lee Thomason5492a1c2012-01-23 15:32:10 -0800913{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700914 friend class XMLBase;
915 friend class XMLDocument;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800916public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700917 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -0800918
Lee Thomason624d43f2012-10-12 10:58:48 -0700919 virtual XMLText* ToText() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700920 return this;
921 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700922 virtual const XMLText* ToText() const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700923 return this;
924 }
Lee Thomason5492a1c2012-01-23 15:32:10 -0800925
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700926 /// Declare whether this should be CDATA or standard text.
Lee Thomason624d43f2012-10-12 10:58:48 -0700927 void SetCData( bool isCData ) {
928 _isCData = isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700929 }
930 /// Returns true if this is a CDATA text element.
931 bool CData() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700932 return _isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700933 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800934
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700935 char* ParseDeep( char*, StrPair* endTag );
936 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
937 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800938
Lee Thomason5492a1c2012-01-23 15:32:10 -0800939protected:
Lee Thomason624d43f2012-10-12 10:58:48 -0700940 XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700941 virtual ~XMLText() {}
942 XMLText( const XMLText& ); // not supported
943 XMLText& operator=( const XMLText& ); // not supported
Lee Thomason5492a1c2012-01-23 15:32:10 -0800944
945private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700946 bool _isCData;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800947};
948
949
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800950/** An XML Comment. */
PKEuS16ed47d2013-07-06 12:02:43 +0200951class TINYXML2_LIB XMLComment : public XMLNode
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800952{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700953 friend class XMLDocument;
Lee Thomason3f57d272012-01-11 15:30:03 -0800954public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700955 virtual XMLComment* ToComment() {
956 return this;
957 }
958 virtual const XMLComment* ToComment() const {
959 return this;
960 }
Lee Thomasonce0763e2012-01-11 15:43:54 -0800961
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700962 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800963
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700964 char* ParseDeep( char*, StrPair* endTag );
965 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
966 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomasonce0763e2012-01-11 15:43:54 -0800967
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800968protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700969 XMLComment( XMLDocument* doc );
970 virtual ~XMLComment();
971 XMLComment( const XMLComment& ); // not supported
972 XMLComment& operator=( const XMLComment& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800973
Lee Thomason3f57d272012-01-11 15:30:03 -0800974private:
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800975};
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800976
977
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800978/** In correct XML the declaration is the first entry in the file.
979 @verbatim
980 <?xml version="1.0" standalone="yes"?>
981 @endverbatim
982
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600983 TinyXML-2 will happily read or write files without a declaration,
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800984 however.
985
986 The text of the declaration isn't interpreted. It is parsed
987 and written as a string.
988*/
PKEuS16ed47d2013-07-06 12:02:43 +0200989class TINYXML2_LIB XMLDeclaration : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -0800990{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700991 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -0800992public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700993 virtual XMLDeclaration* ToDeclaration() {
994 return this;
995 }
996 virtual const XMLDeclaration* ToDeclaration() const {
997 return this;
998 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800999
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001000 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001001
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001002 char* ParseDeep( char*, StrPair* endTag );
1003 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1004 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001005
1006protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001007 XMLDeclaration( XMLDocument* doc );
1008 virtual ~XMLDeclaration();
1009 XMLDeclaration( const XMLDeclaration& ); // not supported
1010 XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001011};
1012
1013
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001014/** Any tag that TinyXML-2 doesn't recognize is saved as an
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001015 unknown. It is a tag of text, but should not be modified.
1016 It will be written back to the XML, unchanged, when the file
1017 is saved.
1018
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001019 DTD tags get thrown into XMLUnknowns.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001020*/
PKEuS16ed47d2013-07-06 12:02:43 +02001021class TINYXML2_LIB XMLUnknown : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -08001022{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001023 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -08001024public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001025 virtual XMLUnknown* ToUnknown() {
1026 return this;
1027 }
1028 virtual const XMLUnknown* ToUnknown() const {
1029 return this;
1030 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001031
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001032 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001033
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001034 char* ParseDeep( char*, StrPair* endTag );
1035 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1036 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001037
1038protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001039 XMLUnknown( XMLDocument* doc );
1040 virtual ~XMLUnknown();
1041 XMLUnknown( const XMLUnknown& ); // not supported
1042 XMLUnknown& operator=( const XMLUnknown& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001043};
1044
1045
Lee Thomason1ff38e02012-02-14 18:18:16 -08001046
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001047/** An attribute is a name-value pair. Elements have an arbitrary
1048 number of attributes, each with a unique name.
1049
1050 @note The attributes are not XMLNodes. You may only query the
1051 Next() attribute in a list.
1052*/
PKEuS16ed47d2013-07-06 12:02:43 +02001053class TINYXML2_LIB XMLAttribute
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001054{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001055 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001056public:
Lee Thomason2fa81722012-11-09 12:37:46 -08001057 /// The name of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001058 const char* Name() const;
1059
Lee Thomason2fa81722012-11-09 12:37:46 -08001060 /// The value of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001061 const char* Value() const;
1062
Lee Thomason2fa81722012-11-09 12:37:46 -08001063 /// The next attribute in the list.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001064 const XMLAttribute* Next() const {
MortenMacFly4ee49f12013-01-14 20:03:14 +01001065 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001066 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001067
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001068 /** IntValue interprets the attribute as an integer, and returns the value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001069 If the value isn't an integer, 0 will be returned. There is no error checking;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001070 use QueryIntValue() if you need error checking.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001071 */
1072 int IntValue() const {
1073 int i=0;
1074 QueryIntValue( &i );
1075 return i;
1076 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001077 /// Query as an unsigned integer. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001078 unsigned UnsignedValue() const {
1079 unsigned i=0;
1080 QueryUnsignedValue( &i );
1081 return i;
1082 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001083 /// Query as a boolean. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001084 bool BoolValue() const {
1085 bool b=false;
1086 QueryBoolValue( &b );
1087 return b;
1088 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001089 /// Query as a double. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001090 double DoubleValue() const {
1091 double d=0;
1092 QueryDoubleValue( &d );
1093 return d;
1094 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001095 /// Query as a float. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001096 float FloatValue() const {
1097 float f=0;
1098 QueryFloatValue( &f );
1099 return f;
1100 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001101
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001102 /** QueryIntValue interprets the attribute as an integer, and returns the value
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001103 in the provided parameter. The function will return XML_NO_ERROR on success,
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001104 and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
1105 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001106 XMLError QueryIntValue( int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001107 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001108 XMLError QueryUnsignedValue( unsigned int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001109 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001110 XMLError QueryBoolValue( bool* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001111 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001112 XMLError QueryDoubleValue( double* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001113 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001114 XMLError QueryFloatValue( float* value ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -08001115
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001116 /// Set the attribute to a string value.
1117 void SetAttribute( const char* value );
1118 /// Set the attribute to value.
1119 void SetAttribute( int value );
1120 /// Set the attribute to value.
1121 void SetAttribute( unsigned value );
1122 /// Set the attribute to value.
1123 void SetAttribute( bool value );
1124 /// Set the attribute to value.
1125 void SetAttribute( double value );
1126 /// Set the attribute to value.
1127 void SetAttribute( float value );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001128
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001129private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001130 enum { BUF_SIZE = 200 };
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001131
Thomas Roß61892312013-05-12 14:07:38 +02001132 XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001133 virtual ~XMLAttribute() {}
Lee Thomason624d43f2012-10-12 10:58:48 -07001134
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001135 XMLAttribute( const XMLAttribute& ); // not supported
1136 void operator=( const XMLAttribute& ); // not supported
1137 void SetName( const char* name );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001138
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001139 char* ParseDeep( char* p, bool processEntities );
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001140
Lee Thomason624d43f2012-10-12 10:58:48 -07001141 mutable StrPair _name;
1142 mutable StrPair _value;
1143 XMLAttribute* _next;
1144 MemPool* _memPool;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001145};
1146
1147
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001148/** The element is a container class. It has a value, the element name,
1149 and can contain other elements, text, comments, and unknowns.
1150 Elements also contain an arbitrary number of attributes.
1151*/
PKEuS16ed47d2013-07-06 12:02:43 +02001152class TINYXML2_LIB XMLElement : public XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001153{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001154 friend class XMLBase;
1155 friend class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001156public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001157 /// Get the name of an element (which is the Value() of the node.)
1158 const char* Name() const {
1159 return Value();
1160 }
1161 /// Set the name of the element.
1162 void SetName( const char* str, bool staticMem=false ) {
1163 SetValue( str, staticMem );
1164 }
Lee Thomason2c85a712012-01-31 08:24:24 -08001165
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001166 virtual XMLElement* ToElement() {
1167 return this;
1168 }
1169 virtual const XMLElement* ToElement() const {
1170 return this;
1171 }
1172 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001173
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001174 /** Given an attribute name, Attribute() returns the value
1175 for the attribute of that name, or null if none
1176 exists. For example:
Lee Thomason92258152012-03-24 13:05:39 -07001177
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001178 @verbatim
1179 const char* value = ele->Attribute( "foo" );
1180 @endverbatim
Lee Thomason92258152012-03-24 13:05:39 -07001181
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001182 The 'value' parameter is normally null. However, if specified,
1183 the attribute will only be returned if the 'name' and 'value'
1184 match. This allow you to write code:
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001185
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001186 @verbatim
1187 if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
1188 @endverbatim
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001189
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001190 rather than:
1191 @verbatim
1192 if ( ele->Attribute( "foo" ) ) {
1193 if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
1194 }
1195 @endverbatim
1196 */
1197 const char* Attribute( const char* name, const char* value=0 ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001198
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001199 /** Given an attribute name, IntAttribute() returns the value
1200 of the attribute interpreted as an integer. 0 will be
1201 returned if there is an error. For a method with error
1202 checking, see QueryIntAttribute()
1203 */
1204 int IntAttribute( const char* name ) const {
1205 int i=0;
1206 QueryIntAttribute( name, &i );
1207 return i;
1208 }
1209 /// See IntAttribute()
1210 unsigned UnsignedAttribute( const char* name ) const {
1211 unsigned i=0;
1212 QueryUnsignedAttribute( name, &i );
1213 return i;
1214 }
1215 /// See IntAttribute()
1216 bool BoolAttribute( const char* name ) const {
1217 bool b=false;
1218 QueryBoolAttribute( name, &b );
1219 return b;
1220 }
1221 /// See IntAttribute()
1222 double DoubleAttribute( const char* name ) const {
1223 double d=0;
1224 QueryDoubleAttribute( name, &d );
1225 return d;
1226 }
1227 /// See IntAttribute()
1228 float FloatAttribute( const char* name ) const {
1229 float f=0;
1230 QueryFloatAttribute( name, &f );
1231 return f;
1232 }
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001233
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001234 /** Given an attribute name, QueryIntAttribute() returns
1235 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1236 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1237 doesn't exist. If successful, the result of the conversion
1238 will be written to 'value'. If not successful, nothing will
1239 be written to 'value'. This allows you to provide default
1240 value:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001241
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001242 @verbatim
1243 int value = 10;
1244 QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1245 @endverbatim
1246 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001247 XMLError QueryIntAttribute( const char* name, int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001248 const XMLAttribute* a = FindAttribute( name );
1249 if ( !a ) {
1250 return XML_NO_ATTRIBUTE;
1251 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001252 return a->QueryIntValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001253 }
1254 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001255 XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001256 const XMLAttribute* a = FindAttribute( name );
1257 if ( !a ) {
1258 return XML_NO_ATTRIBUTE;
1259 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001260 return a->QueryUnsignedValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001261 }
1262 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001263 XMLError QueryBoolAttribute( const char* name, bool* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001264 const XMLAttribute* a = FindAttribute( name );
1265 if ( !a ) {
1266 return XML_NO_ATTRIBUTE;
1267 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001268 return a->QueryBoolValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001269 }
1270 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001271 XMLError QueryDoubleAttribute( const char* name, double* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001272 const XMLAttribute* a = FindAttribute( name );
1273 if ( !a ) {
1274 return XML_NO_ATTRIBUTE;
1275 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001276 return a->QueryDoubleValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001277 }
1278 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001279 XMLError QueryFloatAttribute( const char* name, float* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001280 const XMLAttribute* a = FindAttribute( name );
1281 if ( !a ) {
1282 return XML_NO_ATTRIBUTE;
1283 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001284 return a->QueryFloatValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001285 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001286
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001287
1288 /** Given an attribute name, QueryAttribute() returns
1289 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1290 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1291 doesn't exist. It is overloaded for the primitive types,
1292 and is a generally more convenient replacement of
1293 QueryIntAttribute() and related functions.
1294
1295 If successful, the result of the conversion
1296 will be written to 'value'. If not successful, nothing will
1297 be written to 'value'. This allows you to provide default
1298 value:
1299
1300 @verbatim
1301 int value = 10;
1302 QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1303 @endverbatim
1304 */
1305 int QueryAttribute( const char* name, int* value ) const {
1306 return QueryIntAttribute( name, value );
1307 }
1308
1309 int QueryAttribute( const char* name, unsigned int* value ) const {
1310 return QueryUnsignedAttribute( name, value );
1311 }
1312
1313 int QueryAttribute( const char* name, bool* value ) const {
1314 return QueryBoolAttribute( name, value );
1315 }
1316
1317 int QueryAttribute( const char* name, double* value ) const {
1318 return QueryDoubleAttribute( name, value );
1319 }
1320
1321 int QueryAttribute( const char* name, float* value ) const {
1322 return QueryFloatAttribute( name, value );
1323 }
1324
1325 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001326 void SetAttribute( const char* name, const char* value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001327 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001328 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001329 }
1330 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001331 void SetAttribute( const char* name, int value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001332 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001333 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001334 }
1335 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001336 void SetAttribute( const char* name, unsigned value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001337 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001338 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001339 }
1340 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001341 void SetAttribute( const char* name, bool value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001342 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001343 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001344 }
1345 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001346 void SetAttribute( const char* name, double value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001347 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001348 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001349 }
Lee Thomasonc3708cc2014-01-14 12:30:03 -08001350 /// Sets the named attribute to value.
1351 void SetAttribute( const char* name, float value ) {
1352 XMLAttribute* a = FindOrCreateAttribute( name );
1353 a->SetAttribute( value );
1354 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001355
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001356 /**
1357 Delete an attribute.
1358 */
1359 void DeleteAttribute( const char* name );
Lee Thomason751da522012-02-10 08:50:51 -08001360
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001361 /// Return the first attribute in the list.
1362 const XMLAttribute* FirstAttribute() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001363 return _rootAttribute;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001364 }
1365 /// Query a specific attribute in the list.
1366 const XMLAttribute* FindAttribute( const char* name ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001367
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001368 /** Convenience function for easy access to the text inside an element. Although easy
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001369 and concise, GetText() is limited compared to getting the XMLText child
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001370 and accessing it directly.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001371
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001372 If the first child of 'this' is a XMLText, the GetText()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001373 returns the character string of the Text node, else null is returned.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001374
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001375 This is a convenient method for getting the text of simple contained text:
1376 @verbatim
1377 <foo>This is text</foo>
1378 const char* str = fooElement->GetText();
1379 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001380
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001381 'str' will be a pointer to "This is text".
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001382
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001383 Note that this function can be misleading. If the element foo was created from
1384 this XML:
1385 @verbatim
1386 <foo><b>This is text</b></foo>
1387 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001388
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001389 then the value of str would be null. The first child node isn't a text node, it is
1390 another element. From this XML:
1391 @verbatim
1392 <foo>This is <b>text</b></foo>
1393 @endverbatim
1394 GetText() will return "This is ".
1395 */
1396 const char* GetText() const;
Lee Thomason751da522012-02-10 08:50:51 -08001397
Uli Kusterer85fff5e2014-01-21 01:35:30 +01001398 /** Convenience function for easy access to the text inside an element. Although easy
1399 and concise, SetText() is limited compared to creating an XMLText child
1400 and mutating it directly.
1401
1402 If the first child of 'this' is a XMLText, SetText() sets its value to
1403 the given string, otherwise it will create a first child that is an XMLText.
1404
1405 This is a convenient method for setting the text of simple contained text:
1406 @verbatim
1407 <foo>This is text</foo>
1408 fooElement->SetText( "Hullaballoo!" );
1409 <foo>Hullaballoo!</foo>
1410 @endverbatim
1411
1412 Note that this function can be misleading. If the element foo was created from
1413 this XML:
1414 @verbatim
1415 <foo><b>This is text</b></foo>
1416 @endverbatim
1417
1418 then it will not change "This is text", but rather prefix it with a text element:
1419 @verbatim
1420 <foo>Hullaballoo!<b>This is text</b></foo>
1421 @endverbatim
1422
1423 For this XML:
1424 @verbatim
1425 <foo />
1426 @endverbatim
1427 SetText() will generate
1428 @verbatim
1429 <foo>Hullaballoo!</foo>
1430 @endverbatim
1431 */
Lee Thomason5bb2d802014-01-24 10:42:57 -08001432 void SetText( const char* inText );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001433 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001434 void SetText( int value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001435 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001436 void SetText( unsigned value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001437 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001438 void SetText( bool value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001439 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001440 void SetText( double value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001441 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001442 void SetText( float value );
Uli Kusterer8fe342a2014-01-21 01:12:47 +01001443
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001444 /**
1445 Convenience method to query the value of a child text node. This is probably best
1446 shown by example. Given you have a document is this form:
1447 @verbatim
1448 <point>
1449 <x>1</x>
1450 <y>1.4</y>
1451 </point>
1452 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001453
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001454 The QueryIntText() and similar functions provide a safe and easier way to get to the
1455 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001456
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001457 @verbatim
1458 int x = 0;
1459 float y = 0; // types of x and y are contrived for example
1460 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1461 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1462 xElement->QueryIntText( &x );
1463 yElement->QueryFloatText( &y );
1464 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001465
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001466 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1467 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 -07001468
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001469 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001470 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001471 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001472 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001473 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001474 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001475 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001476 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001477 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001478 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001479
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001480 // internal:
1481 enum {
1482 OPEN, // <foo>
1483 CLOSED, // <foo/>
1484 CLOSING // </foo>
1485 };
1486 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001487 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001488 }
1489 char* ParseDeep( char* p, StrPair* endTag );
1490 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1491 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001492
Lee Thomason50adb4c2012-02-13 15:07:09 -08001493private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001494 XMLElement( XMLDocument* doc );
1495 virtual ~XMLElement();
1496 XMLElement( const XMLElement& ); // not supported
1497 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001498
Dmitry-Me1227d512014-12-05 13:41:45 +03001499 XMLAttribute* FindAttribute( const char* name ) {
1500 return const_cast<XMLAttribute*>(const_cast<const XMLElement*>(this)->FindAttribute( name ));
1501 }
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001502 XMLAttribute* FindOrCreateAttribute( const char* name );
1503 //void LinkAttribute( XMLAttribute* attrib );
1504 char* ParseAttributes( char* p );
Dmitry-Mee3225b12014-09-03 11:03:11 +04001505 static void DeleteAttribute( XMLAttribute* attribute );
Lee Thomason67d61312012-01-24 16:01:51 -08001506
Lee Thomason5bb2d802014-01-24 10:42:57 -08001507 enum { BUF_SIZE = 200 };
Lee Thomason624d43f2012-10-12 10:58:48 -07001508 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001509 // The attribute list is ordered; there is no 'lastAttribute'
1510 // because the list needs to be scanned for dupes before adding
1511 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001512 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001513};
1514
1515
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001516enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001517 PRESERVE_WHITESPACE,
1518 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001519};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001520
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001521
1522/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001523 It can be saved, loaded, and printed to the screen.
1524 All Nodes are connected and allocated to a Document.
1525 If the Document is deleted, all its Nodes are also deleted.
1526*/
PKEuS16ed47d2013-07-06 12:02:43 +02001527class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001528{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001529 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001530public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001531 /// constructor
1532 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1533 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001534
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001535 virtual XMLDocument* ToDocument() {
1536 return this;
1537 }
1538 virtual const XMLDocument* ToDocument() const {
1539 return this;
1540 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001541
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001542 /**
1543 Parse an XML file from a character string.
1544 Returns XML_NO_ERROR (0) on success, or
1545 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001546
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001547 You may optionally pass in the 'nBytes', which is
1548 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001549 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001550 null terminated string.
1551 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001552 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001553
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001554 /**
1555 Load an XML file from disk.
1556 Returns XML_NO_ERROR (0) on success, or
1557 an errorID.
1558 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001559 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001560
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001561 /**
1562 Load an XML file from disk. You are responsible
Lee Thomasoncd011bc2014-12-17 10:41:34 -08001563 for providing and closing the FILE*.
1564
1565 NOTE: The file should be opened as binary ("rb")
1566 not text in order for TinyXML-2 to correctly
1567 do newline normalization.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001568
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001569 Returns XML_NO_ERROR (0) on success, or
1570 an errorID.
1571 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001572 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001573
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001574 /**
1575 Save the XML file to disk.
1576 Returns XML_NO_ERROR (0) on success, or
1577 an errorID.
1578 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001579 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001580
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001581 /**
1582 Save the XML file to disk. You are responsible
1583 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001584
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001585 Returns XML_NO_ERROR (0) on success, or
1586 an errorID.
1587 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001588 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001589
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001590 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001591 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001592 }
1593 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001594 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001595 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001596
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001597 /**
1598 Returns true if this document has a leading Byte Order Mark of UTF8.
1599 */
1600 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001601 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001602 }
1603 /** Sets whether to write the BOM when writing the file.
1604 */
1605 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001606 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001607 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001608
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001609 /** Return the root element of DOM. Equivalent to FirstChildElement().
1610 To get the first node, use FirstChild().
1611 */
1612 XMLElement* RootElement() {
1613 return FirstChildElement();
1614 }
1615 const XMLElement* RootElement() const {
1616 return FirstChildElement();
1617 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001618
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001619 /** Print the Document. If the Printer is not provided, it will
1620 print to stdout. If you provide Printer, this can print to a file:
1621 @verbatim
1622 XMLPrinter printer( fp );
1623 doc.Print( &printer );
1624 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001625
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001626 Or you can use a printer to print to memory:
1627 @verbatim
1628 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001629 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001630 // printer.CStr() has a const char* to the XML
1631 @endverbatim
1632 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001633 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001634 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001635
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001636 /**
1637 Create a new Element associated with
1638 this Document. The memory for the Element
1639 is managed by the Document.
1640 */
1641 XMLElement* NewElement( const char* name );
1642 /**
1643 Create a new Comment associated with
1644 this Document. The memory for the Comment
1645 is managed by the Document.
1646 */
1647 XMLComment* NewComment( const char* comment );
1648 /**
1649 Create a new Text associated with
1650 this Document. The memory for the Text
1651 is managed by the Document.
1652 */
1653 XMLText* NewText( const char* text );
1654 /**
1655 Create a new Declaration associated with
1656 this Document. The memory for the object
1657 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001658
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001659 If the 'text' param is null, the standard
1660 declaration is used.:
1661 @verbatim
1662 <?xml version="1.0" encoding="UTF-8"?>
1663 @endverbatim
1664 */
1665 XMLDeclaration* NewDeclaration( const char* text=0 );
1666 /**
1667 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001668 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001669 is managed by the Document.
1670 */
1671 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001672
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001673 /**
1674 Delete a node associated with this document.
1675 It will be unlinked from the DOM.
1676 */
Lee Thomasoncd011bc2014-12-17 10:41:34 -08001677 void DeleteNode( XMLNode* node );
U-Stream\Leeae25a442012-02-17 17:48:16 -08001678
Lee Thomason2fa81722012-11-09 12:37:46 -08001679 void SetError( XMLError error, const char* str1, const char* str2 );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001680
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001681 /// Return true if there was an error parsing the document.
1682 bool Error() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001683 return _errorID != XML_NO_ERROR;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001684 }
1685 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001686 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001687 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001688 }
Lee Thomason331596e2014-09-11 14:56:43 -07001689 const char* ErrorName() const;
1690
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001691 /// Return a possibly helpful diagnostic location or string.
1692 const char* GetErrorStr1() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001693 return _errorStr1;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001694 }
1695 /// Return a possibly helpful secondary diagnostic location or string.
1696 const char* GetErrorStr2() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001697 return _errorStr2;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001698 }
1699 /// If there is an error, print it to stdout.
1700 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001701
1702 /// Clear the document, resetting it to the initial state.
1703 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001704
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001705 // internal
1706 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001707
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001708 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1709 return 0;
1710 }
1711 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1712 return false;
1713 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001714
Lee Thomason3f57d272012-01-11 15:30:03 -08001715private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001716 XMLDocument( const XMLDocument& ); // not supported
1717 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001718
Lee Thomason2fa81722012-11-09 12:37:46 -08001719 bool _writeBOM;
1720 bool _processEntities;
1721 XMLError _errorID;
1722 Whitespace _whitespace;
Lee Thomason624d43f2012-10-12 10:58:48 -07001723 const char* _errorStr1;
1724 const char* _errorStr2;
Lee Thomason2fa81722012-11-09 12:37:46 -08001725 char* _charBuffer;
Lee Thomasond1983222012-02-06 08:41:24 -08001726
Lee Thomason624d43f2012-10-12 10:58:48 -07001727 MemPoolT< sizeof(XMLElement) > _elementPool;
1728 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1729 MemPoolT< sizeof(XMLText) > _textPool;
1730 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason331596e2014-09-11 14:56:43 -07001731
1732 static const char* _errorNames[XML_ERROR_COUNT];
Dmitry-Me97476b72015-01-01 16:15:57 +03001733
1734 void Parse();
Lee Thomason5cae8972012-01-24 18:03:07 -08001735};
1736
Lee Thomason7c913cd2012-01-26 18:32:34 -08001737
Lee Thomason3ffdd392012-03-28 17:27:55 -07001738/**
1739 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001740 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001741 DOM structure. It is a separate utility class.
1742
1743 Take an example:
1744 @verbatim
1745 <Document>
1746 <Element attributeA = "valueA">
1747 <Child attributeB = "value1" />
1748 <Child attributeB = "value2" />
1749 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001750 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001751 @endverbatim
1752
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001753 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001754 easy to write a *lot* of code that looks like:
1755
1756 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001757 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001758 if ( root )
1759 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001760 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001761 if ( element )
1762 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001763 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001764 if ( child )
1765 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001766 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001767 if ( child2 )
1768 {
1769 // Finally do something useful.
1770 @endverbatim
1771
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001772 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001773 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001774 and correct to use:
1775
1776 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001777 XMLHandle docHandle( &document );
Dmitry-Mea317bd62014-12-08 10:35:37 +03001778 XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001779 if ( child2 )
1780 {
1781 // do something useful
1782 @endverbatim
1783
1784 Which is MUCH more concise and useful.
1785
1786 It is also safe to copy handles - internally they are nothing more than node pointers.
1787 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001788 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001789 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001790
1791 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001792*/
PKEuS16ed47d2013-07-06 12:02:43 +02001793class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001794{
1795public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001796 /// 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 -07001797 XMLHandle( XMLNode* node ) {
1798 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001799 }
1800 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001801 XMLHandle( XMLNode& node ) {
1802 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001803 }
1804 /// Copy constructor
1805 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001806 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001807 }
1808 /// Assignment
1809 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001810 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001811 return *this;
1812 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001813
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001814 /// Get the first child of this handle.
1815 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001816 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001817 }
1818 /// Get the first child element of this handle.
1819 XMLHandle FirstChildElement( const char* value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001820 return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001821 }
1822 /// Get the last child of this handle.
1823 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001824 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001825 }
1826 /// Get the last child element of this handle.
1827 XMLHandle LastChildElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001828 return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001829 }
1830 /// Get the previous sibling of this handle.
1831 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001832 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001833 }
1834 /// Get the previous sibling element of this handle.
1835 XMLHandle PreviousSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001836 return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001837 }
1838 /// Get the next sibling of this handle.
1839 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001840 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001841 }
1842 /// Get the next sibling element of this handle.
1843 XMLHandle NextSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001844 return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001845 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001846
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001847 /// Safe cast to XMLNode. This can return null.
1848 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001849 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001850 }
1851 /// Safe cast to XMLElement. This can return null.
1852 XMLElement* ToElement() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001853 return ( ( _node == 0 ) ? 0 : _node->ToElement() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001854 }
1855 /// Safe cast to XMLText. This can return null.
1856 XMLText* ToText() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001857 return ( ( _node == 0 ) ? 0 : _node->ToText() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001858 }
1859 /// Safe cast to XMLUnknown. This can return null.
1860 XMLUnknown* ToUnknown() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001861 return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001862 }
1863 /// Safe cast to XMLDeclaration. This can return null.
1864 XMLDeclaration* ToDeclaration() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001865 return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001866 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001867
1868private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001869 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001870};
1871
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001872
1873/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001874 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1875 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001876*/
PKEuS16ed47d2013-07-06 12:02:43 +02001877class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001878{
1879public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001880 XMLConstHandle( const XMLNode* node ) {
1881 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001882 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001883 XMLConstHandle( const XMLNode& node ) {
1884 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001885 }
1886 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001887 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001888 }
Lee Thomason8b899812012-04-04 15:58:16 -07001889
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001890 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001891 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001892 return *this;
1893 }
Lee Thomason8b899812012-04-04 15:58:16 -07001894
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001895 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001896 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001897 }
1898 const XMLConstHandle FirstChildElement( const char* value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001899 return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001900 }
1901 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001902 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001903 }
1904 const XMLConstHandle LastChildElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001905 return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001906 }
1907 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001908 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001909 }
1910 const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001911 return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001912 }
1913 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001914 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001915 }
1916 const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001917 return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001918 }
Lee Thomason8b899812012-04-04 15:58:16 -07001919
1920
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001921 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001922 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001923 }
1924 const XMLElement* ToElement() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001925 return ( ( _node == 0 ) ? 0 : _node->ToElement() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001926 }
1927 const XMLText* ToText() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001928 return ( ( _node == 0 ) ? 0 : _node->ToText() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001929 }
1930 const XMLUnknown* ToUnknown() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001931 return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001932 }
1933 const XMLDeclaration* ToDeclaration() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001934 return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001935 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08001936
Lee Thomason5cae8972012-01-24 18:03:07 -08001937private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001938 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08001939};
Lee Thomason6f381b72012-03-02 12:59:39 -08001940
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001941
1942/**
1943 Printing functionality. The XMLPrinter gives you more
1944 options than the XMLDocument::Print() method.
1945
1946 It can:
1947 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02001948 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001949 -# Print XML without a XMLDocument.
1950
1951 Print to Memory
1952
1953 @verbatim
1954 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001955 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02001956 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001957 @endverbatim
1958
1959 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001960
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001961 You provide the file pointer.
1962 @verbatim
1963 XMLPrinter printer( fp );
1964 doc.Print( &printer );
1965 @endverbatim
1966
1967 Print without a XMLDocument
1968
1969 When loading, an XML parser is very useful. However, sometimes
1970 when saving, it just gets in the way. The code is often set up
1971 for streaming, and constructing the DOM is just overhead.
1972
1973 The Printer supports the streaming case. The following code
1974 prints out a trivially simple XML file without ever creating
1975 an XML document.
1976
1977 @verbatim
1978 XMLPrinter printer( fp );
1979 printer.OpenElement( "foo" );
1980 printer.PushAttribute( "foo", "bar" );
1981 printer.CloseElement();
1982 @endverbatim
1983*/
PKEuS16ed47d2013-07-06 12:02:43 +02001984class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001985{
1986public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001987 /** Construct the printer. If the FILE* is specified,
1988 this will print to the FILE. Else it will print
1989 to memory, and the result is available in CStr().
1990 If 'compact' is set to true, then output is created
1991 with only required whitespace and newlines.
1992 */
PKEuS1bfb9542013-08-04 13:51:17 +02001993 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05001994 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001995
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001996 /** If streaming, write the BOM and declaration. */
1997 void PushHeader( bool writeBOM, bool writeDeclaration );
1998 /** If streaming, start writing an element.
1999 The element must be closed with CloseElement()
2000 */
Lee Thomason256adb62014-04-06 14:41:46 -07002001 void OpenElement( const char* name, bool compactMode=false );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002002 /// If streaming, add an attribute to an open element.
2003 void PushAttribute( const char* name, const char* value );
2004 void PushAttribute( const char* name, int value );
2005 void PushAttribute( const char* name, unsigned value );
2006 void PushAttribute( const char* name, bool value );
2007 void PushAttribute( const char* name, double value );
2008 /// If streaming, close the Element.
Lee Thomason256adb62014-04-06 14:41:46 -07002009 virtual void CloseElement( bool compactMode=false );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002010
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002011 /// Add a text node.
2012 void PushText( const char* text, bool cdata=false );
2013 /// Add a text node from an integer.
2014 void PushText( int value );
2015 /// Add a text node from an unsigned.
2016 void PushText( unsigned value );
2017 /// Add a text node from a bool.
2018 void PushText( bool value );
2019 /// Add a text node from a float.
2020 void PushText( float value );
2021 /// Add a text node from a double.
2022 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07002023
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002024 /// Add a comment
2025 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002026
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002027 void PushDeclaration( const char* value );
2028 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002029
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002030 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
2031 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
2032 return true;
2033 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002034
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002035 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
2036 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002037
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002038 virtual bool Visit( const XMLText& text );
2039 virtual bool Visit( const XMLComment& comment );
2040 virtual bool Visit( const XMLDeclaration& declaration );
2041 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002042
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002043 /**
2044 If in print to memory mode, return a pointer to
2045 the XML file in memory.
2046 */
2047 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002048 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002049 }
2050 /**
2051 If in print to memory mode, return the size
2052 of the XML file in memory. (Note the size returned
2053 includes the terminating null.)
2054 */
2055 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002056 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002057 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002058 /**
2059 If in print to memory mode, reset the buffer to the
2060 beginning.
2061 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08002062 void ClearBuffer() {
2063 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002064 _buffer.Push(0);
2065 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002066
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002067protected:
Alexander Maid740b642014-05-20 22:04:42 +02002068 virtual bool CompactMode( const XMLElement& ) { return _compactMode; }
Uli Kusterer5d1d27e2014-02-20 11:50:22 +01002069
Lee Thomasonc18eb232014-02-21 17:31:17 -08002070 /** Prints out the space before an element. You may override to change
2071 the space and tabs used. A PrintSpace() override should call Print().
2072 */
2073 virtual void PrintSpace( int depth );
2074 void Print( const char* format, ... );
2075
Dmitry-Mea092bc12014-12-23 17:57:05 +03002076 void SealElementIfJustOpened();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002077 bool _elementJustOpened;
2078 DynArray< const char*, 10 > _stack;
2079
2080private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002081 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002082
Lee Thomason624d43f2012-10-12 10:58:48 -07002083 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01002084 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07002085 int _depth;
2086 int _textDepth;
2087 bool _processEntities;
Lee Thomasonc18eb232014-02-21 17:31:17 -08002088 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002089
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002090 enum {
2091 ENTITY_RANGE = 64,
2092 BUF_SIZE = 200
2093 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002094 bool _entityFlag[ENTITY_RANGE];
2095 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002096
Lee Thomason624d43f2012-10-12 10:58:48 -07002097 DynArray< char, 20 > _buffer;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002098};
2099
2100
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002101} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002102
PKEuS95060352013-07-26 10:42:44 +02002103#if defined(_MSC_VER)
2104# pragma warning(pop)
2105#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002106
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002107#endif // TINYXML2_INCLUDED