blob: f1be6cabf4eaa6eba1db4e5904580d0da6ba972c [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
Lee Thomason (grinliz)db304252013-07-31 12:24:52 -070017
Lee Thomason (grinliz)28129862012-02-25 21:11:20 -0800182. Altered source versions must be plainly marked as such, and
19must not be misrepresented as being the original software.
20
213. This notice may not be removed or altered from any source
22distribution.
23*/
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -080024
Lee Thomason7d00b9a2012-02-27 17:54:22 -080025#ifndef TINYXML2_INCLUDED
U-Lama\Leee13c3e62011-12-28 14:36:55 -080026#define TINYXML2_INCLUDED
27
Jerome Martinez242c3ea2013-01-06 12:20:04 +010028#if defined(ANDROID_NDK) || defined(__BORLANDC__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070029# include <ctype.h>
30# include <limits.h>
31# include <stdio.h>
32# include <stdlib.h>
33# include <string.h>
34# include <stdarg.h>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070035#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -070036# include <cctype>
37# include <climits>
38# include <cstdio>
39# include <cstdlib>
40# include <cstring>
41# include <cstdarg>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070042#endif
Lee Thomason (grinliz)6a22be22012-04-04 12:39:05 -070043
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -070044/*
Lee Thomason7d00b9a2012-02-27 17:54:22 -080045 TODO: intern strings instead of allocation.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080046*/
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080047/*
Lee Thomasona9cf3f92012-10-11 16:56:51 -070048 gcc:
Lee Thomason5b0a6772012-11-19 13:54:42 -080049 g++ -Wall -DDEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
MortenMacFly4ee49f12013-01-14 20:03:14 +010050
Lee Thomasona9cf3f92012-10-11 16:56:51 -070051 Formatting, Artistic Style:
52 AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080053*/
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080054
U-Lama\Lee4cee6112011-12-31 14:58:18 -080055#if defined( _DEBUG ) || defined( DEBUG ) || defined (__DEBUG__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070056# ifndef DEBUG
57# define DEBUG
58# endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080059#endif
60
PKEuS95060352013-07-26 10:42:44 +020061#ifdef _MSC_VER
62# pragma warning(push)
63# pragma warning(disable: 4251)
64#endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080065
PKEuS16ed47d2013-07-06 12:02:43 +020066#ifdef _WIN32
67# ifdef TINYXML2_EXPORT
68# define TINYXML2_LIB __declspec(dllexport)
69# elif defined(TINYXML2_IMPORT)
70# define TINYXML2_LIB __declspec(dllimport)
71# else
72# define TINYXML2_LIB
73# endif
74#else
75# define TINYXML2_LIB
76#endif
77
78
U-Lama\Lee4cee6112011-12-31 14:58:18 -080079#if defined(DEBUG)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070080# if defined(_MSC_VER)
81# define TIXMLASSERT( x ) if ( !(x)) { __debugbreak(); } //if ( !(x)) WinDebugBreak()
82# 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
Lee Thomason1a1d4a72012-02-15 09:09:25 -080094#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
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
Lee Thomason (grinliz)b9e791f2012-04-06 21:27:10 -0700112#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700113// GCC version 3 and higher
114//#warning( "Using sn* functions." )
115#define TIXML_SNPRINTF snprintf
116#define TIXML_SSCANF sscanf
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800117#endif
Lee Thomason1ff38e02012-02-14 18:18:16 -0800118
Uli Kusterer8fe342a2014-01-21 01:12:47 +0100119static const int TIXML2_MAJOR_VERSION = 1;
120static const int TIXML2_MINOR_VERSION = 0;
121static const int TIXML2_PATCH_VERSION = 13;
Lee Thomason1ff38e02012-02-14 18:18:16 -0800122
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800123namespace tinyxml2
124{
Lee Thomasonce0763e2012-01-11 15:43:54 -0800125class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800126class XMLElement;
127class XMLAttribute;
128class XMLComment;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800129class XMLText;
Lee Thomason50f97b22012-02-11 16:33:40 -0800130class XMLDeclaration;
131class XMLUnknown;
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800132class XMLPrinter;
Lee Thomason5cae8972012-01-24 18:03:07 -0800133
U-Stream\Leeae25a442012-02-17 17:48:16 -0800134/*
135 A class that wraps strings. Normally stores the start and end
136 pointers into the XML file itself, and will apply normalization
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800137 and entity translation if actually read. Can also store (and memory
U-Stream\Leeae25a442012-02-17 17:48:16 -0800138 manage) a traditional char[]
139*/
PKEuS95060352013-07-26 10:42:44 +0200140class StrPair
Lee Thomason39ede242012-01-20 11:27:56 -0800141{
Lee Thomasond34f52c2012-01-20 12:55:24 -0800142public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700143 enum {
144 NEEDS_ENTITY_PROCESSING = 0x01,
145 NEEDS_NEWLINE_NORMALIZATION = 0x02,
selfpoisede77e1952013-03-13 14:08:29 +0800146 COLLAPSE_WHITESPACE = 0x04,
Lee Thomason18d68bd2012-01-26 18:17:26 -0800147
selfpoisede77e1952013-03-13 14:08:29 +0800148 TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700149 TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
selfpoisede77e1952013-03-13 14:08:29 +0800150 ATTRIBUTE_NAME = 0,
151 ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
152 ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
153 COMMENT = NEEDS_NEWLINE_NORMALIZATION
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700154 };
Lee Thomason39ede242012-01-20 11:27:56 -0800155
Lee Thomason120b3a62012-10-12 10:06:59 -0700156 StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700157 ~StrPair();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800158
Lee Thomason120b3a62012-10-12 10:06:59 -0700159 void Set( char* start, char* end, int flags ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700160 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700161 _start = start;
162 _end = end;
163 _flags = flags | NEEDS_FLUSH;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700164 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700165
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700166 const char* GetStr();
Lee Thomason120b3a62012-10-12 10:06:59 -0700167
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700168 bool Empty() const {
Lee Thomason120b3a62012-10-12 10:06:59 -0700169 return _start == _end;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700170 }
Lee Thomason39ede242012-01-20 11:27:56 -0800171
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700172 void SetInternedStr( const char* str ) {
173 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700174 _start = const_cast<char*>(str);
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700175 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700176
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700177 void SetStr( const char* str, int flags=0 );
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800178
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700179 char* ParseText( char* in, const char* endTag, int strFlags );
180 char* ParseName( char* in );
Lee Thomason56bdd022012-02-09 18:16:58 -0800181
Lee Thomason39ede242012-01-20 11:27:56 -0800182private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700183 void Reset();
184 void CollapseWhitespace();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800185
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700186 enum {
187 NEEDS_FLUSH = 0x100,
188 NEEDS_DELETE = 0x200
189 };
Lee Thomasone4422302012-01-20 17:59:50 -0800190
selfpoised4dd59bc2013-03-13 16:54:15 +0800191 // After parsing, if *_end != 0, it can be set to zero.
Lee Thomason120b3a62012-10-12 10:06:59 -0700192 int _flags;
193 char* _start;
194 char* _end;
Lee Thomason39ede242012-01-20 11:27:56 -0800195};
196
U-Lama\Lee560bd472011-12-28 19:42:49 -0800197
U-Stream\Leeae25a442012-02-17 17:48:16 -0800198/*
199 A dynamic array of Plain Old Data. Doesn't support constructors, etc.
200 Has a small initial memory pool, so that low or no usage will not
201 cause a call to new/delete
202*/
Lee Thomason2c85a712012-01-31 08:24:24 -0800203template <class T, int INIT>
PKEuS95060352013-07-26 10:42:44 +0200204class DynArray
Lee Thomason2c85a712012-01-31 08:24:24 -0800205{
206public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700207 DynArray< T, INIT >() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700208 _mem = _pool;
209 _allocated = INIT;
210 _size = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700211 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700212
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700213 ~DynArray() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700214 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700215 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700216 }
217 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700218
Lee Thomasonce0510b2013-11-26 21:29:37 -0800219 void Clear() {
Reinhard Klambauer4e74b132013-11-22 14:01:58 +0100220 _size = 0;
221 }
222
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700223 void Push( T t ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700224 EnsureCapacity( _size+1 );
225 _mem[_size++] = t;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700226 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800227
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700228 T* PushArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700229 EnsureCapacity( _size+count );
230 T* ret = &_mem[_size];
231 _size += count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700232 return ret;
233 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700234
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700235 T Pop() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700236 return _mem[--_size];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700237 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700238
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700239 void PopArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700240 TIXMLASSERT( _size >= count );
241 _size -= count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700242 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800243
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700244 bool Empty() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700245 return _size == 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700246 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700247
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700248 T& operator[](int i) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700249 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700250 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700251 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700252
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700253 const T& operator[](int i) const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700254 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700255 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700256 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700257
Dennis Jenkins59c75d32013-10-08 13:10:07 -0500258 const T& PeekTop() const {
259 TIXMLASSERT( _size > 0 );
260 return _mem[ _size - 1];
261 }
262
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700263 int Size() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700264 return _size;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700265 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700266
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700267 int Capacity() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700268 return _allocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700269 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700270
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700271 const T* Mem() const {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700272 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700273 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700274
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700275 T* Mem() {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700276 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700277 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800278
Lee Thomason2c85a712012-01-31 08:24:24 -0800279private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700280 void EnsureCapacity( int cap ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700281 if ( cap > _allocated ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700282 int newAllocated = cap * 2;
283 T* newMem = new T[newAllocated];
Lee Thomason624d43f2012-10-12 10:58:48 -0700284 memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
285 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700286 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700287 }
Lee Thomasoned5c8792012-10-12 10:09:48 -0700288 _mem = newMem;
Lee Thomason624d43f2012-10-12 10:58:48 -0700289 _allocated = newAllocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700290 }
291 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800292
Lee Thomason624d43f2012-10-12 10:58:48 -0700293 T* _mem;
294 T _pool[INIT];
295 int _allocated; // objects allocated
296 int _size; // number objects in use
Lee Thomason2c85a712012-01-31 08:24:24 -0800297};
298
Lee Thomason50adb4c2012-02-13 15:07:09 -0800299
U-Stream\Leeae25a442012-02-17 17:48:16 -0800300/*
Thomas Roß08bdf502012-05-12 14:21:23 +0200301 Parent virtual class of a pool for fast allocation
U-Stream\Leeae25a442012-02-17 17:48:16 -0800302 and deallocation of objects.
303*/
PKEuS95060352013-07-26 10:42:44 +0200304class MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800305{
306public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700307 MemPool() {}
308 virtual ~MemPool() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800309
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700310 virtual int ItemSize() const = 0;
311 virtual void* Alloc() = 0;
312 virtual void Free( void* ) = 0;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800313 virtual void SetTracked() = 0;
Lee Thomasond1983222012-02-06 08:41:24 -0800314};
315
Lee Thomason50adb4c2012-02-13 15:07:09 -0800316
U-Stream\Leeae25a442012-02-17 17:48:16 -0800317/*
318 Template child class to create pools of the correct type.
319*/
Lee Thomasond1983222012-02-06 08:41:24 -0800320template< int SIZE >
PKEuS95060352013-07-26 10:42:44 +0200321class MemPoolT : public MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800322{
323public:
Lee Thomason5b0a6772012-11-19 13:54:42 -0800324 MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700325 ~MemPoolT() {
326 // Delete the blocks.
Lee Thomason624d43f2012-10-12 10:58:48 -0700327 for( int i=0; i<_blockPtrs.Size(); ++i ) {
328 delete _blockPtrs[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700329 }
330 }
Lee Thomasond1983222012-02-06 08:41:24 -0800331
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700332 virtual int ItemSize() const {
333 return SIZE;
334 }
335 int CurrentAllocs() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700336 return _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700337 }
Lee Thomasond1983222012-02-06 08:41:24 -0800338
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700339 virtual void* Alloc() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700340 if ( !_root ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700341 // Need a new block.
342 Block* block = new Block();
Lee Thomason624d43f2012-10-12 10:58:48 -0700343 _blockPtrs.Push( block );
Lee Thomasond1983222012-02-06 08:41:24 -0800344
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700345 for( int i=0; i<COUNT-1; ++i ) {
346 block->chunk[i].next = &block->chunk[i+1];
347 }
348 block->chunk[COUNT-1].next = 0;
Lee Thomason624d43f2012-10-12 10:58:48 -0700349 _root = block->chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700350 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700351 void* result = _root;
352 _root = _root->next;
Lee Thomason455c9d42012-02-06 09:14:14 -0800353
Lee Thomason624d43f2012-10-12 10:58:48 -0700354 ++_currentAllocs;
355 if ( _currentAllocs > _maxAllocs ) {
356 _maxAllocs = _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700357 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700358 _nAllocs++;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800359 _nUntracked++;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700360 return result;
361 }
362 virtual void Free( void* mem ) {
363 if ( !mem ) {
364 return;
365 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700366 --_currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700367 Chunk* chunk = (Chunk*)mem;
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700368#ifdef DEBUG
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700369 memset( chunk, 0xfe, sizeof(Chunk) );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700370#endif
Lee Thomason624d43f2012-10-12 10:58:48 -0700371 chunk->next = _root;
372 _root = chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700373 }
374 void Trace( const char* name ) {
375 printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
Lee Thomason624d43f2012-10-12 10:58:48 -0700376 name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700377 }
Lee Thomasond1983222012-02-06 08:41:24 -0800378
Lee Thomason5b0a6772012-11-19 13:54:42 -0800379 void SetTracked() {
380 _nUntracked--;
381 }
382
383 int Untracked() const {
384 return _nUntracked;
385 }
386
Lee Thomason (grinliz)ac83b4e2013-02-01 09:02:34 -0800387 // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
388 // The test file is large, 170k.
389 // Release: VS2010 gcc(no opt)
390 // 1k: 4000
391 // 2k: 4000
392 // 4k: 3900 21000
393 // 16k: 5200
394 // 32k: 4300
395 // 64k: 4000 21000
396 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 +0200397
Lee Thomasond1983222012-02-06 08:41:24 -0800398private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700399 union Chunk {
Lee Thomason624d43f2012-10-12 10:58:48 -0700400 Chunk* next;
401 char mem[SIZE];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700402 };
403 struct Block {
Lee Thomason (grinliz)856da212012-10-19 09:08:15 -0700404 Chunk chunk[COUNT];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700405 };
Lee Thomason624d43f2012-10-12 10:58:48 -0700406 DynArray< Block*, 10 > _blockPtrs;
407 Chunk* _root;
Lee Thomason455c9d42012-02-06 09:14:14 -0800408
Lee Thomason624d43f2012-10-12 10:58:48 -0700409 int _currentAllocs;
410 int _nAllocs;
411 int _maxAllocs;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800412 int _nUntracked;
Lee Thomasond1983222012-02-06 08:41:24 -0800413};
414
Lee Thomason2c85a712012-01-31 08:24:24 -0800415
Lee Thomason56bdd022012-02-09 18:16:58 -0800416
417/**
418 Implements the interface to the "Visitor pattern" (see the Accept() method.)
419 If you call the Accept() method, it requires being passed a XMLVisitor
420 class to handle callbacks. For nodes that contain other nodes (Document, Element)
Thomas Roß08bdf502012-05-12 14:21:23 +0200421 you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
Lee Thomason56bdd022012-02-09 18:16:58 -0800422 are simply called with Visit().
423
424 If you return 'true' from a Visit method, recursive parsing will continue. If you return
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700425 false, <b>no children of this node or its siblings</b> will be visited.
Lee Thomason56bdd022012-02-09 18:16:58 -0800426
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700427 All flavors of Visit methods have a default implementation that returns 'true' (continue
Lee Thomason56bdd022012-02-09 18:16:58 -0800428 visiting). You need to only override methods that are interesting to you.
429
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600430 Generally Accept() is called on the XMLDocument, although all nodes support visiting.
Lee Thomason56bdd022012-02-09 18:16:58 -0800431
432 You should never change the document from a callback.
433
434 @sa XMLNode::Accept()
435*/
PKEuS16ed47d2013-07-06 12:02:43 +0200436class TINYXML2_LIB XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800437{
438public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700439 virtual ~XMLVisitor() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800440
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700441 /// Visit a document.
442 virtual bool VisitEnter( const XMLDocument& /*doc*/ ) {
443 return true;
444 }
445 /// Visit a document.
446 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
447 return true;
448 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800449
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700450 /// Visit an element.
451 virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ ) {
452 return true;
453 }
454 /// Visit an element.
455 virtual bool VisitExit( const XMLElement& /*element*/ ) {
456 return true;
457 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800458
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700459 /// Visit a declaration.
460 virtual bool Visit( const XMLDeclaration& /*declaration*/ ) {
461 return true;
462 }
463 /// Visit a text node.
464 virtual bool Visit( const XMLText& /*text*/ ) {
465 return true;
466 }
467 /// Visit a comment node.
468 virtual bool Visit( const XMLComment& /*comment*/ ) {
469 return true;
470 }
471 /// Visit an unknown node.
472 virtual bool Visit( const XMLUnknown& /*unknown*/ ) {
473 return true;
474 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800475};
476
477
U-Stream\Leeae25a442012-02-17 17:48:16 -0800478/*
479 Utility functionality.
480*/
Lee Thomason56bdd022012-02-09 18:16:58 -0800481class XMLUtil
482{
Lee Thomasond1983222012-02-06 08:41:24 -0800483public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700484 // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
485 // correct, but simple, and usually works.
486 static const char* SkipWhiteSpace( const char* p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100487 while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<const unsigned char*>(p) ) ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700488 ++p;
489 }
490 return p;
491 }
492 static char* SkipWhiteSpace( char* p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100493 while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<unsigned char*>(p) ) ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700494 ++p;
495 }
496 return p;
497 }
498 static bool IsWhiteSpace( char p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100499 return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700500 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200501
502 inline static bool IsNameStartChar( unsigned char ch ) {
503 return ( ( ch < 128 ) ? isalpha( ch ) : 1 )
504 || ch == ':'
505 || ch == '_';
506 }
507
508 inline static bool IsNameChar( unsigned char ch ) {
509 return IsNameStartChar( ch )
510 || isdigit( ch )
511 || ch == '.'
512 || ch == '-';
513 }
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800514
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700515 inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
516 int n = 0;
517 if ( p == q ) {
518 return true;
519 }
520 while( *p && *q && *p == *q && n<nChar ) {
521 ++p;
522 ++q;
523 ++n;
524 }
525 if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
526 return true;
527 }
528 return false;
529 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200530
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700531 inline static int IsUTF8Continuation( const char p ) {
532 return p & 0x80;
533 }
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800534
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700535 static const char* ReadBOM( const char* p, bool* hasBOM );
536 // p is the starting location,
537 // the UTF-8 value of the entity will be placed in value, and length filled in.
538 static const char* GetCharacterRef( const char* p, char* value, int* length );
539 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
Lee Thomason21be8822012-07-15 17:27:22 -0700540
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700541 // converts primitive types to strings
542 static void ToStr( int v, char* buffer, int bufferSize );
Uli Kusterer664d0562014-01-21 12:24:47 +0100543 static void ToStr( long long v, char* buffer, int bufferSize );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700544 static void ToStr( unsigned v, char* buffer, int bufferSize );
545 static void ToStr( bool v, char* buffer, int bufferSize );
546 static void ToStr( float v, char* buffer, int bufferSize );
547 static void ToStr( double v, char* buffer, int bufferSize );
Lee Thomason21be8822012-07-15 17:27:22 -0700548
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700549 // converts strings to primitive types
550 static bool ToInt( const char* str, int* value );
Uli Kusterer664d0562014-01-21 12:24:47 +0100551 static bool ToLongLong( const char* str, long long* value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700552 static bool ToUnsigned( const char* str, unsigned* value );
553 static bool ToBool( const char* str, bool* value );
554 static bool ToFloat( const char* str, float* value );
555 static bool ToDouble( const char* str, double* value );
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800556};
557
Lee Thomason5cae8972012-01-24 18:03:07 -0800558
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800559/** XMLNode is a base class for every object that is in the
560 XML Document Object Model (DOM), except XMLAttributes.
561 Nodes have siblings, a parent, and children which can
562 be navigated. A node is always in a XMLDocument.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700563 The type of a XMLNode can be queried, and it can
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800564 be cast to its more defined type.
565
Thomas Roß08bdf502012-05-12 14:21:23 +0200566 A XMLDocument allocates memory for all its Nodes.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800567 When the XMLDocument gets deleted, all its Nodes
568 will also be deleted.
569
570 @verbatim
571 A Document can contain: Element (container or leaf)
572 Comment (leaf)
573 Unknown (leaf)
574 Declaration( leaf )
575
576 An Element can contain: Element (container or leaf)
577 Text (leaf)
578 Attributes (not on tree)
579 Comment (leaf)
580 Unknown (leaf)
581
582 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800583*/
PKEuS16ed47d2013-07-06 12:02:43 +0200584class TINYXML2_LIB XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800585{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700586 friend class XMLDocument;
587 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800588public:
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800589
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700590 /// Get the XMLDocument that owns this XMLNode.
591 const XMLDocument* GetDocument() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700592 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700593 }
594 /// Get the XMLDocument that owns this XMLNode.
595 XMLDocument* GetDocument() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700596 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700597 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800598
Lee Thomason2fa81722012-11-09 12:37:46 -0800599 /// Safely cast to an Element, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700600 virtual XMLElement* ToElement() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100601 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700602 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800603 /// Safely cast to Text, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700604 virtual XMLText* ToText() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100605 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700606 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800607 /// Safely cast to a Comment, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700608 virtual XMLComment* ToComment() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100609 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700610 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800611 /// Safely cast to a Document, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700612 virtual XMLDocument* ToDocument() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100613 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700614 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800615 /// Safely cast to a Declaration, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700616 virtual XMLDeclaration* ToDeclaration() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100617 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700618 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800619 /// Safely cast to an Unknown, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700620 virtual XMLUnknown* ToUnknown() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100621 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700622 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800623
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700624 virtual const XMLElement* ToElement() const {
625 return 0;
626 }
627 virtual const XMLText* ToText() const {
628 return 0;
629 }
630 virtual const XMLComment* ToComment() const {
631 return 0;
632 }
633 virtual const XMLDocument* ToDocument() const {
634 return 0;
635 }
636 virtual const XMLDeclaration* ToDeclaration() const {
637 return 0;
638 }
639 virtual const XMLUnknown* ToUnknown() const {
640 return 0;
641 }
Lee Thomason751da522012-02-10 08:50:51 -0800642
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700643 /** The meaning of 'value' changes for the specific type.
644 @verbatim
645 Document: empty
646 Element: name of the element
647 Comment: the comment text
648 Unknown: the tag contents
649 Text: the text string
650 @endverbatim
651 */
Michael Daumling21626882013-10-22 17:03:37 +0200652 const char* Value() const;
MortenMacFly4ee49f12013-01-14 20:03:14 +0100653
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700654 /** Set the Value of an XML node.
655 @sa Value()
656 */
657 void SetValue( const char* val, bool staticMem=false );
Lee Thomason2c85a712012-01-31 08:24:24 -0800658
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700659 /// Get the parent of this node on the DOM.
660 const XMLNode* Parent() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700661 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700662 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100663
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700664 XMLNode* Parent() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700665 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700666 }
Lee Thomason751da522012-02-10 08:50:51 -0800667
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700668 /// Returns true if this node has no children.
669 bool NoChildren() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700670 return !_firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700671 }
Lee Thomason751da522012-02-10 08:50:51 -0800672
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700673 /// Get the first child node, or null if none exists.
674 const XMLNode* FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700675 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700676 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100677
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700678 XMLNode* FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700679 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700680 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100681
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700682 /** Get the first child element, or optionally the first child
683 element with the specified name.
684 */
685 const XMLElement* FirstChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700686
687 XMLElement* FirstChildElement( const char* value=0 ) {
688 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700689 }
Lee Thomason3f57d272012-01-11 15:30:03 -0800690
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700691 /// Get the last child node, or null if none exists.
692 const XMLNode* LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700693 return _lastChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700694 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700695
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700696 XMLNode* LastChild() {
697 return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
698 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800699
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700700 /** Get the last child element or optionally the last child
701 element with the specified name.
702 */
703 const XMLElement* LastChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700704
705 XMLElement* LastChildElement( const char* value=0 ) {
706 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700707 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700708
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700709 /// Get the previous (left) sibling node of this node.
710 const XMLNode* PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700711 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700712 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700713
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700714 XMLNode* PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700715 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700716 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800717
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700718 /// Get the previous (left) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700719 const XMLElement* PreviousSiblingElement( const char* value=0 ) const ;
Lee Thomason624d43f2012-10-12 10:58:48 -0700720
721 XMLElement* PreviousSiblingElement( const char* value=0 ) {
722 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700723 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700724
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700725 /// Get the next (right) sibling node of this node.
726 const XMLNode* NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700727 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700728 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700729
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700730 XMLNode* NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700731 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700732 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700733
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700734 /// Get the next (right) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700735 const XMLElement* NextSiblingElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700736
737 XMLElement* NextSiblingElement( const char* value=0 ) {
738 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700739 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800740
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700741 /**
742 Add a child node as the last (right) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200743 If the child node is already part of the document,
744 it is moved from its old location to the new location.
745 Returns the addThis argument or 0 if the node does not
746 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700747 */
748 XMLNode* InsertEndChild( XMLNode* addThis );
Lee Thomason618dbf82012-02-28 12:34:27 -0800749
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700750 XMLNode* LinkEndChild( XMLNode* addThis ) {
751 return InsertEndChild( addThis );
752 }
753 /**
754 Add a child node as the first (left) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200755 If the child node is already part of the document,
756 it is moved from its old location to the new location.
757 Returns the addThis argument or 0 if the node does not
758 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700759 */
760 XMLNode* InsertFirstChild( XMLNode* addThis );
761 /**
762 Add a node after the specified child node.
Michael Daumlinged523282013-10-23 07:47:29 +0200763 If the child node is already part of the document,
764 it is moved from its old location to the new location.
765 Returns the addThis argument or 0 if the afterThis node
766 is not a child of this node, or if the node does not
767 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700768 */
769 XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700770
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700771 /**
772 Delete all the children of this node.
773 */
774 void DeleteChildren();
U-Stream\Leeae25a442012-02-17 17:48:16 -0800775
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700776 /**
777 Delete a child of this node.
778 */
779 void DeleteChild( XMLNode* node );
Lee Thomason56bdd022012-02-09 18:16:58 -0800780
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700781 /**
782 Make a copy of this node, but not its children.
783 You may pass in a Document pointer that will be
784 the owner of the new Node. If the 'document' is
785 null, then the node returned will be allocated
786 from the current Document. (this->GetDocument())
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800787
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700788 Note: if called on a XMLDocument, this will return null.
789 */
790 virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800791
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700792 /**
793 Test if 2 nodes are the same, but don't test children.
794 The 2 nodes do not need to be in the same Document.
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800795
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700796 Note: if called on a XMLDocument, this will return false.
797 */
798 virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800799
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600800 /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700801 XML tree will be conditionally visited and the host will be called back
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600802 via the XMLVisitor interface.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800803
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600804 This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
805 the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700806 interface versus any other.)
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800807
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700808 The interface has been based on ideas from:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800809
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700810 - http://www.saxproject.org/
811 - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800812
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700813 Which are both good references for "visiting".
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800814
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700815 An example of using Accept():
816 @verbatim
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600817 XMLPrinter printer;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700818 tinyxmlDoc.Accept( &printer );
819 const char* xmlcstr = printer.CStr();
820 @endverbatim
821 */
822 virtual bool Accept( XMLVisitor* visitor ) const = 0;
Lee Thomason56bdd022012-02-09 18:16:58 -0800823
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700824 // internal
825 virtual char* ParseDeep( char*, StrPair* );
Lee Thomason3f57d272012-01-11 15:30:03 -0800826
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800827protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700828 XMLNode( XMLDocument* );
829 virtual ~XMLNode();
830 XMLNode( const XMLNode& ); // not supported
831 XMLNode& operator=( const XMLNode& ); // not supported
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700832
Lee Thomason624d43f2012-10-12 10:58:48 -0700833 XMLDocument* _document;
834 XMLNode* _parent;
835 mutable StrPair _value;
Lee Thomason3f57d272012-01-11 15:30:03 -0800836
Lee Thomason624d43f2012-10-12 10:58:48 -0700837 XMLNode* _firstChild;
838 XMLNode* _lastChild;
Lee Thomason3f57d272012-01-11 15:30:03 -0800839
Lee Thomason624d43f2012-10-12 10:58:48 -0700840 XMLNode* _prev;
841 XMLNode* _next;
Lee Thomason3f57d272012-01-11 15:30:03 -0800842
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800843private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700844 MemPool* _memPool;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700845 void Unlink( XMLNode* child );
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800846};
847
848
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800849/** XML text.
850
851 Note that a text node can have child element nodes, for example:
852 @verbatim
853 <root>This is <b>bold</b></root>
854 @endverbatim
855
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700856 A text node can have 2 ways to output the next. "normal" output
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800857 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 -0700858 you generally want to leave it alone, but you can change the output mode with
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600859 SetCData() and query it with CData().
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800860*/
PKEuS16ed47d2013-07-06 12:02:43 +0200861class TINYXML2_LIB XMLText : public XMLNode
Lee Thomason5492a1c2012-01-23 15:32:10 -0800862{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700863 friend class XMLBase;
864 friend class XMLDocument;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800865public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700866 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -0800867
Lee Thomason624d43f2012-10-12 10:58:48 -0700868 virtual XMLText* ToText() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700869 return this;
870 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700871 virtual const XMLText* ToText() const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700872 return this;
873 }
Lee Thomason5492a1c2012-01-23 15:32:10 -0800874
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700875 /// Declare whether this should be CDATA or standard text.
Lee Thomason624d43f2012-10-12 10:58:48 -0700876 void SetCData( bool isCData ) {
877 _isCData = isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700878 }
879 /// Returns true if this is a CDATA text element.
880 bool CData() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700881 return _isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700882 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800883
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700884 char* ParseDeep( char*, StrPair* endTag );
885 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
886 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800887
Lee Thomason5492a1c2012-01-23 15:32:10 -0800888protected:
Lee Thomason624d43f2012-10-12 10:58:48 -0700889 XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700890 virtual ~XMLText() {}
891 XMLText( const XMLText& ); // not supported
892 XMLText& operator=( const XMLText& ); // not supported
Lee Thomason5492a1c2012-01-23 15:32:10 -0800893
894private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700895 bool _isCData;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800896};
897
898
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800899/** An XML Comment. */
PKEuS16ed47d2013-07-06 12:02:43 +0200900class TINYXML2_LIB XMLComment : public XMLNode
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800901{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700902 friend class XMLDocument;
Lee Thomason3f57d272012-01-11 15:30:03 -0800903public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700904 virtual XMLComment* ToComment() {
905 return this;
906 }
907 virtual const XMLComment* ToComment() const {
908 return this;
909 }
Lee Thomasonce0763e2012-01-11 15:43:54 -0800910
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700911 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800912
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700913 char* ParseDeep( char*, StrPair* endTag );
914 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
915 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomasonce0763e2012-01-11 15:43:54 -0800916
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800917protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700918 XMLComment( XMLDocument* doc );
919 virtual ~XMLComment();
920 XMLComment( const XMLComment& ); // not supported
921 XMLComment& operator=( const XMLComment& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800922
Lee Thomason3f57d272012-01-11 15:30:03 -0800923private:
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800924};
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800925
926
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800927/** In correct XML the declaration is the first entry in the file.
928 @verbatim
929 <?xml version="1.0" standalone="yes"?>
930 @endverbatim
931
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600932 TinyXML-2 will happily read or write files without a declaration,
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800933 however.
934
935 The text of the declaration isn't interpreted. It is parsed
936 and written as a string.
937*/
PKEuS16ed47d2013-07-06 12:02:43 +0200938class TINYXML2_LIB XMLDeclaration : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -0800939{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700940 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -0800941public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700942 virtual XMLDeclaration* ToDeclaration() {
943 return this;
944 }
945 virtual const XMLDeclaration* ToDeclaration() const {
946 return this;
947 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800948
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700949 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800950
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700951 char* ParseDeep( char*, StrPair* endTag );
952 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
953 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800954
955protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700956 XMLDeclaration( XMLDocument* doc );
957 virtual ~XMLDeclaration();
958 XMLDeclaration( const XMLDeclaration& ); // not supported
959 XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -0800960};
961
962
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600963/** Any tag that TinyXML-2 doesn't recognize is saved as an
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800964 unknown. It is a tag of text, but should not be modified.
965 It will be written back to the XML, unchanged, when the file
966 is saved.
967
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600968 DTD tags get thrown into XMLUnknowns.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800969*/
PKEuS16ed47d2013-07-06 12:02:43 +0200970class TINYXML2_LIB XMLUnknown : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -0800971{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700972 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -0800973public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700974 virtual XMLUnknown* ToUnknown() {
975 return this;
976 }
977 virtual const XMLUnknown* ToUnknown() const {
978 return this;
979 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800980
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700981 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800982
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700983 char* ParseDeep( char*, StrPair* endTag );
984 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
985 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800986
987protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700988 XMLUnknown( XMLDocument* doc );
989 virtual ~XMLUnknown();
990 XMLUnknown( const XMLUnknown& ); // not supported
991 XMLUnknown& operator=( const XMLUnknown& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -0800992};
993
994
Lee Thomason2fa81722012-11-09 12:37:46 -0800995enum XMLError {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700996 XML_NO_ERROR = 0,
997 XML_SUCCESS = 0,
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800998
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700999 XML_NO_ATTRIBUTE,
1000 XML_WRONG_ATTRIBUTE_TYPE,
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001001
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001002 XML_ERROR_FILE_NOT_FOUND,
1003 XML_ERROR_FILE_COULD_NOT_BE_OPENED,
1004 XML_ERROR_FILE_READ_ERROR,
1005 XML_ERROR_ELEMENT_MISMATCH,
1006 XML_ERROR_PARSING_ELEMENT,
1007 XML_ERROR_PARSING_ATTRIBUTE,
1008 XML_ERROR_IDENTIFYING_TAG,
1009 XML_ERROR_PARSING_TEXT,
1010 XML_ERROR_PARSING_CDATA,
1011 XML_ERROR_PARSING_COMMENT,
1012 XML_ERROR_PARSING_DECLARATION,
1013 XML_ERROR_PARSING_UNKNOWN,
1014 XML_ERROR_EMPTY_DOCUMENT,
1015 XML_ERROR_MISMATCHED_ELEMENT,
1016 XML_ERROR_PARSING,
Lee Thomason21be8822012-07-15 17:27:22 -07001017
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001018 XML_CAN_NOT_CONVERT_TEXT,
Uli Kustererff8e2042014-01-21 02:53:47 +01001019 XML_NO_TEXT_NODE,
1020 XML_NO_ELEMENT_NODE
Lee Thomason1ff38e02012-02-14 18:18:16 -08001021};
1022
1023
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001024/** An attribute is a name-value pair. Elements have an arbitrary
1025 number of attributes, each with a unique name.
1026
1027 @note The attributes are not XMLNodes. You may only query the
1028 Next() attribute in a list.
1029*/
PKEuS16ed47d2013-07-06 12:02:43 +02001030class TINYXML2_LIB XMLAttribute
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001031{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001032 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001033public:
Lee Thomason2fa81722012-11-09 12:37:46 -08001034 /// The name of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001035 const char* Name() const;
1036
Lee Thomason2fa81722012-11-09 12:37:46 -08001037 /// The value of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001038 const char* Value() const;
1039
Lee Thomason2fa81722012-11-09 12:37:46 -08001040 /// The next attribute in the list.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001041 const XMLAttribute* Next() const {
MortenMacFly4ee49f12013-01-14 20:03:14 +01001042 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001043 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001044
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001045 /** IntValue interprets the attribute as an integer, and returns the value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001046 If the value isn't an integer, 0 will be returned. There is no error checking;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001047 use QueryIntValue() if you need error checking.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001048 */
1049 int IntValue() const {
1050 int i=0;
1051 QueryIntValue( &i );
1052 return i;
1053 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001054 /// Query as an unsigned integer. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001055 unsigned UnsignedValue() const {
1056 unsigned i=0;
1057 QueryUnsignedValue( &i );
1058 return i;
1059 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001060 /// Query as a boolean. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001061 bool BoolValue() const {
1062 bool b=false;
1063 QueryBoolValue( &b );
1064 return b;
1065 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001066 /// Query as a double. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001067 double DoubleValue() const {
1068 double d=0;
1069 QueryDoubleValue( &d );
1070 return d;
1071 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001072 /// Query as a float. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001073 float FloatValue() const {
1074 float f=0;
1075 QueryFloatValue( &f );
1076 return f;
1077 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001078
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001079 /** QueryIntValue interprets the attribute as an integer, and returns the value
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001080 in the provided parameter. The function will return XML_NO_ERROR on success,
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001081 and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
1082 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001083 XMLError QueryIntValue( int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001084 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001085 XMLError QueryUnsignedValue( unsigned int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001086 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001087 XMLError QueryBoolValue( bool* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001088 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001089 XMLError QueryDoubleValue( double* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001090 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001091 XMLError QueryFloatValue( float* value ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -08001092
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001093 /// Set the attribute to a string value.
1094 void SetAttribute( const char* value );
1095 /// Set the attribute to value.
1096 void SetAttribute( int value );
1097 /// Set the attribute to value.
Uli Kusterer664d0562014-01-21 12:24:47 +01001098 void SetAttribute( long long value );
1099 /// Set the attribute to value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001100 void SetAttribute( unsigned value );
1101 /// Set the attribute to value.
1102 void SetAttribute( bool value );
1103 /// Set the attribute to value.
1104 void SetAttribute( double value );
1105 /// Set the attribute to value.
1106 void SetAttribute( float value );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001107
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001108private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001109 enum { BUF_SIZE = 200 };
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001110
Thomas Roß61892312013-05-12 14:07:38 +02001111 XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001112 virtual ~XMLAttribute() {}
Lee Thomason624d43f2012-10-12 10:58:48 -07001113
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001114 XMLAttribute( const XMLAttribute& ); // not supported
1115 void operator=( const XMLAttribute& ); // not supported
1116 void SetName( const char* name );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001117
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001118 char* ParseDeep( char* p, bool processEntities );
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001119
Lee Thomason624d43f2012-10-12 10:58:48 -07001120 mutable StrPair _name;
1121 mutable StrPair _value;
1122 XMLAttribute* _next;
1123 MemPool* _memPool;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001124};
1125
1126
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001127/** The element is a container class. It has a value, the element name,
1128 and can contain other elements, text, comments, and unknowns.
1129 Elements also contain an arbitrary number of attributes.
1130*/
PKEuS16ed47d2013-07-06 12:02:43 +02001131class TINYXML2_LIB XMLElement : public XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001132{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001133 friend class XMLBase;
1134 friend class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001135public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001136 /// Get the name of an element (which is the Value() of the node.)
1137 const char* Name() const {
1138 return Value();
1139 }
1140 /// Set the name of the element.
1141 void SetName( const char* str, bool staticMem=false ) {
1142 SetValue( str, staticMem );
1143 }
Lee Thomason2c85a712012-01-31 08:24:24 -08001144
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001145 virtual XMLElement* ToElement() {
1146 return this;
1147 }
1148 virtual const XMLElement* ToElement() const {
1149 return this;
1150 }
1151 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001152
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001153 /** Given an attribute name, Attribute() returns the value
1154 for the attribute of that name, or null if none
1155 exists. For example:
Lee Thomason92258152012-03-24 13:05:39 -07001156
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001157 @verbatim
1158 const char* value = ele->Attribute( "foo" );
1159 @endverbatim
Lee Thomason92258152012-03-24 13:05:39 -07001160
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001161 The 'value' parameter is normally null. However, if specified,
1162 the attribute will only be returned if the 'name' and 'value'
1163 match. This allow you to write code:
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001164
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001165 @verbatim
1166 if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
1167 @endverbatim
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001168
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001169 rather than:
1170 @verbatim
1171 if ( ele->Attribute( "foo" ) ) {
1172 if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
1173 }
1174 @endverbatim
1175 */
1176 const char* Attribute( const char* name, const char* value=0 ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001177
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001178 /** Given an attribute name, IntAttribute() returns the value
1179 of the attribute interpreted as an integer. 0 will be
1180 returned if there is an error. For a method with error
1181 checking, see QueryIntAttribute()
1182 */
1183 int IntAttribute( const char* name ) const {
1184 int i=0;
1185 QueryIntAttribute( name, &i );
1186 return i;
1187 }
1188 /// See IntAttribute()
1189 unsigned UnsignedAttribute( const char* name ) const {
1190 unsigned i=0;
1191 QueryUnsignedAttribute( name, &i );
1192 return i;
1193 }
1194 /// See IntAttribute()
1195 bool BoolAttribute( const char* name ) const {
1196 bool b=false;
1197 QueryBoolAttribute( name, &b );
1198 return b;
1199 }
1200 /// See IntAttribute()
1201 double DoubleAttribute( const char* name ) const {
1202 double d=0;
1203 QueryDoubleAttribute( name, &d );
1204 return d;
1205 }
1206 /// See IntAttribute()
1207 float FloatAttribute( const char* name ) const {
1208 float f=0;
1209 QueryFloatAttribute( name, &f );
1210 return f;
1211 }
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001212
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001213 /** Given an attribute name, QueryIntAttribute() returns
1214 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1215 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1216 doesn't exist. If successful, the result of the conversion
1217 will be written to 'value'. If not successful, nothing will
1218 be written to 'value'. This allows you to provide default
1219 value:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001220
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001221 @verbatim
1222 int value = 10;
1223 QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1224 @endverbatim
1225 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001226 XMLError QueryIntAttribute( const char* name, int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001227 const XMLAttribute* a = FindAttribute( name );
1228 if ( !a ) {
1229 return XML_NO_ATTRIBUTE;
1230 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001231 return a->QueryIntValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001232 }
1233 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001234 XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001235 const XMLAttribute* a = FindAttribute( name );
1236 if ( !a ) {
1237 return XML_NO_ATTRIBUTE;
1238 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001239 return a->QueryUnsignedValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001240 }
1241 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001242 XMLError QueryBoolAttribute( const char* name, bool* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001243 const XMLAttribute* a = FindAttribute( name );
1244 if ( !a ) {
1245 return XML_NO_ATTRIBUTE;
1246 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001247 return a->QueryBoolValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001248 }
1249 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001250 XMLError QueryDoubleAttribute( const char* name, double* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001251 const XMLAttribute* a = FindAttribute( name );
1252 if ( !a ) {
1253 return XML_NO_ATTRIBUTE;
1254 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001255 return a->QueryDoubleValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001256 }
1257 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001258 XMLError QueryFloatAttribute( const char* name, float* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001259 const XMLAttribute* a = FindAttribute( name );
1260 if ( !a ) {
1261 return XML_NO_ATTRIBUTE;
1262 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001263 return a->QueryFloatValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001264 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001265
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001266
1267 /** Given an attribute name, QueryAttribute() returns
1268 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1269 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1270 doesn't exist. It is overloaded for the primitive types,
1271 and is a generally more convenient replacement of
1272 QueryIntAttribute() and related functions.
1273
1274 If successful, the result of the conversion
1275 will be written to 'value'. If not successful, nothing will
1276 be written to 'value'. This allows you to provide default
1277 value:
1278
1279 @verbatim
1280 int value = 10;
1281 QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1282 @endverbatim
1283 */
1284 int QueryAttribute( const char* name, int* value ) const {
1285 return QueryIntAttribute( name, value );
1286 }
1287
1288 int QueryAttribute( const char* name, unsigned int* value ) const {
1289 return QueryUnsignedAttribute( name, value );
1290 }
1291
1292 int QueryAttribute( const char* name, bool* value ) const {
1293 return QueryBoolAttribute( name, value );
1294 }
1295
1296 int QueryAttribute( const char* name, double* value ) const {
1297 return QueryDoubleAttribute( name, value );
1298 }
1299
1300 int QueryAttribute( const char* name, float* value ) const {
1301 return QueryFloatAttribute( name, value );
1302 }
1303
1304 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001305 void SetAttribute( const char* name, const char* value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001306 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001307 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001308 }
1309 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001310 void SetAttribute( const char* name, int value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001311 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001312 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001313 }
1314 /// Sets the named attribute to value.
Uli Kusterer664d0562014-01-21 12:24:47 +01001315 void SetAttribute( const char* name, long long value ) {
1316 XMLAttribute* a = FindOrCreateAttribute( name );
1317 a->SetAttribute( value );
1318 }
1319 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001320 void SetAttribute( const char* name, unsigned value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001321 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001322 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001323 }
1324 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001325 void SetAttribute( const char* name, bool value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001326 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001327 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001328 }
1329 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001330 void SetAttribute( const char* name, double value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001331 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001332 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001333 }
Lee Thomasonc3708cc2014-01-14 12:30:03 -08001334 /// Sets the named attribute to value.
1335 void SetAttribute( const char* name, float value ) {
1336 XMLAttribute* a = FindOrCreateAttribute( name );
1337 a->SetAttribute( value );
1338 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001339
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001340 /**
1341 Delete an attribute.
1342 */
1343 void DeleteAttribute( const char* name );
Lee Thomason751da522012-02-10 08:50:51 -08001344
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001345 /// Return the first attribute in the list.
1346 const XMLAttribute* FirstAttribute() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001347 return _rootAttribute;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001348 }
1349 /// Query a specific attribute in the list.
1350 const XMLAttribute* FindAttribute( const char* name ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001351
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001352 /** Convenience function for easy access to the text inside an element. Although easy
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001353 and concise, GetText() is limited compared to getting the XMLText child
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001354 and accessing it directly.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001355
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001356 If the first child of 'this' is a XMLText, the GetText()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001357 returns the character string of the Text node, else null is returned.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001358
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001359 This is a convenient method for getting the text of simple contained text:
1360 @verbatim
1361 <foo>This is text</foo>
1362 const char* str = fooElement->GetText();
1363 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001364
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001365 'str' will be a pointer to "This is text".
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001366
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001367 Note that this function can be misleading. If the element foo was created from
1368 this XML:
1369 @verbatim
1370 <foo><b>This is text</b></foo>
1371 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001372
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001373 then the value of str would be null. The first child node isn't a text node, it is
1374 another element. From this XML:
1375 @verbatim
1376 <foo>This is <b>text</b></foo>
1377 @endverbatim
1378 GetText() will return "This is ".
1379 */
1380 const char* GetText() const;
Lee Thomason751da522012-02-10 08:50:51 -08001381
Uli Kusterer85fff5e2014-01-21 01:35:30 +01001382 /** Convenience function for easy access to the text inside an element. Although easy
1383 and concise, SetText() is limited compared to creating an XMLText child
1384 and mutating it directly.
1385
1386 If the first child of 'this' is a XMLText, SetText() sets its value to
1387 the given string, otherwise it will create a first child that is an XMLText.
1388
1389 This is a convenient method for setting the text of simple contained text:
1390 @verbatim
1391 <foo>This is text</foo>
1392 fooElement->SetText( "Hullaballoo!" );
1393 <foo>Hullaballoo!</foo>
1394 @endverbatim
1395
1396 Note that this function can be misleading. If the element foo was created from
1397 this XML:
1398 @verbatim
1399 <foo><b>This is text</b></foo>
1400 @endverbatim
1401
1402 then it will not change "This is text", but rather prefix it with a text element:
1403 @verbatim
1404 <foo>Hullaballoo!<b>This is text</b></foo>
1405 @endverbatim
1406
1407 For this XML:
1408 @verbatim
1409 <foo />
1410 @endverbatim
1411 SetText() will generate
1412 @verbatim
1413 <foo>Hullaballoo!</foo>
1414 @endverbatim
1415 */
Uli Kusterer8fe342a2014-01-21 01:12:47 +01001416 void SetText( const char* inText );
1417
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001418 /// Sets the text to the given number.
1419 void SetText( int inNum );
1420
1421 /// Sets the text to the given number.
1422 void SetText( unsigned inNum );
1423
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001424 /// Sets the text to the given double.
1425 void SetText( double inNum );
1426
1427 /// Sets the text to the given float.
1428 void SetText( float inNum );
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001429
Uli Kusterer664d0562014-01-21 12:24:47 +01001430 /// Sets the text to the given long long.
1431 void SetText( long long inNum );
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001432
1433 /// Convenience for QueryIntText when you don't care if the text won't convert.
1434 int IntText()
1435 {
1436 int i = 0;
1437 QueryIntText( &i );
1438 return i;
1439 }
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001440
Uli Kusterer664d0562014-01-21 12:24:47 +01001441 /// Convenience for QueryLongLongText when you don't care if the text won't convert.
1442 long long LongLongText()
1443 {
1444 long long i = 0;
1445 QueryLongLongText( &i );
1446 return i;
1447 }
1448
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001449 /// Convenience for QueryUnsignedText when you don't care if the text won't convert.
1450 unsigned UnsignedText()
1451 {
1452 unsigned i = 0;
1453 QueryUnsignedText( &i );
1454 return i;
1455 }
1456
1457 /// Convenience for QueryDoubleText when you don't care if the text won't convert.
1458 double DoubleText()
1459 {
1460 double i = 0;
1461 QueryDoubleText( &i );
1462 return i;
1463 }
1464
1465 /// Convenience for QueryFloatText when you don't care if the text won't convert.
1466 float FloatText()
1467 {
1468 float i = 0;
1469 QueryFloatText( &i );
1470 return i;
1471 }
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001472
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001473 /// Adds a sub-element equivalent to the given boolean.
Uli Kustererff8e2042014-01-21 02:53:47 +01001474 void SetBoolFirstChild( bool inBool );
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001475
Uli Kustererff8e2042014-01-21 02:53:47 +01001476 /// Looks for a &lt;true /&gt; or &lt;false /&gt; as the first child and returns the corresponding bool.
1477 bool BoolFirstChild()
1478 {
1479 bool b = false;
1480 QueryBoolFirstChild(&b);
1481 return b;
1482 }
1483
1484 XMLError QueryBoolFirstChild( bool *outBool );
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001485
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001486 /**
1487 Convenience method to query the value of a child text node. This is probably best
1488 shown by example. Given you have a document is this form:
1489 @verbatim
1490 <point>
1491 <x>1</x>
1492 <y>1.4</y>
1493 </point>
1494 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001495
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001496 The QueryIntText() and similar functions provide a safe and easier way to get to the
1497 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001498
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001499 @verbatim
1500 int x = 0;
1501 float y = 0; // types of x and y are contrived for example
1502 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1503 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1504 xElement->QueryIntText( &x );
1505 yElement->QueryFloatText( &y );
1506 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001507
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001508 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1509 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 -07001510
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001511 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001512 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001513 /// See QueryIntText()
Uli Kusterer664d0562014-01-21 12:24:47 +01001514 XMLError QueryLongLongText( long long* ival ) const;
1515 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001516 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001517 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001518 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001519 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001520 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001521 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001522 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001523
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001524 // internal:
1525 enum {
1526 OPEN, // <foo>
1527 CLOSED, // <foo/>
1528 CLOSING // </foo>
1529 };
1530 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001531 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001532 }
1533 char* ParseDeep( char* p, StrPair* endTag );
1534 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1535 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001536
Lee Thomason50adb4c2012-02-13 15:07:09 -08001537private:
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001538 enum { BUF_SIZE = 200 };
1539
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001540 XMLElement( XMLDocument* doc );
1541 virtual ~XMLElement();
1542 XMLElement( const XMLElement& ); // not supported
1543 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001544
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001545 XMLAttribute* FindAttribute( const char* name );
1546 XMLAttribute* FindOrCreateAttribute( const char* name );
1547 //void LinkAttribute( XMLAttribute* attrib );
1548 char* ParseAttributes( char* p );
Lee Thomason67d61312012-01-24 16:01:51 -08001549
Lee Thomason624d43f2012-10-12 10:58:48 -07001550 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001551 // The attribute list is ordered; there is no 'lastAttribute'
1552 // because the list needs to be scanned for dupes before adding
1553 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001554 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001555};
1556
1557
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001558enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001559 PRESERVE_WHITESPACE,
1560 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001561};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001562
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001563
1564/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001565 It can be saved, loaded, and printed to the screen.
1566 All Nodes are connected and allocated to a Document.
1567 If the Document is deleted, all its Nodes are also deleted.
1568*/
PKEuS16ed47d2013-07-06 12:02:43 +02001569class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001570{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001571 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001572public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001573 /// constructor
1574 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1575 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001576
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001577 virtual XMLDocument* ToDocument() {
1578 return this;
1579 }
1580 virtual const XMLDocument* ToDocument() const {
1581 return this;
1582 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001583
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001584 /**
1585 Parse an XML file from a character string.
1586 Returns XML_NO_ERROR (0) on success, or
1587 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001588
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001589 You may optionally pass in the 'nBytes', which is
1590 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001591 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001592 null terminated string.
1593 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001594 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001595
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001596 /**
1597 Load an XML file from disk.
1598 Returns XML_NO_ERROR (0) on success, or
1599 an errorID.
1600 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001601 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001602
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001603 /**
1604 Load an XML file from disk. You are responsible
1605 for providing and closing the FILE*.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001606
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001607 Returns XML_NO_ERROR (0) on success, or
1608 an errorID.
1609 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001610 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001611
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001612 /**
1613 Save the XML file to disk.
1614 Returns XML_NO_ERROR (0) on success, or
1615 an errorID.
1616 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001617 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001618
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001619 /**
1620 Save the XML file to disk. You are responsible
1621 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001622
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001623 Returns XML_NO_ERROR (0) on success, or
1624 an errorID.
1625 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001626 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001627
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001628 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001629 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001630 }
1631 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001632 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001633 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001634
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001635 /**
1636 Returns true if this document has a leading Byte Order Mark of UTF8.
1637 */
1638 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001639 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001640 }
1641 /** Sets whether to write the BOM when writing the file.
1642 */
1643 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001644 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001645 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001646
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001647 /** Return the root element of DOM. Equivalent to FirstChildElement().
1648 To get the first node, use FirstChild().
1649 */
1650 XMLElement* RootElement() {
1651 return FirstChildElement();
1652 }
1653 const XMLElement* RootElement() const {
1654 return FirstChildElement();
1655 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001656
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001657 /** Print the Document. If the Printer is not provided, it will
1658 print to stdout. If you provide Printer, this can print to a file:
1659 @verbatim
1660 XMLPrinter printer( fp );
1661 doc.Print( &printer );
1662 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001663
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001664 Or you can use a printer to print to memory:
1665 @verbatim
1666 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001667 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001668 // printer.CStr() has a const char* to the XML
1669 @endverbatim
1670 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001671 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001672 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001673
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001674 /**
1675 Create a new Element associated with
1676 this Document. The memory for the Element
1677 is managed by the Document.
1678 */
1679 XMLElement* NewElement( const char* name );
1680 /**
1681 Create a new Comment associated with
1682 this Document. The memory for the Comment
1683 is managed by the Document.
1684 */
1685 XMLComment* NewComment( const char* comment );
1686 /**
1687 Create a new Text associated with
1688 this Document. The memory for the Text
1689 is managed by the Document.
1690 */
1691 XMLText* NewText( const char* text );
1692 /**
1693 Create a new Declaration associated with
1694 this Document. The memory for the object
1695 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001696
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001697 If the 'text' param is null, the standard
1698 declaration is used.:
1699 @verbatim
1700 <?xml version="1.0" encoding="UTF-8"?>
1701 @endverbatim
1702 */
1703 XMLDeclaration* NewDeclaration( const char* text=0 );
1704 /**
1705 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001706 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001707 is managed by the Document.
1708 */
1709 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001710
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001711 /**
1712 Delete a node associated with this document.
1713 It will be unlinked from the DOM.
1714 */
1715 void DeleteNode( XMLNode* node ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001716 node->_parent->DeleteChild( node );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001717 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001718
Lee Thomason2fa81722012-11-09 12:37:46 -08001719 void SetError( XMLError error, const char* str1, const char* str2 );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001720
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001721 /// Return true if there was an error parsing the document.
1722 bool Error() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001723 return _errorID != XML_NO_ERROR;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001724 }
1725 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001726 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001727 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001728 }
1729 /// Return a possibly helpful diagnostic location or string.
1730 const char* GetErrorStr1() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001731 return _errorStr1;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001732 }
1733 /// Return a possibly helpful secondary diagnostic location or string.
1734 const char* GetErrorStr2() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001735 return _errorStr2;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001736 }
1737 /// If there is an error, print it to stdout.
1738 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001739
1740 /// Clear the document, resetting it to the initial state.
1741 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001742
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001743 // internal
1744 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001745
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001746 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1747 return 0;
1748 }
1749 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1750 return false;
1751 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001752
Lee Thomason3f57d272012-01-11 15:30:03 -08001753private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001754 XMLDocument( const XMLDocument& ); // not supported
1755 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001756
Lee Thomason2fa81722012-11-09 12:37:46 -08001757 bool _writeBOM;
1758 bool _processEntities;
1759 XMLError _errorID;
1760 Whitespace _whitespace;
Lee Thomason624d43f2012-10-12 10:58:48 -07001761 const char* _errorStr1;
1762 const char* _errorStr2;
Lee Thomason2fa81722012-11-09 12:37:46 -08001763 char* _charBuffer;
Lee Thomasond1983222012-02-06 08:41:24 -08001764
Lee Thomason624d43f2012-10-12 10:58:48 -07001765 MemPoolT< sizeof(XMLElement) > _elementPool;
1766 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1767 MemPoolT< sizeof(XMLText) > _textPool;
1768 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason5cae8972012-01-24 18:03:07 -08001769};
1770
Lee Thomason7c913cd2012-01-26 18:32:34 -08001771
Lee Thomason3ffdd392012-03-28 17:27:55 -07001772/**
1773 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001774 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001775 DOM structure. It is a separate utility class.
1776
1777 Take an example:
1778 @verbatim
1779 <Document>
1780 <Element attributeA = "valueA">
1781 <Child attributeB = "value1" />
1782 <Child attributeB = "value2" />
1783 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001784 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001785 @endverbatim
1786
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001787 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001788 easy to write a *lot* of code that looks like:
1789
1790 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001791 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001792 if ( root )
1793 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001794 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001795 if ( element )
1796 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001797 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001798 if ( child )
1799 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001800 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001801 if ( child2 )
1802 {
1803 // Finally do something useful.
1804 @endverbatim
1805
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001806 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001807 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001808 and correct to use:
1809
1810 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001811 XMLHandle docHandle( &document );
1812 XMLElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild().NextSibling().ToElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001813 if ( child2 )
1814 {
1815 // do something useful
1816 @endverbatim
1817
1818 Which is MUCH more concise and useful.
1819
1820 It is also safe to copy handles - internally they are nothing more than node pointers.
1821 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001822 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001823 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001824
1825 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001826*/
PKEuS16ed47d2013-07-06 12:02:43 +02001827class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001828{
1829public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001830 /// 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 -07001831 XMLHandle( XMLNode* node ) {
1832 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001833 }
1834 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001835 XMLHandle( XMLNode& node ) {
1836 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001837 }
1838 /// Copy constructor
1839 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001840 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001841 }
1842 /// Assignment
1843 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001844 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001845 return *this;
1846 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001847
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001848 /// Get the first child of this handle.
1849 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001850 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001851 }
1852 /// Get the first child element of this handle.
1853 XMLHandle FirstChildElement( const char* value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001854 return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001855 }
1856 /// Get the last child of this handle.
1857 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001858 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001859 }
1860 /// Get the last child element of this handle.
1861 XMLHandle LastChildElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001862 return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001863 }
1864 /// Get the previous sibling of this handle.
1865 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001866 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001867 }
1868 /// Get the previous sibling element of this handle.
1869 XMLHandle PreviousSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001870 return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001871 }
1872 /// Get the next sibling of this handle.
1873 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001874 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001875 }
1876 /// Get the next sibling element of this handle.
1877 XMLHandle NextSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001878 return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001879 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001880
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001881 /// Safe cast to XMLNode. This can return null.
1882 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001883 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001884 }
1885 /// Safe cast to XMLElement. This can return null.
1886 XMLElement* ToElement() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001887 return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001888 }
1889 /// Safe cast to XMLText. This can return null.
1890 XMLText* ToText() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001891 return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001892 }
1893 /// Safe cast to XMLUnknown. This can return null.
1894 XMLUnknown* ToUnknown() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001895 return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001896 }
1897 /// Safe cast to XMLDeclaration. This can return null.
1898 XMLDeclaration* ToDeclaration() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001899 return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001900 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001901
1902private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001903 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001904};
1905
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001906
1907/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001908 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1909 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001910*/
PKEuS16ed47d2013-07-06 12:02:43 +02001911class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001912{
1913public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001914 XMLConstHandle( const XMLNode* node ) {
1915 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001916 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001917 XMLConstHandle( const XMLNode& node ) {
1918 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001919 }
1920 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001921 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001922 }
Lee Thomason8b899812012-04-04 15:58:16 -07001923
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001924 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001925 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001926 return *this;
1927 }
Lee Thomason8b899812012-04-04 15:58:16 -07001928
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001929 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001930 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001931 }
1932 const XMLConstHandle FirstChildElement( const char* value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001933 return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001934 }
1935 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001936 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001937 }
1938 const XMLConstHandle LastChildElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001939 return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001940 }
1941 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001942 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001943 }
1944 const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001945 return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001946 }
1947 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001948 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001949 }
1950 const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001951 return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001952 }
Lee Thomason8b899812012-04-04 15:58:16 -07001953
1954
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001955 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001956 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001957 }
1958 const XMLElement* ToElement() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001959 return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001960 }
1961 const XMLText* ToText() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001962 return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001963 }
1964 const XMLUnknown* ToUnknown() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001965 return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001966 }
1967 const XMLDeclaration* ToDeclaration() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001968 return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001969 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08001970
Lee Thomason5cae8972012-01-24 18:03:07 -08001971private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001972 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08001973};
Lee Thomason6f381b72012-03-02 12:59:39 -08001974
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001975
1976/**
1977 Printing functionality. The XMLPrinter gives you more
1978 options than the XMLDocument::Print() method.
1979
1980 It can:
1981 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02001982 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001983 -# Print XML without a XMLDocument.
1984
1985 Print to Memory
1986
1987 @verbatim
1988 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001989 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02001990 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001991 @endverbatim
1992
1993 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001994
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001995 You provide the file pointer.
1996 @verbatim
1997 XMLPrinter printer( fp );
1998 doc.Print( &printer );
1999 @endverbatim
2000
2001 Print without a XMLDocument
2002
2003 When loading, an XML parser is very useful. However, sometimes
2004 when saving, it just gets in the way. The code is often set up
2005 for streaming, and constructing the DOM is just overhead.
2006
2007 The Printer supports the streaming case. The following code
2008 prints out a trivially simple XML file without ever creating
2009 an XML document.
2010
2011 @verbatim
2012 XMLPrinter printer( fp );
2013 printer.OpenElement( "foo" );
2014 printer.PushAttribute( "foo", "bar" );
2015 printer.CloseElement();
2016 @endverbatim
2017*/
PKEuS16ed47d2013-07-06 12:02:43 +02002018class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002019{
2020public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002021 /** Construct the printer. If the FILE* is specified,
2022 this will print to the FILE. Else it will print
2023 to memory, and the result is available in CStr().
2024 If 'compact' is set to true, then output is created
2025 with only required whitespace and newlines.
2026 */
PKEuS1bfb9542013-08-04 13:51:17 +02002027 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002028 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002029
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002030 /** If streaming, write the BOM and declaration. */
2031 void PushHeader( bool writeBOM, bool writeDeclaration );
2032 /** If streaming, start writing an element.
2033 The element must be closed with CloseElement()
2034 */
2035 void OpenElement( const char* name );
2036 /// If streaming, add an attribute to an open element.
2037 void PushAttribute( const char* name, const char* value );
2038 void PushAttribute( const char* name, int value );
2039 void PushAttribute( const char* name, unsigned value );
2040 void PushAttribute( const char* name, bool value );
2041 void PushAttribute( const char* name, double value );
2042 /// If streaming, close the Element.
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002043 virtual void CloseElement();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002044
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002045 /// Add a text node.
2046 void PushText( const char* text, bool cdata=false );
2047 /// Add a text node from an integer.
2048 void PushText( int value );
2049 /// Add a text node from an unsigned.
2050 void PushText( unsigned value );
2051 /// Add a text node from a bool.
2052 void PushText( bool value );
2053 /// Add a text node from a float.
2054 void PushText( float value );
2055 /// Add a text node from a double.
2056 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07002057
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002058 /// Add a comment
2059 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002060
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002061 void PushDeclaration( const char* value );
2062 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002063
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002064 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
2065 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
2066 return true;
2067 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002068
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002069 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
2070 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002071
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002072 virtual bool Visit( const XMLText& text );
2073 virtual bool Visit( const XMLComment& comment );
2074 virtual bool Visit( const XMLDeclaration& declaration );
2075 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002076
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002077 /**
2078 If in print to memory mode, return a pointer to
2079 the XML file in memory.
2080 */
2081 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002082 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002083 }
2084 /**
2085 If in print to memory mode, return the size
2086 of the XML file in memory. (Note the size returned
2087 includes the terminating null.)
2088 */
2089 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002090 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002091 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002092 /**
2093 If in print to memory mode, reset the buffer to the
2094 beginning.
2095 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08002096 void ClearBuffer() {
2097 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002098 _buffer.Push(0);
2099 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002100
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002101protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002102 void SealElement();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002103 bool _elementJustOpened;
2104 DynArray< const char*, 10 > _stack;
2105
2106private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002107 void PrintSpace( int depth );
2108 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
2109 void Print( const char* format, ... );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002110
Lee Thomason624d43f2012-10-12 10:58:48 -07002111 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01002112 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07002113 int _depth;
2114 int _textDepth;
2115 bool _processEntities;
2116 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002117
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002118 enum {
2119 ENTITY_RANGE = 64,
2120 BUF_SIZE = 200
2121 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002122 bool _entityFlag[ENTITY_RANGE];
2123 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002124
Lee Thomason624d43f2012-10-12 10:58:48 -07002125 DynArray< char, 20 > _buffer;
PKEuSe736f292012-07-16 03:27:55 -07002126#ifdef _MSC_VER
Lee Thomason624d43f2012-10-12 10:58:48 -07002127 DynArray< char, 20 > _accumulator;
PKEuSe736f292012-07-16 03:27:55 -07002128#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002129};
2130
2131
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002132} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002133
PKEuS95060352013-07-26 10:42:44 +02002134#if defined(_MSC_VER)
2135# pragma warning(pop)
2136#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002137
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002138#endif // TINYXML2_INCLUDED