blob: f9269a1aa4d119122998bf37d90bf24a315fd595 [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;
Lee Thomason5bb2d802014-01-24 10:42:57 -0800121static const int TIXML2_PATCH_VERSION = 14;
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 */
Lee Thomason5bb2d802014-01-24 10:42:57 -08001416 void SetText( const char* inText );
1417 /// Convenince method for setting text inside and element. See SetText() for important limitations.
1418 void SetText( int value );
1419 /// Convenince method for setting text inside and element. See SetText() for important limitations.
1420 void SetText( unsigned value );
1421 /// Convenince method for setting text inside and element. See SetText() for important limitations.
1422 void SetText( bool value );
1423 /// Convenince method for setting text inside and element. See SetText() for important limitations.
1424 void SetText( double value );
1425 /// Convenince method for setting text inside and element. See SetText() for important limitations.
1426 void SetText( float value );
Uli Kusterer8fe342a2014-01-21 01:12:47 +01001427
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001428 /// Sets the text to the given number.
1429 void SetText( int inNum );
1430
1431 /// Sets the text to the given number.
1432 void SetText( unsigned inNum );
1433
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001434 /// Sets the text to the given double.
1435 void SetText( double inNum );
1436
1437 /// Sets the text to the given float.
1438 void SetText( float inNum );
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001439
Uli Kusterer664d0562014-01-21 12:24:47 +01001440 /// Sets the text to the given long long.
1441 void SetText( long long inNum );
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001442
1443 /// Convenience for QueryIntText when you don't care if the text won't convert.
1444 int IntText()
1445 {
1446 int i = 0;
1447 QueryIntText( &i );
1448 return i;
1449 }
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001450
Uli Kusterer664d0562014-01-21 12:24:47 +01001451 /// Convenience for QueryLongLongText when you don't care if the text won't convert.
1452 long long LongLongText()
1453 {
1454 long long i = 0;
1455 QueryLongLongText( &i );
1456 return i;
1457 }
1458
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001459 /// Convenience for QueryUnsignedText when you don't care if the text won't convert.
1460 unsigned UnsignedText()
1461 {
1462 unsigned i = 0;
1463 QueryUnsignedText( &i );
1464 return i;
1465 }
1466
1467 /// Convenience for QueryDoubleText when you don't care if the text won't convert.
1468 double DoubleText()
1469 {
1470 double i = 0;
1471 QueryDoubleText( &i );
1472 return i;
1473 }
1474
1475 /// Convenience for QueryFloatText when you don't care if the text won't convert.
1476 float FloatText()
1477 {
1478 float i = 0;
1479 QueryFloatText( &i );
1480 return i;
1481 }
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001482
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001483 /// Adds a sub-element equivalent to the given boolean.
Uli Kustererff8e2042014-01-21 02:53:47 +01001484 void SetBoolFirstChild( bool inBool );
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001485
Uli Kustererff8e2042014-01-21 02:53:47 +01001486 /// Looks for a &lt;true /&gt; or &lt;false /&gt; as the first child and returns the corresponding bool.
1487 bool BoolFirstChild()
1488 {
1489 bool b = false;
1490 QueryBoolFirstChild(&b);
1491 return b;
1492 }
1493
1494 XMLError QueryBoolFirstChild( bool *outBool );
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001495
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001496 /**
1497 Convenience method to query the value of a child text node. This is probably best
1498 shown by example. Given you have a document is this form:
1499 @verbatim
1500 <point>
1501 <x>1</x>
1502 <y>1.4</y>
1503 </point>
1504 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001505
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001506 The QueryIntText() and similar functions provide a safe and easier way to get to the
1507 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001508
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001509 @verbatim
1510 int x = 0;
1511 float y = 0; // types of x and y are contrived for example
1512 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1513 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1514 xElement->QueryIntText( &x );
1515 yElement->QueryFloatText( &y );
1516 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001517
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001518 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1519 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 -07001520
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001521 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001522 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001523 /// See QueryIntText()
Uli Kusterer664d0562014-01-21 12:24:47 +01001524 XMLError QueryLongLongText( long long* ival ) const;
1525 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001526 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001527 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001528 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001529 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001530 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001531 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001532 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001533
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001534 // internal:
1535 enum {
1536 OPEN, // <foo>
1537 CLOSED, // <foo/>
1538 CLOSING // </foo>
1539 };
1540 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001541 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001542 }
1543 char* ParseDeep( char* p, StrPair* endTag );
1544 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1545 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001546
Lee Thomason50adb4c2012-02-13 15:07:09 -08001547private:
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001548 enum { BUF_SIZE = 200 };
1549
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001550 XMLElement( XMLDocument* doc );
1551 virtual ~XMLElement();
1552 XMLElement( const XMLElement& ); // not supported
1553 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001554
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001555 XMLAttribute* FindAttribute( const char* name );
1556 XMLAttribute* FindOrCreateAttribute( const char* name );
1557 //void LinkAttribute( XMLAttribute* attrib );
1558 char* ParseAttributes( char* p );
Lee Thomason67d61312012-01-24 16:01:51 -08001559
Lee Thomason5bb2d802014-01-24 10:42:57 -08001560 enum { BUF_SIZE = 200 };
Lee Thomason624d43f2012-10-12 10:58:48 -07001561 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001562 // The attribute list is ordered; there is no 'lastAttribute'
1563 // because the list needs to be scanned for dupes before adding
1564 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001565 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001566};
1567
1568
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001569enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001570 PRESERVE_WHITESPACE,
1571 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001572};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001573
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001574
1575/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001576 It can be saved, loaded, and printed to the screen.
1577 All Nodes are connected and allocated to a Document.
1578 If the Document is deleted, all its Nodes are also deleted.
1579*/
PKEuS16ed47d2013-07-06 12:02:43 +02001580class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001581{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001582 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001583public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001584 /// constructor
1585 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1586 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001587
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001588 virtual XMLDocument* ToDocument() {
1589 return this;
1590 }
1591 virtual const XMLDocument* ToDocument() const {
1592 return this;
1593 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001594
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001595 /**
1596 Parse an XML file from a character string.
1597 Returns XML_NO_ERROR (0) on success, or
1598 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001599
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001600 You may optionally pass in the 'nBytes', which is
1601 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001602 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001603 null terminated string.
1604 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001605 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001606
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001607 /**
1608 Load an XML file from disk.
1609 Returns XML_NO_ERROR (0) on success, or
1610 an errorID.
1611 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001612 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001613
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001614 /**
1615 Load an XML file from disk. You are responsible
1616 for providing and closing the FILE*.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001617
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001618 Returns XML_NO_ERROR (0) on success, or
1619 an errorID.
1620 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001621 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001622
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001623 /**
1624 Save the XML file to disk.
1625 Returns XML_NO_ERROR (0) on success, or
1626 an errorID.
1627 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001628 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001629
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001630 /**
1631 Save the XML file to disk. You are responsible
1632 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001633
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001634 Returns XML_NO_ERROR (0) on success, or
1635 an errorID.
1636 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001637 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001638
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001639 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001640 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001641 }
1642 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001643 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001644 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001645
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001646 /**
1647 Returns true if this document has a leading Byte Order Mark of UTF8.
1648 */
1649 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001650 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001651 }
1652 /** Sets whether to write the BOM when writing the file.
1653 */
1654 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001655 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001656 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001657
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001658 /** Return the root element of DOM. Equivalent to FirstChildElement().
1659 To get the first node, use FirstChild().
1660 */
1661 XMLElement* RootElement() {
1662 return FirstChildElement();
1663 }
1664 const XMLElement* RootElement() const {
1665 return FirstChildElement();
1666 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001667
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001668 /** Print the Document. If the Printer is not provided, it will
1669 print to stdout. If you provide Printer, this can print to a file:
1670 @verbatim
1671 XMLPrinter printer( fp );
1672 doc.Print( &printer );
1673 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001674
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001675 Or you can use a printer to print to memory:
1676 @verbatim
1677 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001678 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001679 // printer.CStr() has a const char* to the XML
1680 @endverbatim
1681 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001682 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001683 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001684
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001685 /**
1686 Create a new Element associated with
1687 this Document. The memory for the Element
1688 is managed by the Document.
1689 */
1690 XMLElement* NewElement( const char* name );
1691 /**
1692 Create a new Comment associated with
1693 this Document. The memory for the Comment
1694 is managed by the Document.
1695 */
1696 XMLComment* NewComment( const char* comment );
1697 /**
1698 Create a new Text associated with
1699 this Document. The memory for the Text
1700 is managed by the Document.
1701 */
1702 XMLText* NewText( const char* text );
1703 /**
1704 Create a new Declaration associated with
1705 this Document. The memory for the object
1706 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001707
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001708 If the 'text' param is null, the standard
1709 declaration is used.:
1710 @verbatim
1711 <?xml version="1.0" encoding="UTF-8"?>
1712 @endverbatim
1713 */
1714 XMLDeclaration* NewDeclaration( const char* text=0 );
1715 /**
1716 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001717 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001718 is managed by the Document.
1719 */
1720 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001721
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001722 /**
1723 Delete a node associated with this document.
1724 It will be unlinked from the DOM.
1725 */
1726 void DeleteNode( XMLNode* node ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001727 node->_parent->DeleteChild( node );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001728 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001729
Lee Thomason2fa81722012-11-09 12:37:46 -08001730 void SetError( XMLError error, const char* str1, const char* str2 );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001731
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001732 /// Return true if there was an error parsing the document.
1733 bool Error() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001734 return _errorID != XML_NO_ERROR;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001735 }
1736 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001737 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001738 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001739 }
1740 /// Return a possibly helpful diagnostic location or string.
1741 const char* GetErrorStr1() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001742 return _errorStr1;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001743 }
1744 /// Return a possibly helpful secondary diagnostic location or string.
1745 const char* GetErrorStr2() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001746 return _errorStr2;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001747 }
1748 /// If there is an error, print it to stdout.
1749 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001750
1751 /// Clear the document, resetting it to the initial state.
1752 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001753
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001754 // internal
1755 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001756
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001757 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1758 return 0;
1759 }
1760 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1761 return false;
1762 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001763
Lee Thomason3f57d272012-01-11 15:30:03 -08001764private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001765 XMLDocument( const XMLDocument& ); // not supported
1766 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001767
Lee Thomason2fa81722012-11-09 12:37:46 -08001768 bool _writeBOM;
1769 bool _processEntities;
1770 XMLError _errorID;
1771 Whitespace _whitespace;
Lee Thomason624d43f2012-10-12 10:58:48 -07001772 const char* _errorStr1;
1773 const char* _errorStr2;
Lee Thomason2fa81722012-11-09 12:37:46 -08001774 char* _charBuffer;
Lee Thomasond1983222012-02-06 08:41:24 -08001775
Lee Thomason624d43f2012-10-12 10:58:48 -07001776 MemPoolT< sizeof(XMLElement) > _elementPool;
1777 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1778 MemPoolT< sizeof(XMLText) > _textPool;
1779 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason5cae8972012-01-24 18:03:07 -08001780};
1781
Lee Thomason7c913cd2012-01-26 18:32:34 -08001782
Lee Thomason3ffdd392012-03-28 17:27:55 -07001783/**
1784 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001785 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001786 DOM structure. It is a separate utility class.
1787
1788 Take an example:
1789 @verbatim
1790 <Document>
1791 <Element attributeA = "valueA">
1792 <Child attributeB = "value1" />
1793 <Child attributeB = "value2" />
1794 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001795 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001796 @endverbatim
1797
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001798 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001799 easy to write a *lot* of code that looks like:
1800
1801 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001802 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001803 if ( root )
1804 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001805 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001806 if ( element )
1807 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001808 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001809 if ( child )
1810 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001811 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001812 if ( child2 )
1813 {
1814 // Finally do something useful.
1815 @endverbatim
1816
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001817 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001818 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001819 and correct to use:
1820
1821 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001822 XMLHandle docHandle( &document );
1823 XMLElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild().NextSibling().ToElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001824 if ( child2 )
1825 {
1826 // do something useful
1827 @endverbatim
1828
1829 Which is MUCH more concise and useful.
1830
1831 It is also safe to copy handles - internally they are nothing more than node pointers.
1832 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001833 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001834 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001835
1836 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001837*/
PKEuS16ed47d2013-07-06 12:02:43 +02001838class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001839{
1840public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001841 /// 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 -07001842 XMLHandle( XMLNode* node ) {
1843 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001844 }
1845 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001846 XMLHandle( XMLNode& node ) {
1847 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001848 }
1849 /// Copy constructor
1850 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001851 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001852 }
1853 /// Assignment
1854 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001855 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001856 return *this;
1857 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001858
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001859 /// Get the first child of this handle.
1860 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001861 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001862 }
1863 /// Get the first child element of this handle.
1864 XMLHandle FirstChildElement( const char* value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001865 return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001866 }
1867 /// Get the last child of this handle.
1868 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001869 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001870 }
1871 /// Get the last child element of this handle.
1872 XMLHandle LastChildElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001873 return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001874 }
1875 /// Get the previous sibling of this handle.
1876 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001877 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001878 }
1879 /// Get the previous sibling element of this handle.
1880 XMLHandle PreviousSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001881 return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001882 }
1883 /// Get the next sibling of this handle.
1884 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001885 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001886 }
1887 /// Get the next sibling element of this handle.
1888 XMLHandle NextSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001889 return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001890 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001891
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001892 /// Safe cast to XMLNode. This can return null.
1893 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001894 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001895 }
1896 /// Safe cast to XMLElement. This can return null.
1897 XMLElement* ToElement() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001898 return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001899 }
1900 /// Safe cast to XMLText. This can return null.
1901 XMLText* ToText() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001902 return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001903 }
1904 /// Safe cast to XMLUnknown. This can return null.
1905 XMLUnknown* ToUnknown() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001906 return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001907 }
1908 /// Safe cast to XMLDeclaration. This can return null.
1909 XMLDeclaration* ToDeclaration() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001910 return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001911 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001912
1913private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001914 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001915};
1916
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001917
1918/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001919 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1920 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001921*/
PKEuS16ed47d2013-07-06 12:02:43 +02001922class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001923{
1924public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001925 XMLConstHandle( const XMLNode* node ) {
1926 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001927 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001928 XMLConstHandle( const XMLNode& node ) {
1929 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001930 }
1931 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001932 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001933 }
Lee Thomason8b899812012-04-04 15:58:16 -07001934
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001935 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001936 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001937 return *this;
1938 }
Lee Thomason8b899812012-04-04 15:58:16 -07001939
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001940 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001941 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001942 }
1943 const XMLConstHandle FirstChildElement( const char* value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001944 return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001945 }
1946 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001947 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001948 }
1949 const XMLConstHandle LastChildElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001950 return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001951 }
1952 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001953 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001954 }
1955 const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001956 return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001957 }
1958 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001959 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001960 }
1961 const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001962 return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001963 }
Lee Thomason8b899812012-04-04 15:58:16 -07001964
1965
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001966 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001967 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001968 }
1969 const XMLElement* ToElement() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001970 return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001971 }
1972 const XMLText* ToText() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001973 return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001974 }
1975 const XMLUnknown* ToUnknown() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001976 return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001977 }
1978 const XMLDeclaration* ToDeclaration() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001979 return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001980 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08001981
Lee Thomason5cae8972012-01-24 18:03:07 -08001982private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001983 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08001984};
Lee Thomason6f381b72012-03-02 12:59:39 -08001985
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001986
1987/**
1988 Printing functionality. The XMLPrinter gives you more
1989 options than the XMLDocument::Print() method.
1990
1991 It can:
1992 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02001993 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001994 -# Print XML without a XMLDocument.
1995
1996 Print to Memory
1997
1998 @verbatim
1999 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06002000 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02002001 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002002 @endverbatim
2003
2004 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07002005
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002006 You provide the file pointer.
2007 @verbatim
2008 XMLPrinter printer( fp );
2009 doc.Print( &printer );
2010 @endverbatim
2011
2012 Print without a XMLDocument
2013
2014 When loading, an XML parser is very useful. However, sometimes
2015 when saving, it just gets in the way. The code is often set up
2016 for streaming, and constructing the DOM is just overhead.
2017
2018 The Printer supports the streaming case. The following code
2019 prints out a trivially simple XML file without ever creating
2020 an XML document.
2021
2022 @verbatim
2023 XMLPrinter printer( fp );
2024 printer.OpenElement( "foo" );
2025 printer.PushAttribute( "foo", "bar" );
2026 printer.CloseElement();
2027 @endverbatim
2028*/
PKEuS16ed47d2013-07-06 12:02:43 +02002029class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002030{
2031public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002032 /** Construct the printer. If the FILE* is specified,
2033 this will print to the FILE. Else it will print
2034 to memory, and the result is available in CStr().
2035 If 'compact' is set to true, then output is created
2036 with only required whitespace and newlines.
2037 */
PKEuS1bfb9542013-08-04 13:51:17 +02002038 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002039 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002040
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002041 /** If streaming, write the BOM and declaration. */
2042 void PushHeader( bool writeBOM, bool writeDeclaration );
2043 /** If streaming, start writing an element.
2044 The element must be closed with CloseElement()
2045 */
2046 void OpenElement( const char* name );
2047 /// If streaming, add an attribute to an open element.
2048 void PushAttribute( const char* name, const char* value );
2049 void PushAttribute( const char* name, int value );
2050 void PushAttribute( const char* name, unsigned value );
2051 void PushAttribute( const char* name, bool value );
2052 void PushAttribute( const char* name, double value );
2053 /// If streaming, close the Element.
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002054 virtual void CloseElement();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002055
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002056 /// Add a text node.
2057 void PushText( const char* text, bool cdata=false );
2058 /// Add a text node from an integer.
2059 void PushText( int value );
2060 /// Add a text node from an unsigned.
2061 void PushText( unsigned value );
2062 /// Add a text node from a bool.
2063 void PushText( bool value );
2064 /// Add a text node from a float.
2065 void PushText( float value );
2066 /// Add a text node from a double.
2067 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07002068
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002069 /// Add a comment
2070 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002071
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002072 void PushDeclaration( const char* value );
2073 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002074
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002075 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
2076 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
2077 return true;
2078 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002079
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002080 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
2081 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002082
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002083 virtual bool Visit( const XMLText& text );
2084 virtual bool Visit( const XMLComment& comment );
2085 virtual bool Visit( const XMLDeclaration& declaration );
2086 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002087
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002088 /**
2089 If in print to memory mode, return a pointer to
2090 the XML file in memory.
2091 */
2092 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002093 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002094 }
2095 /**
2096 If in print to memory mode, return the size
2097 of the XML file in memory. (Note the size returned
2098 includes the terminating null.)
2099 */
2100 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002101 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002102 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002103 /**
2104 If in print to memory mode, reset the buffer to the
2105 beginning.
2106 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08002107 void ClearBuffer() {
2108 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002109 _buffer.Push(0);
2110 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002111
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002112protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002113 void SealElement();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002114 bool _elementJustOpened;
2115 DynArray< const char*, 10 > _stack;
2116
2117private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002118 void PrintSpace( int depth );
2119 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
2120 void Print( const char* format, ... );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002121
Lee Thomason624d43f2012-10-12 10:58:48 -07002122 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01002123 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07002124 int _depth;
2125 int _textDepth;
2126 bool _processEntities;
2127 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002128
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002129 enum {
2130 ENTITY_RANGE = 64,
2131 BUF_SIZE = 200
2132 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002133 bool _entityFlag[ENTITY_RANGE];
2134 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002135
Lee Thomason624d43f2012-10-12 10:58:48 -07002136 DynArray< char, 20 > _buffer;
PKEuSe736f292012-07-16 03:27:55 -07002137#ifdef _MSC_VER
Lee Thomason624d43f2012-10-12 10:58:48 -07002138 DynArray< char, 20 > _accumulator;
PKEuSe736f292012-07-16 03:27:55 -07002139#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002140};
2141
2142
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002143} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002144
PKEuS95060352013-07-26 10:42:44 +02002145#if defined(_MSC_VER)
2146# pragma warning(pop)
2147#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002148
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002149#endif // TINYXML2_INCLUDED