blob: 02866494adef95defd046f0be73c8bb3b1f26338 [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 );
Dmitry-Me74e39402015-01-01 16:26:17 +0300897 void BeforeInsertChild( XMLNode* insertThis ) const;
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800898};
899
900
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800901/** XML text.
902
903 Note that a text node can have child element nodes, for example:
904 @verbatim
905 <root>This is <b>bold</b></root>
906 @endverbatim
907
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700908 A text node can have 2 ways to output the next. "normal" output
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800909 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 -0700910 you generally want to leave it alone, but you can change the output mode with
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600911 SetCData() and query it with CData().
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800912*/
PKEuS16ed47d2013-07-06 12:02:43 +0200913class TINYXML2_LIB XMLText : public XMLNode
Lee Thomason5492a1c2012-01-23 15:32:10 -0800914{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700915 friend class XMLBase;
916 friend class XMLDocument;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800917public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700918 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -0800919
Lee Thomason624d43f2012-10-12 10:58:48 -0700920 virtual XMLText* ToText() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700921 return this;
922 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700923 virtual const XMLText* ToText() const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700924 return this;
925 }
Lee Thomason5492a1c2012-01-23 15:32:10 -0800926
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700927 /// Declare whether this should be CDATA or standard text.
Lee Thomason624d43f2012-10-12 10:58:48 -0700928 void SetCData( bool isCData ) {
929 _isCData = isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700930 }
931 /// Returns true if this is a CDATA text element.
932 bool CData() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700933 return _isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700934 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800935
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700936 char* ParseDeep( char*, StrPair* endTag );
937 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
938 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800939
Lee Thomason5492a1c2012-01-23 15:32:10 -0800940protected:
Lee Thomason624d43f2012-10-12 10:58:48 -0700941 XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700942 virtual ~XMLText() {}
943 XMLText( const XMLText& ); // not supported
944 XMLText& operator=( const XMLText& ); // not supported
Lee Thomason5492a1c2012-01-23 15:32:10 -0800945
946private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700947 bool _isCData;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800948};
949
950
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800951/** An XML Comment. */
PKEuS16ed47d2013-07-06 12:02:43 +0200952class TINYXML2_LIB XMLComment : public XMLNode
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800953{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700954 friend class XMLDocument;
Lee Thomason3f57d272012-01-11 15:30:03 -0800955public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700956 virtual XMLComment* ToComment() {
957 return this;
958 }
959 virtual const XMLComment* ToComment() const {
960 return this;
961 }
Lee Thomasonce0763e2012-01-11 15:43:54 -0800962
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700963 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800964
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700965 char* ParseDeep( char*, StrPair* endTag );
966 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
967 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomasonce0763e2012-01-11 15:43:54 -0800968
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800969protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700970 XMLComment( XMLDocument* doc );
971 virtual ~XMLComment();
972 XMLComment( const XMLComment& ); // not supported
973 XMLComment& operator=( const XMLComment& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800974
Lee Thomason3f57d272012-01-11 15:30:03 -0800975private:
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800976};
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800977
978
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800979/** In correct XML the declaration is the first entry in the file.
980 @verbatim
981 <?xml version="1.0" standalone="yes"?>
982 @endverbatim
983
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600984 TinyXML-2 will happily read or write files without a declaration,
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800985 however.
986
987 The text of the declaration isn't interpreted. It is parsed
988 and written as a string.
989*/
PKEuS16ed47d2013-07-06 12:02:43 +0200990class TINYXML2_LIB XMLDeclaration : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -0800991{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700992 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -0800993public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700994 virtual XMLDeclaration* ToDeclaration() {
995 return this;
996 }
997 virtual const XMLDeclaration* ToDeclaration() const {
998 return this;
999 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001000
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001001 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001002
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001003 char* ParseDeep( char*, StrPair* endTag );
1004 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1005 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001006
1007protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001008 XMLDeclaration( XMLDocument* doc );
1009 virtual ~XMLDeclaration();
1010 XMLDeclaration( const XMLDeclaration& ); // not supported
1011 XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001012};
1013
1014
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001015/** Any tag that TinyXML-2 doesn't recognize is saved as an
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001016 unknown. It is a tag of text, but should not be modified.
1017 It will be written back to the XML, unchanged, when the file
1018 is saved.
1019
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001020 DTD tags get thrown into XMLUnknowns.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001021*/
PKEuS16ed47d2013-07-06 12:02:43 +02001022class TINYXML2_LIB XMLUnknown : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -08001023{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001024 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -08001025public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001026 virtual XMLUnknown* ToUnknown() {
1027 return this;
1028 }
1029 virtual const XMLUnknown* ToUnknown() const {
1030 return this;
1031 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001032
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001033 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001034
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001035 char* ParseDeep( char*, StrPair* endTag );
1036 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1037 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001038
1039protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001040 XMLUnknown( XMLDocument* doc );
1041 virtual ~XMLUnknown();
1042 XMLUnknown( const XMLUnknown& ); // not supported
1043 XMLUnknown& operator=( const XMLUnknown& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001044};
1045
1046
Lee Thomason1ff38e02012-02-14 18:18:16 -08001047
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001048/** An attribute is a name-value pair. Elements have an arbitrary
1049 number of attributes, each with a unique name.
1050
1051 @note The attributes are not XMLNodes. You may only query the
1052 Next() attribute in a list.
1053*/
PKEuS16ed47d2013-07-06 12:02:43 +02001054class TINYXML2_LIB XMLAttribute
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001055{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001056 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001057public:
Lee Thomason2fa81722012-11-09 12:37:46 -08001058 /// The name of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001059 const char* Name() const;
1060
Lee Thomason2fa81722012-11-09 12:37:46 -08001061 /// The value of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001062 const char* Value() const;
1063
Lee Thomason2fa81722012-11-09 12:37:46 -08001064 /// The next attribute in the list.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001065 const XMLAttribute* Next() const {
MortenMacFly4ee49f12013-01-14 20:03:14 +01001066 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001067 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001068
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001069 /** IntValue interprets the attribute as an integer, and returns the value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001070 If the value isn't an integer, 0 will be returned. There is no error checking;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001071 use QueryIntValue() if you need error checking.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001072 */
1073 int IntValue() const {
1074 int i=0;
1075 QueryIntValue( &i );
1076 return i;
1077 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001078 /// Query as an unsigned integer. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001079 unsigned UnsignedValue() const {
1080 unsigned i=0;
1081 QueryUnsignedValue( &i );
1082 return i;
1083 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001084 /// Query as a boolean. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001085 bool BoolValue() const {
1086 bool b=false;
1087 QueryBoolValue( &b );
1088 return b;
1089 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001090 /// Query as a double. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001091 double DoubleValue() const {
1092 double d=0;
1093 QueryDoubleValue( &d );
1094 return d;
1095 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001096 /// Query as a float. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001097 float FloatValue() const {
1098 float f=0;
1099 QueryFloatValue( &f );
1100 return f;
1101 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001102
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001103 /** QueryIntValue interprets the attribute as an integer, and returns the value
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001104 in the provided parameter. The function will return XML_NO_ERROR on success,
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001105 and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
1106 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001107 XMLError QueryIntValue( int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001108 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001109 XMLError QueryUnsignedValue( unsigned int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001110 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001111 XMLError QueryBoolValue( bool* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001112 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001113 XMLError QueryDoubleValue( double* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001114 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001115 XMLError QueryFloatValue( float* value ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -08001116
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001117 /// Set the attribute to a string value.
1118 void SetAttribute( const char* value );
1119 /// Set the attribute to value.
1120 void SetAttribute( int value );
1121 /// Set the attribute to value.
1122 void SetAttribute( unsigned value );
1123 /// Set the attribute to value.
1124 void SetAttribute( bool value );
1125 /// Set the attribute to value.
1126 void SetAttribute( double value );
1127 /// Set the attribute to value.
1128 void SetAttribute( float value );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001129
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001130private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001131 enum { BUF_SIZE = 200 };
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001132
Thomas Roß61892312013-05-12 14:07:38 +02001133 XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001134 virtual ~XMLAttribute() {}
Lee Thomason624d43f2012-10-12 10:58:48 -07001135
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001136 XMLAttribute( const XMLAttribute& ); // not supported
1137 void operator=( const XMLAttribute& ); // not supported
1138 void SetName( const char* name );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001139
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001140 char* ParseDeep( char* p, bool processEntities );
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001141
Lee Thomason624d43f2012-10-12 10:58:48 -07001142 mutable StrPair _name;
1143 mutable StrPair _value;
1144 XMLAttribute* _next;
1145 MemPool* _memPool;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001146};
1147
1148
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001149/** The element is a container class. It has a value, the element name,
1150 and can contain other elements, text, comments, and unknowns.
1151 Elements also contain an arbitrary number of attributes.
1152*/
PKEuS16ed47d2013-07-06 12:02:43 +02001153class TINYXML2_LIB XMLElement : public XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001154{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001155 friend class XMLBase;
1156 friend class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001157public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001158 /// Get the name of an element (which is the Value() of the node.)
1159 const char* Name() const {
1160 return Value();
1161 }
1162 /// Set the name of the element.
1163 void SetName( const char* str, bool staticMem=false ) {
1164 SetValue( str, staticMem );
1165 }
Lee Thomason2c85a712012-01-31 08:24:24 -08001166
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001167 virtual XMLElement* ToElement() {
1168 return this;
1169 }
1170 virtual const XMLElement* ToElement() const {
1171 return this;
1172 }
1173 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001174
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001175 /** Given an attribute name, Attribute() returns the value
1176 for the attribute of that name, or null if none
1177 exists. For example:
Lee Thomason92258152012-03-24 13:05:39 -07001178
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001179 @verbatim
1180 const char* value = ele->Attribute( "foo" );
1181 @endverbatim
Lee Thomason92258152012-03-24 13:05:39 -07001182
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001183 The 'value' parameter is normally null. However, if specified,
1184 the attribute will only be returned if the 'name' and 'value'
1185 match. This allow you to write code:
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001186
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001187 @verbatim
1188 if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
1189 @endverbatim
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001190
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001191 rather than:
1192 @verbatim
1193 if ( ele->Attribute( "foo" ) ) {
1194 if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
1195 }
1196 @endverbatim
1197 */
1198 const char* Attribute( const char* name, const char* value=0 ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001199
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001200 /** Given an attribute name, IntAttribute() returns the value
1201 of the attribute interpreted as an integer. 0 will be
1202 returned if there is an error. For a method with error
1203 checking, see QueryIntAttribute()
1204 */
1205 int IntAttribute( const char* name ) const {
1206 int i=0;
1207 QueryIntAttribute( name, &i );
1208 return i;
1209 }
1210 /// See IntAttribute()
1211 unsigned UnsignedAttribute( const char* name ) const {
1212 unsigned i=0;
1213 QueryUnsignedAttribute( name, &i );
1214 return i;
1215 }
1216 /// See IntAttribute()
1217 bool BoolAttribute( const char* name ) const {
1218 bool b=false;
1219 QueryBoolAttribute( name, &b );
1220 return b;
1221 }
1222 /// See IntAttribute()
1223 double DoubleAttribute( const char* name ) const {
1224 double d=0;
1225 QueryDoubleAttribute( name, &d );
1226 return d;
1227 }
1228 /// See IntAttribute()
1229 float FloatAttribute( const char* name ) const {
1230 float f=0;
1231 QueryFloatAttribute( name, &f );
1232 return f;
1233 }
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001234
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001235 /** Given an attribute name, QueryIntAttribute() returns
1236 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1237 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1238 doesn't exist. If successful, the result of the conversion
1239 will be written to 'value'. If not successful, nothing will
1240 be written to 'value'. This allows you to provide default
1241 value:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001242
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001243 @verbatim
1244 int value = 10;
1245 QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1246 @endverbatim
1247 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001248 XMLError QueryIntAttribute( const char* name, int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001249 const XMLAttribute* a = FindAttribute( name );
1250 if ( !a ) {
1251 return XML_NO_ATTRIBUTE;
1252 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001253 return a->QueryIntValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001254 }
1255 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001256 XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001257 const XMLAttribute* a = FindAttribute( name );
1258 if ( !a ) {
1259 return XML_NO_ATTRIBUTE;
1260 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001261 return a->QueryUnsignedValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001262 }
1263 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001264 XMLError QueryBoolAttribute( const char* name, bool* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001265 const XMLAttribute* a = FindAttribute( name );
1266 if ( !a ) {
1267 return XML_NO_ATTRIBUTE;
1268 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001269 return a->QueryBoolValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001270 }
1271 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001272 XMLError QueryDoubleAttribute( const char* name, double* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001273 const XMLAttribute* a = FindAttribute( name );
1274 if ( !a ) {
1275 return XML_NO_ATTRIBUTE;
1276 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001277 return a->QueryDoubleValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001278 }
1279 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001280 XMLError QueryFloatAttribute( const char* name, float* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001281 const XMLAttribute* a = FindAttribute( name );
1282 if ( !a ) {
1283 return XML_NO_ATTRIBUTE;
1284 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001285 return a->QueryFloatValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001286 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001287
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001288
1289 /** Given an attribute name, QueryAttribute() returns
1290 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1291 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1292 doesn't exist. It is overloaded for the primitive types,
1293 and is a generally more convenient replacement of
1294 QueryIntAttribute() and related functions.
1295
1296 If successful, the result of the conversion
1297 will be written to 'value'. If not successful, nothing will
1298 be written to 'value'. This allows you to provide default
1299 value:
1300
1301 @verbatim
1302 int value = 10;
1303 QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1304 @endverbatim
1305 */
1306 int QueryAttribute( const char* name, int* value ) const {
1307 return QueryIntAttribute( name, value );
1308 }
1309
1310 int QueryAttribute( const char* name, unsigned int* value ) const {
1311 return QueryUnsignedAttribute( name, value );
1312 }
1313
1314 int QueryAttribute( const char* name, bool* value ) const {
1315 return QueryBoolAttribute( name, value );
1316 }
1317
1318 int QueryAttribute( const char* name, double* value ) const {
1319 return QueryDoubleAttribute( name, value );
1320 }
1321
1322 int QueryAttribute( const char* name, float* value ) const {
1323 return QueryFloatAttribute( name, value );
1324 }
1325
1326 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001327 void SetAttribute( const char* name, const char* value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001328 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001329 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001330 }
1331 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001332 void SetAttribute( const char* name, int value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001333 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001334 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001335 }
1336 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001337 void SetAttribute( const char* name, unsigned value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001338 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001339 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001340 }
1341 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001342 void SetAttribute( const char* name, bool value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001343 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001344 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001345 }
1346 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001347 void SetAttribute( const char* name, double value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001348 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001349 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001350 }
Lee Thomasonc3708cc2014-01-14 12:30:03 -08001351 /// Sets the named attribute to value.
1352 void SetAttribute( const char* name, float value ) {
1353 XMLAttribute* a = FindOrCreateAttribute( name );
1354 a->SetAttribute( value );
1355 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001356
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001357 /**
1358 Delete an attribute.
1359 */
1360 void DeleteAttribute( const char* name );
Lee Thomason751da522012-02-10 08:50:51 -08001361
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001362 /// Return the first attribute in the list.
1363 const XMLAttribute* FirstAttribute() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001364 return _rootAttribute;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001365 }
1366 /// Query a specific attribute in the list.
1367 const XMLAttribute* FindAttribute( const char* name ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001368
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001369 /** Convenience function for easy access to the text inside an element. Although easy
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001370 and concise, GetText() is limited compared to getting the XMLText child
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001371 and accessing it directly.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001372
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001373 If the first child of 'this' is a XMLText, the GetText()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001374 returns the character string of the Text node, else null is returned.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001375
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001376 This is a convenient method for getting the text of simple contained text:
1377 @verbatim
1378 <foo>This is text</foo>
1379 const char* str = fooElement->GetText();
1380 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001381
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001382 'str' will be a pointer to "This is text".
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001383
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001384 Note that this function can be misleading. If the element foo was created from
1385 this XML:
1386 @verbatim
1387 <foo><b>This is text</b></foo>
1388 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001389
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001390 then the value of str would be null. The first child node isn't a text node, it is
1391 another element. From this XML:
1392 @verbatim
1393 <foo>This is <b>text</b></foo>
1394 @endverbatim
1395 GetText() will return "This is ".
1396 */
1397 const char* GetText() const;
Lee Thomason751da522012-02-10 08:50:51 -08001398
Uli Kusterer85fff5e2014-01-21 01:35:30 +01001399 /** Convenience function for easy access to the text inside an element. Although easy
1400 and concise, SetText() is limited compared to creating an XMLText child
1401 and mutating it directly.
1402
1403 If the first child of 'this' is a XMLText, SetText() sets its value to
1404 the given string, otherwise it will create a first child that is an XMLText.
1405
1406 This is a convenient method for setting the text of simple contained text:
1407 @verbatim
1408 <foo>This is text</foo>
1409 fooElement->SetText( "Hullaballoo!" );
1410 <foo>Hullaballoo!</foo>
1411 @endverbatim
1412
1413 Note that this function can be misleading. If the element foo was created from
1414 this XML:
1415 @verbatim
1416 <foo><b>This is text</b></foo>
1417 @endverbatim
1418
1419 then it will not change "This is text", but rather prefix it with a text element:
1420 @verbatim
1421 <foo>Hullaballoo!<b>This is text</b></foo>
1422 @endverbatim
1423
1424 For this XML:
1425 @verbatim
1426 <foo />
1427 @endverbatim
1428 SetText() will generate
1429 @verbatim
1430 <foo>Hullaballoo!</foo>
1431 @endverbatim
1432 */
Lee Thomason5bb2d802014-01-24 10:42:57 -08001433 void SetText( const char* inText );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001434 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001435 void SetText( int value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001436 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001437 void SetText( unsigned value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001438 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001439 void SetText( bool value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001440 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001441 void SetText( double value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001442 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001443 void SetText( float value );
Uli Kusterer8fe342a2014-01-21 01:12:47 +01001444
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001445 /**
1446 Convenience method to query the value of a child text node. This is probably best
1447 shown by example. Given you have a document is this form:
1448 @verbatim
1449 <point>
1450 <x>1</x>
1451 <y>1.4</y>
1452 </point>
1453 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001454
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001455 The QueryIntText() and similar functions provide a safe and easier way to get to the
1456 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001457
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001458 @verbatim
1459 int x = 0;
1460 float y = 0; // types of x and y are contrived for example
1461 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1462 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1463 xElement->QueryIntText( &x );
1464 yElement->QueryFloatText( &y );
1465 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001466
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001467 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1468 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 -07001469
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001470 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001471 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001472 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001473 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001474 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001475 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001476 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001477 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001478 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001479 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001480
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001481 // internal:
1482 enum {
1483 OPEN, // <foo>
1484 CLOSED, // <foo/>
1485 CLOSING // </foo>
1486 };
1487 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001488 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001489 }
1490 char* ParseDeep( char* p, StrPair* endTag );
1491 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1492 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001493
Lee Thomason50adb4c2012-02-13 15:07:09 -08001494private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001495 XMLElement( XMLDocument* doc );
1496 virtual ~XMLElement();
1497 XMLElement( const XMLElement& ); // not supported
1498 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001499
Dmitry-Me1227d512014-12-05 13:41:45 +03001500 XMLAttribute* FindAttribute( const char* name ) {
1501 return const_cast<XMLAttribute*>(const_cast<const XMLElement*>(this)->FindAttribute( name ));
1502 }
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001503 XMLAttribute* FindOrCreateAttribute( const char* name );
1504 //void LinkAttribute( XMLAttribute* attrib );
1505 char* ParseAttributes( char* p );
Dmitry-Mee3225b12014-09-03 11:03:11 +04001506 static void DeleteAttribute( XMLAttribute* attribute );
Lee Thomason67d61312012-01-24 16:01:51 -08001507
Lee Thomason5bb2d802014-01-24 10:42:57 -08001508 enum { BUF_SIZE = 200 };
Lee Thomason624d43f2012-10-12 10:58:48 -07001509 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001510 // The attribute list is ordered; there is no 'lastAttribute'
1511 // because the list needs to be scanned for dupes before adding
1512 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001513 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001514};
1515
1516
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001517enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001518 PRESERVE_WHITESPACE,
1519 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001520};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001521
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001522
1523/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001524 It can be saved, loaded, and printed to the screen.
1525 All Nodes are connected and allocated to a Document.
1526 If the Document is deleted, all its Nodes are also deleted.
1527*/
PKEuS16ed47d2013-07-06 12:02:43 +02001528class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001529{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001530 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001531public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001532 /// constructor
1533 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1534 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001535
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001536 virtual XMLDocument* ToDocument() {
1537 return this;
1538 }
1539 virtual const XMLDocument* ToDocument() const {
1540 return this;
1541 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001542
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001543 /**
1544 Parse an XML file from a character string.
1545 Returns XML_NO_ERROR (0) on success, or
1546 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001547
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001548 You may optionally pass in the 'nBytes', which is
1549 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001550 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001551 null terminated string.
1552 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001553 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001554
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001555 /**
1556 Load an XML file from disk.
1557 Returns XML_NO_ERROR (0) on success, or
1558 an errorID.
1559 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001560 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001561
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001562 /**
1563 Load an XML file from disk. You are responsible
Lee Thomasoncd011bc2014-12-17 10:41:34 -08001564 for providing and closing the FILE*.
1565
1566 NOTE: The file should be opened as binary ("rb")
1567 not text in order for TinyXML-2 to correctly
1568 do newline normalization.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001569
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001570 Returns XML_NO_ERROR (0) on success, or
1571 an errorID.
1572 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001573 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001574
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001575 /**
1576 Save the XML file to disk.
1577 Returns XML_NO_ERROR (0) on success, or
1578 an errorID.
1579 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001580 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001581
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001582 /**
1583 Save the XML file to disk. You are responsible
1584 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001585
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001586 Returns XML_NO_ERROR (0) on success, or
1587 an errorID.
1588 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001589 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001590
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001591 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001592 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001593 }
1594 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001595 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001596 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001597
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001598 /**
1599 Returns true if this document has a leading Byte Order Mark of UTF8.
1600 */
1601 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001602 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001603 }
1604 /** Sets whether to write the BOM when writing the file.
1605 */
1606 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001607 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001608 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001609
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001610 /** Return the root element of DOM. Equivalent to FirstChildElement().
1611 To get the first node, use FirstChild().
1612 */
1613 XMLElement* RootElement() {
1614 return FirstChildElement();
1615 }
1616 const XMLElement* RootElement() const {
1617 return FirstChildElement();
1618 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001619
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001620 /** Print the Document. If the Printer is not provided, it will
1621 print to stdout. If you provide Printer, this can print to a file:
1622 @verbatim
1623 XMLPrinter printer( fp );
1624 doc.Print( &printer );
1625 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001626
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001627 Or you can use a printer to print to memory:
1628 @verbatim
1629 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001630 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001631 // printer.CStr() has a const char* to the XML
1632 @endverbatim
1633 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001634 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001635 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001636
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001637 /**
1638 Create a new Element associated with
1639 this Document. The memory for the Element
1640 is managed by the Document.
1641 */
1642 XMLElement* NewElement( const char* name );
1643 /**
1644 Create a new Comment associated with
1645 this Document. The memory for the Comment
1646 is managed by the Document.
1647 */
1648 XMLComment* NewComment( const char* comment );
1649 /**
1650 Create a new Text associated with
1651 this Document. The memory for the Text
1652 is managed by the Document.
1653 */
1654 XMLText* NewText( const char* text );
1655 /**
1656 Create a new Declaration associated with
1657 this Document. The memory for the object
1658 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001659
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001660 If the 'text' param is null, the standard
1661 declaration is used.:
1662 @verbatim
1663 <?xml version="1.0" encoding="UTF-8"?>
1664 @endverbatim
1665 */
1666 XMLDeclaration* NewDeclaration( const char* text=0 );
1667 /**
1668 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001669 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001670 is managed by the Document.
1671 */
1672 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001673
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001674 /**
1675 Delete a node associated with this document.
1676 It will be unlinked from the DOM.
1677 */
Lee Thomasoncd011bc2014-12-17 10:41:34 -08001678 void DeleteNode( XMLNode* node );
U-Stream\Leeae25a442012-02-17 17:48:16 -08001679
Lee Thomason2fa81722012-11-09 12:37:46 -08001680 void SetError( XMLError error, const char* str1, const char* str2 );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001681
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001682 /// Return true if there was an error parsing the document.
1683 bool Error() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001684 return _errorID != XML_NO_ERROR;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001685 }
1686 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001687 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001688 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001689 }
Lee Thomason331596e2014-09-11 14:56:43 -07001690 const char* ErrorName() const;
1691
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001692 /// Return a possibly helpful diagnostic location or string.
1693 const char* GetErrorStr1() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001694 return _errorStr1;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001695 }
1696 /// Return a possibly helpful secondary diagnostic location or string.
1697 const char* GetErrorStr2() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001698 return _errorStr2;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001699 }
1700 /// If there is an error, print it to stdout.
1701 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001702
1703 /// Clear the document, resetting it to the initial state.
1704 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001705
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001706 // internal
1707 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001708
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001709 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1710 return 0;
1711 }
1712 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1713 return false;
1714 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001715
Lee Thomason3f57d272012-01-11 15:30:03 -08001716private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001717 XMLDocument( const XMLDocument& ); // not supported
1718 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001719
Lee Thomason2fa81722012-11-09 12:37:46 -08001720 bool _writeBOM;
1721 bool _processEntities;
1722 XMLError _errorID;
1723 Whitespace _whitespace;
Lee Thomason624d43f2012-10-12 10:58:48 -07001724 const char* _errorStr1;
1725 const char* _errorStr2;
Lee Thomason2fa81722012-11-09 12:37:46 -08001726 char* _charBuffer;
Lee Thomasond1983222012-02-06 08:41:24 -08001727
Lee Thomason624d43f2012-10-12 10:58:48 -07001728 MemPoolT< sizeof(XMLElement) > _elementPool;
1729 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1730 MemPoolT< sizeof(XMLText) > _textPool;
1731 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason331596e2014-09-11 14:56:43 -07001732
1733 static const char* _errorNames[XML_ERROR_COUNT];
Lee Thomason5cae8972012-01-24 18:03:07 -08001734};
1735
Lee Thomason7c913cd2012-01-26 18:32:34 -08001736
Lee Thomason3ffdd392012-03-28 17:27:55 -07001737/**
1738 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001739 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001740 DOM structure. It is a separate utility class.
1741
1742 Take an example:
1743 @verbatim
1744 <Document>
1745 <Element attributeA = "valueA">
1746 <Child attributeB = "value1" />
1747 <Child attributeB = "value2" />
1748 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001749 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001750 @endverbatim
1751
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001752 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001753 easy to write a *lot* of code that looks like:
1754
1755 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001756 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001757 if ( root )
1758 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001759 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001760 if ( element )
1761 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001762 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001763 if ( child )
1764 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001765 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001766 if ( child2 )
1767 {
1768 // Finally do something useful.
1769 @endverbatim
1770
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001771 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001772 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001773 and correct to use:
1774
1775 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001776 XMLHandle docHandle( &document );
Dmitry-Mea317bd62014-12-08 10:35:37 +03001777 XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001778 if ( child2 )
1779 {
1780 // do something useful
1781 @endverbatim
1782
1783 Which is MUCH more concise and useful.
1784
1785 It is also safe to copy handles - internally they are nothing more than node pointers.
1786 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001787 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001788 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001789
1790 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001791*/
PKEuS16ed47d2013-07-06 12:02:43 +02001792class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001793{
1794public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001795 /// 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 -07001796 XMLHandle( XMLNode* node ) {
1797 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001798 }
1799 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001800 XMLHandle( XMLNode& node ) {
1801 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001802 }
1803 /// Copy constructor
1804 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001805 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001806 }
1807 /// Assignment
1808 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001809 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001810 return *this;
1811 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001812
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001813 /// Get the first child of this handle.
1814 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001815 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001816 }
1817 /// Get the first child element of this handle.
1818 XMLHandle FirstChildElement( const char* value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001819 return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001820 }
1821 /// Get the last child of this handle.
1822 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001823 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001824 }
1825 /// Get the last child element of this handle.
1826 XMLHandle LastChildElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001827 return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001828 }
1829 /// Get the previous sibling of this handle.
1830 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001831 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001832 }
1833 /// Get the previous sibling element of this handle.
1834 XMLHandle PreviousSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001835 return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001836 }
1837 /// Get the next sibling of this handle.
1838 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001839 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001840 }
1841 /// Get the next sibling element of this handle.
1842 XMLHandle NextSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001843 return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001844 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001845
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001846 /// Safe cast to XMLNode. This can return null.
1847 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001848 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001849 }
1850 /// Safe cast to XMLElement. This can return null.
1851 XMLElement* ToElement() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001852 return ( ( _node == 0 ) ? 0 : _node->ToElement() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001853 }
1854 /// Safe cast to XMLText. This can return null.
1855 XMLText* ToText() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001856 return ( ( _node == 0 ) ? 0 : _node->ToText() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001857 }
1858 /// Safe cast to XMLUnknown. This can return null.
1859 XMLUnknown* ToUnknown() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001860 return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001861 }
1862 /// Safe cast to XMLDeclaration. This can return null.
1863 XMLDeclaration* ToDeclaration() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001864 return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001865 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001866
1867private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001868 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001869};
1870
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001871
1872/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001873 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1874 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001875*/
PKEuS16ed47d2013-07-06 12:02:43 +02001876class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001877{
1878public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001879 XMLConstHandle( const XMLNode* node ) {
1880 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001881 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001882 XMLConstHandle( const XMLNode& node ) {
1883 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001884 }
1885 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001886 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001887 }
Lee Thomason8b899812012-04-04 15:58:16 -07001888
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001889 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001890 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001891 return *this;
1892 }
Lee Thomason8b899812012-04-04 15:58:16 -07001893
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001894 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001895 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001896 }
1897 const XMLConstHandle FirstChildElement( const char* value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001898 return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001899 }
1900 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001901 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001902 }
1903 const XMLConstHandle LastChildElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001904 return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001905 }
1906 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001907 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001908 }
1909 const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001910 return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001911 }
1912 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001913 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001914 }
1915 const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001916 return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001917 }
Lee Thomason8b899812012-04-04 15:58:16 -07001918
1919
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001920 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001921 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001922 }
1923 const XMLElement* ToElement() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001924 return ( ( _node == 0 ) ? 0 : _node->ToElement() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001925 }
1926 const XMLText* ToText() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001927 return ( ( _node == 0 ) ? 0 : _node->ToText() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001928 }
1929 const XMLUnknown* ToUnknown() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001930 return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001931 }
1932 const XMLDeclaration* ToDeclaration() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001933 return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001934 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08001935
Lee Thomason5cae8972012-01-24 18:03:07 -08001936private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001937 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08001938};
Lee Thomason6f381b72012-03-02 12:59:39 -08001939
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001940
1941/**
1942 Printing functionality. The XMLPrinter gives you more
1943 options than the XMLDocument::Print() method.
1944
1945 It can:
1946 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02001947 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001948 -# Print XML without a XMLDocument.
1949
1950 Print to Memory
1951
1952 @verbatim
1953 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001954 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02001955 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001956 @endverbatim
1957
1958 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001959
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001960 You provide the file pointer.
1961 @verbatim
1962 XMLPrinter printer( fp );
1963 doc.Print( &printer );
1964 @endverbatim
1965
1966 Print without a XMLDocument
1967
1968 When loading, an XML parser is very useful. However, sometimes
1969 when saving, it just gets in the way. The code is often set up
1970 for streaming, and constructing the DOM is just overhead.
1971
1972 The Printer supports the streaming case. The following code
1973 prints out a trivially simple XML file without ever creating
1974 an XML document.
1975
1976 @verbatim
1977 XMLPrinter printer( fp );
1978 printer.OpenElement( "foo" );
1979 printer.PushAttribute( "foo", "bar" );
1980 printer.CloseElement();
1981 @endverbatim
1982*/
PKEuS16ed47d2013-07-06 12:02:43 +02001983class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001984{
1985public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001986 /** Construct the printer. If the FILE* is specified,
1987 this will print to the FILE. Else it will print
1988 to memory, and the result is available in CStr().
1989 If 'compact' is set to true, then output is created
1990 with only required whitespace and newlines.
1991 */
PKEuS1bfb9542013-08-04 13:51:17 +02001992 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05001993 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001994
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001995 /** If streaming, write the BOM and declaration. */
1996 void PushHeader( bool writeBOM, bool writeDeclaration );
1997 /** If streaming, start writing an element.
1998 The element must be closed with CloseElement()
1999 */
Lee Thomason256adb62014-04-06 14:41:46 -07002000 void OpenElement( const char* name, bool compactMode=false );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002001 /// If streaming, add an attribute to an open element.
2002 void PushAttribute( const char* name, const char* value );
2003 void PushAttribute( const char* name, int value );
2004 void PushAttribute( const char* name, unsigned value );
2005 void PushAttribute( const char* name, bool value );
2006 void PushAttribute( const char* name, double value );
2007 /// If streaming, close the Element.
Lee Thomason256adb62014-04-06 14:41:46 -07002008 virtual void CloseElement( bool compactMode=false );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002009
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002010 /// Add a text node.
2011 void PushText( const char* text, bool cdata=false );
2012 /// Add a text node from an integer.
2013 void PushText( int value );
2014 /// Add a text node from an unsigned.
2015 void PushText( unsigned value );
2016 /// Add a text node from a bool.
2017 void PushText( bool value );
2018 /// Add a text node from a float.
2019 void PushText( float value );
2020 /// Add a text node from a double.
2021 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07002022
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002023 /// Add a comment
2024 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002025
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002026 void PushDeclaration( const char* value );
2027 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002028
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002029 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
2030 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
2031 return true;
2032 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002033
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002034 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
2035 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002036
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002037 virtual bool Visit( const XMLText& text );
2038 virtual bool Visit( const XMLComment& comment );
2039 virtual bool Visit( const XMLDeclaration& declaration );
2040 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002041
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002042 /**
2043 If in print to memory mode, return a pointer to
2044 the XML file in memory.
2045 */
2046 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002047 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002048 }
2049 /**
2050 If in print to memory mode, return the size
2051 of the XML file in memory. (Note the size returned
2052 includes the terminating null.)
2053 */
2054 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002055 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002056 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002057 /**
2058 If in print to memory mode, reset the buffer to the
2059 beginning.
2060 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08002061 void ClearBuffer() {
2062 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002063 _buffer.Push(0);
2064 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002065
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002066protected:
Alexander Maid740b642014-05-20 22:04:42 +02002067 virtual bool CompactMode( const XMLElement& ) { return _compactMode; }
Uli Kusterer5d1d27e2014-02-20 11:50:22 +01002068
Lee Thomasonc18eb232014-02-21 17:31:17 -08002069 /** Prints out the space before an element. You may override to change
2070 the space and tabs used. A PrintSpace() override should call Print().
2071 */
2072 virtual void PrintSpace( int depth );
2073 void Print( const char* format, ... );
2074
Dmitry-Mea092bc12014-12-23 17:57:05 +03002075 void SealElementIfJustOpened();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002076 bool _elementJustOpened;
2077 DynArray< const char*, 10 > _stack;
2078
2079private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002080 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002081
Lee Thomason624d43f2012-10-12 10:58:48 -07002082 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01002083 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07002084 int _depth;
2085 int _textDepth;
2086 bool _processEntities;
Lee Thomasonc18eb232014-02-21 17:31:17 -08002087 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002088
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002089 enum {
2090 ENTITY_RANGE = 64,
2091 BUF_SIZE = 200
2092 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002093 bool _entityFlag[ENTITY_RANGE];
2094 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002095
Lee Thomason624d43f2012-10-12 10:58:48 -07002096 DynArray< char, 20 > _buffer;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002097};
2098
2099
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002100} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002101
PKEuS95060352013-07-26 10:42:44 +02002102#if defined(_MSC_VER)
2103# pragma warning(pop)
2104#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002105
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002106#endif // TINYXML2_INCLUDED