blob: a58401078a1cc7f0457da87ac25a849803c29f21 [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 );
543 static void ToStr( unsigned v, char* buffer, int bufferSize );
544 static void ToStr( bool v, char* buffer, int bufferSize );
545 static void ToStr( float v, char* buffer, int bufferSize );
546 static void ToStr( double v, char* buffer, int bufferSize );
Lee Thomason21be8822012-07-15 17:27:22 -0700547
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700548 // converts strings to primitive types
549 static bool ToInt( const char* str, int* value );
550 static bool ToUnsigned( const char* str, unsigned* value );
551 static bool ToBool( const char* str, bool* value );
552 static bool ToFloat( const char* str, float* value );
553 static bool ToDouble( const char* str, double* value );
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800554};
555
Lee Thomason5cae8972012-01-24 18:03:07 -0800556
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800557/** XMLNode is a base class for every object that is in the
558 XML Document Object Model (DOM), except XMLAttributes.
559 Nodes have siblings, a parent, and children which can
560 be navigated. A node is always in a XMLDocument.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700561 The type of a XMLNode can be queried, and it can
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800562 be cast to its more defined type.
563
Thomas Roß08bdf502012-05-12 14:21:23 +0200564 A XMLDocument allocates memory for all its Nodes.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800565 When the XMLDocument gets deleted, all its Nodes
566 will also be deleted.
567
568 @verbatim
569 A Document can contain: Element (container or leaf)
570 Comment (leaf)
571 Unknown (leaf)
572 Declaration( leaf )
573
574 An Element can contain: Element (container or leaf)
575 Text (leaf)
576 Attributes (not on tree)
577 Comment (leaf)
578 Unknown (leaf)
579
580 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800581*/
PKEuS16ed47d2013-07-06 12:02:43 +0200582class TINYXML2_LIB XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800583{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700584 friend class XMLDocument;
585 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800586public:
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800587
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700588 /// Get the XMLDocument that owns this XMLNode.
589 const XMLDocument* GetDocument() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700590 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700591 }
592 /// Get the XMLDocument that owns this XMLNode.
593 XMLDocument* GetDocument() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700594 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700595 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800596
Lee Thomason2fa81722012-11-09 12:37:46 -0800597 /// Safely cast to an Element, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700598 virtual XMLElement* ToElement() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100599 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700600 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800601 /// Safely cast to Text, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700602 virtual XMLText* ToText() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100603 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700604 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800605 /// Safely cast to a Comment, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700606 virtual XMLComment* ToComment() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100607 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700608 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800609 /// Safely cast to a Document, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700610 virtual XMLDocument* ToDocument() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100611 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700612 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800613 /// Safely cast to a Declaration, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700614 virtual XMLDeclaration* ToDeclaration() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100615 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700616 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800617 /// Safely cast to an Unknown, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700618 virtual XMLUnknown* ToUnknown() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100619 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700620 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800621
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700622 virtual const XMLElement* ToElement() const {
623 return 0;
624 }
625 virtual const XMLText* ToText() const {
626 return 0;
627 }
628 virtual const XMLComment* ToComment() const {
629 return 0;
630 }
631 virtual const XMLDocument* ToDocument() const {
632 return 0;
633 }
634 virtual const XMLDeclaration* ToDeclaration() const {
635 return 0;
636 }
637 virtual const XMLUnknown* ToUnknown() const {
638 return 0;
639 }
Lee Thomason751da522012-02-10 08:50:51 -0800640
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700641 /** The meaning of 'value' changes for the specific type.
642 @verbatim
643 Document: empty
644 Element: name of the element
645 Comment: the comment text
646 Unknown: the tag contents
647 Text: the text string
648 @endverbatim
649 */
Michael Daumling21626882013-10-22 17:03:37 +0200650 const char* Value() const;
MortenMacFly4ee49f12013-01-14 20:03:14 +0100651
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700652 /** Set the Value of an XML node.
653 @sa Value()
654 */
655 void SetValue( const char* val, bool staticMem=false );
Lee Thomason2c85a712012-01-31 08:24:24 -0800656
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700657 /// Get the parent of this node on the DOM.
658 const XMLNode* Parent() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700659 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700660 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100661
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700662 XMLNode* Parent() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700663 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700664 }
Lee Thomason751da522012-02-10 08:50:51 -0800665
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700666 /// Returns true if this node has no children.
667 bool NoChildren() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700668 return !_firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700669 }
Lee Thomason751da522012-02-10 08:50:51 -0800670
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700671 /// Get the first child node, or null if none exists.
672 const XMLNode* FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700673 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700674 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100675
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700676 XMLNode* FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700677 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700678 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100679
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700680 /** Get the first child element, or optionally the first child
681 element with the specified name.
682 */
683 const XMLElement* FirstChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700684
685 XMLElement* FirstChildElement( const char* value=0 ) {
686 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700687 }
Lee Thomason3f57d272012-01-11 15:30:03 -0800688
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700689 /// Get the last child node, or null if none exists.
690 const XMLNode* LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700691 return _lastChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700692 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700693
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700694 XMLNode* LastChild() {
695 return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
696 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800697
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700698 /** Get the last child element or optionally the last child
699 element with the specified name.
700 */
701 const XMLElement* LastChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700702
703 XMLElement* LastChildElement( const char* value=0 ) {
704 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700705 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700706
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700707 /// Get the previous (left) sibling node of this node.
708 const XMLNode* PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700709 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700710 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700711
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700712 XMLNode* PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700713 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700714 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800715
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700716 /// Get the previous (left) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700717 const XMLElement* PreviousSiblingElement( const char* value=0 ) const ;
Lee Thomason624d43f2012-10-12 10:58:48 -0700718
719 XMLElement* PreviousSiblingElement( const char* value=0 ) {
720 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700721 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700722
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700723 /// Get the next (right) sibling node of this node.
724 const XMLNode* NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700725 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700726 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700727
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700728 XMLNode* NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700729 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700730 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700731
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700732 /// Get the next (right) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700733 const XMLElement* NextSiblingElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700734
735 XMLElement* NextSiblingElement( const char* value=0 ) {
736 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700737 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800738
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700739 /**
740 Add a child node as the last (right) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200741 If the child node is already part of the document,
742 it is moved from its old location to the new location.
743 Returns the addThis argument or 0 if the node does not
744 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700745 */
746 XMLNode* InsertEndChild( XMLNode* addThis );
Lee Thomason618dbf82012-02-28 12:34:27 -0800747
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700748 XMLNode* LinkEndChild( XMLNode* addThis ) {
749 return InsertEndChild( addThis );
750 }
751 /**
752 Add a child node as the first (left) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200753 If the child node is already part of the document,
754 it is moved from its old location to the new location.
755 Returns the addThis argument or 0 if the node does not
756 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700757 */
758 XMLNode* InsertFirstChild( XMLNode* addThis );
759 /**
760 Add a node after the specified child node.
Michael Daumlinged523282013-10-23 07:47:29 +0200761 If the child node is already part of the document,
762 it is moved from its old location to the new location.
763 Returns the addThis argument or 0 if the afterThis node
764 is not a child of this node, or if the node does not
765 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700766 */
767 XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700768
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700769 /**
770 Delete all the children of this node.
771 */
772 void DeleteChildren();
U-Stream\Leeae25a442012-02-17 17:48:16 -0800773
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700774 /**
775 Delete a child of this node.
776 */
777 void DeleteChild( XMLNode* node );
Lee Thomason56bdd022012-02-09 18:16:58 -0800778
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700779 /**
780 Make a copy of this node, but not its children.
781 You may pass in a Document pointer that will be
782 the owner of the new Node. If the 'document' is
783 null, then the node returned will be allocated
784 from the current Document. (this->GetDocument())
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800785
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700786 Note: if called on a XMLDocument, this will return null.
787 */
788 virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800789
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700790 /**
791 Test if 2 nodes are the same, but don't test children.
792 The 2 nodes do not need to be in the same Document.
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800793
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700794 Note: if called on a XMLDocument, this will return false.
795 */
796 virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800797
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600798 /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700799 XML tree will be conditionally visited and the host will be called back
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600800 via the XMLVisitor interface.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800801
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600802 This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
803 the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700804 interface versus any other.)
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800805
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700806 The interface has been based on ideas from:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800807
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700808 - http://www.saxproject.org/
809 - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800810
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700811 Which are both good references for "visiting".
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800812
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700813 An example of using Accept():
814 @verbatim
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600815 XMLPrinter printer;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700816 tinyxmlDoc.Accept( &printer );
817 const char* xmlcstr = printer.CStr();
818 @endverbatim
819 */
820 virtual bool Accept( XMLVisitor* visitor ) const = 0;
Lee Thomason56bdd022012-02-09 18:16:58 -0800821
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700822 // internal
823 virtual char* ParseDeep( char*, StrPair* );
Uli Kusterer593a33d2014-02-01 12:48:51 +0100824
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800825protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700826 XMLNode( XMLDocument* );
827 virtual ~XMLNode();
828 XMLNode( const XMLNode& ); // not supported
829 XMLNode& operator=( const XMLNode& ); // not supported
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700830
Lee Thomason624d43f2012-10-12 10:58:48 -0700831 XMLDocument* _document;
832 XMLNode* _parent;
833 mutable StrPair _value;
Lee Thomason3f57d272012-01-11 15:30:03 -0800834
Lee Thomason624d43f2012-10-12 10:58:48 -0700835 XMLNode* _firstChild;
836 XMLNode* _lastChild;
Lee Thomason3f57d272012-01-11 15:30:03 -0800837
Lee Thomason624d43f2012-10-12 10:58:48 -0700838 XMLNode* _prev;
839 XMLNode* _next;
Uli Kusterer593a33d2014-02-01 12:48:51 +0100840
841 bool _forceCompactMode;
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.
1098 void SetAttribute( unsigned value );
1099 /// Set the attribute to value.
1100 void SetAttribute( bool value );
1101 /// Set the attribute to value.
1102 void SetAttribute( double value );
1103 /// Set the attribute to value.
1104 void SetAttribute( float value );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001105
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001106private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001107 enum { BUF_SIZE = 200 };
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001108
Thomas Roß61892312013-05-12 14:07:38 +02001109 XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001110 virtual ~XMLAttribute() {}
Lee Thomason624d43f2012-10-12 10:58:48 -07001111
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001112 XMLAttribute( const XMLAttribute& ); // not supported
1113 void operator=( const XMLAttribute& ); // not supported
1114 void SetName( const char* name );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001115
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001116 char* ParseDeep( char* p, bool processEntities );
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001117
Lee Thomason624d43f2012-10-12 10:58:48 -07001118 mutable StrPair _name;
1119 mutable StrPair _value;
1120 XMLAttribute* _next;
1121 MemPool* _memPool;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001122};
1123
1124
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001125/** The element is a container class. It has a value, the element name,
1126 and can contain other elements, text, comments, and unknowns.
1127 Elements also contain an arbitrary number of attributes.
1128*/
PKEuS16ed47d2013-07-06 12:02:43 +02001129class TINYXML2_LIB XMLElement : public XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001130{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001131 friend class XMLBase;
1132 friend class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001133public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001134 /// Get the name of an element (which is the Value() of the node.)
1135 const char* Name() const {
1136 return Value();
1137 }
1138 /// Set the name of the element.
1139 void SetName( const char* str, bool staticMem=false ) {
1140 SetValue( str, staticMem );
1141 }
Lee Thomason2c85a712012-01-31 08:24:24 -08001142
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001143 virtual XMLElement* ToElement() {
1144 return this;
1145 }
1146 virtual const XMLElement* ToElement() const {
1147 return this;
1148 }
1149 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001150
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001151 /** Given an attribute name, Attribute() returns the value
1152 for the attribute of that name, or null if none
1153 exists. For example:
Lee Thomason92258152012-03-24 13:05:39 -07001154
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001155 @verbatim
1156 const char* value = ele->Attribute( "foo" );
1157 @endverbatim
Lee Thomason92258152012-03-24 13:05:39 -07001158
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001159 The 'value' parameter is normally null. However, if specified,
1160 the attribute will only be returned if the 'name' and 'value'
1161 match. This allow you to write code:
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001162
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001163 @verbatim
1164 if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
1165 @endverbatim
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001166
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001167 rather than:
1168 @verbatim
1169 if ( ele->Attribute( "foo" ) ) {
1170 if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
1171 }
1172 @endverbatim
1173 */
1174 const char* Attribute( const char* name, const char* value=0 ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001175
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001176 /** Given an attribute name, IntAttribute() returns the value
1177 of the attribute interpreted as an integer. 0 will be
1178 returned if there is an error. For a method with error
1179 checking, see QueryIntAttribute()
1180 */
1181 int IntAttribute( const char* name ) const {
1182 int i=0;
1183 QueryIntAttribute( name, &i );
1184 return i;
1185 }
1186 /// See IntAttribute()
1187 unsigned UnsignedAttribute( const char* name ) const {
1188 unsigned i=0;
1189 QueryUnsignedAttribute( name, &i );
1190 return i;
1191 }
1192 /// See IntAttribute()
1193 bool BoolAttribute( const char* name ) const {
1194 bool b=false;
1195 QueryBoolAttribute( name, &b );
1196 return b;
1197 }
1198 /// See IntAttribute()
1199 double DoubleAttribute( const char* name ) const {
1200 double d=0;
1201 QueryDoubleAttribute( name, &d );
1202 return d;
1203 }
1204 /// See IntAttribute()
1205 float FloatAttribute( const char* name ) const {
1206 float f=0;
1207 QueryFloatAttribute( name, &f );
1208 return f;
1209 }
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001210
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001211 /** Given an attribute name, QueryIntAttribute() returns
1212 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1213 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1214 doesn't exist. If successful, the result of the conversion
1215 will be written to 'value'. If not successful, nothing will
1216 be written to 'value'. This allows you to provide default
1217 value:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001218
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001219 @verbatim
1220 int value = 10;
1221 QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1222 @endverbatim
1223 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001224 XMLError QueryIntAttribute( const char* name, int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001225 const XMLAttribute* a = FindAttribute( name );
1226 if ( !a ) {
1227 return XML_NO_ATTRIBUTE;
1228 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001229 return a->QueryIntValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001230 }
1231 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001232 XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001233 const XMLAttribute* a = FindAttribute( name );
1234 if ( !a ) {
1235 return XML_NO_ATTRIBUTE;
1236 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001237 return a->QueryUnsignedValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001238 }
1239 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001240 XMLError QueryBoolAttribute( const char* name, bool* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001241 const XMLAttribute* a = FindAttribute( name );
1242 if ( !a ) {
1243 return XML_NO_ATTRIBUTE;
1244 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001245 return a->QueryBoolValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001246 }
1247 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001248 XMLError QueryDoubleAttribute( const char* name, double* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001249 const XMLAttribute* a = FindAttribute( name );
1250 if ( !a ) {
1251 return XML_NO_ATTRIBUTE;
1252 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001253 return a->QueryDoubleValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001254 }
1255 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001256 XMLError QueryFloatAttribute( const char* name, float* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001257 const XMLAttribute* a = FindAttribute( name );
1258 if ( !a ) {
1259 return XML_NO_ATTRIBUTE;
1260 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001261 return a->QueryFloatValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001262 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001263
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001264
1265 /** Given an attribute name, QueryAttribute() returns
1266 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1267 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1268 doesn't exist. It is overloaded for the primitive types,
1269 and is a generally more convenient replacement of
1270 QueryIntAttribute() and related functions.
1271
1272 If successful, the result of the conversion
1273 will be written to 'value'. If not successful, nothing will
1274 be written to 'value'. This allows you to provide default
1275 value:
1276
1277 @verbatim
1278 int value = 10;
1279 QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1280 @endverbatim
1281 */
1282 int QueryAttribute( const char* name, int* value ) const {
1283 return QueryIntAttribute( name, value );
1284 }
1285
1286 int QueryAttribute( const char* name, unsigned int* value ) const {
1287 return QueryUnsignedAttribute( name, value );
1288 }
1289
1290 int QueryAttribute( const char* name, bool* value ) const {
1291 return QueryBoolAttribute( name, value );
1292 }
1293
1294 int QueryAttribute( const char* name, double* value ) const {
1295 return QueryDoubleAttribute( name, value );
1296 }
1297
1298 int QueryAttribute( const char* name, float* value ) const {
1299 return QueryFloatAttribute( name, value );
1300 }
1301
1302 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001303 void SetAttribute( const char* name, const char* value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001304 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001305 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001306 }
1307 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001308 void SetAttribute( const char* name, int value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001309 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001310 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001311 }
1312 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001313 void SetAttribute( const char* name, unsigned value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001314 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001315 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001316 }
1317 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001318 void SetAttribute( const char* name, bool value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001319 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001320 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001321 }
1322 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001323 void SetAttribute( const char* name, double value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001324 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001325 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001326 }
Lee Thomasonc3708cc2014-01-14 12:30:03 -08001327 /// Sets the named attribute to value.
1328 void SetAttribute( const char* name, float value ) {
1329 XMLAttribute* a = FindOrCreateAttribute( name );
1330 a->SetAttribute( value );
1331 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001332
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001333 /**
1334 Delete an attribute.
1335 */
1336 void DeleteAttribute( const char* name );
Lee Thomason751da522012-02-10 08:50:51 -08001337
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001338 /// Return the first attribute in the list.
1339 const XMLAttribute* FirstAttribute() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001340 return _rootAttribute;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001341 }
1342 /// Query a specific attribute in the list.
1343 const XMLAttribute* FindAttribute( const char* name ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001344
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001345 /** Convenience function for easy access to the text inside an element. Although easy
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001346 and concise, GetText() is limited compared to getting the XMLText child
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001347 and accessing it directly.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001348
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001349 If the first child of 'this' is a XMLText, the GetText()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001350 returns the character string of the Text node, else null is returned.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001351
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001352 This is a convenient method for getting the text of simple contained text:
1353 @verbatim
1354 <foo>This is text</foo>
1355 const char* str = fooElement->GetText();
1356 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001357
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001358 'str' will be a pointer to "This is text".
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001359
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001360 Note that this function can be misleading. If the element foo was created from
1361 this XML:
1362 @verbatim
1363 <foo><b>This is text</b></foo>
1364 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001365
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001366 then the value of str would be null. The first child node isn't a text node, it is
1367 another element. From this XML:
1368 @verbatim
1369 <foo>This is <b>text</b></foo>
1370 @endverbatim
1371 GetText() will return "This is ".
1372 */
1373 const char* GetText() const;
Lee Thomason751da522012-02-10 08:50:51 -08001374
Uli Kusterer85fff5e2014-01-21 01:35:30 +01001375 /** Convenience function for easy access to the text inside an element. Although easy
1376 and concise, SetText() is limited compared to creating an XMLText child
1377 and mutating it directly.
1378
1379 If the first child of 'this' is a XMLText, SetText() sets its value to
1380 the given string, otherwise it will create a first child that is an XMLText.
1381
1382 This is a convenient method for setting the text of simple contained text:
1383 @verbatim
1384 <foo>This is text</foo>
1385 fooElement->SetText( "Hullaballoo!" );
1386 <foo>Hullaballoo!</foo>
1387 @endverbatim
1388
1389 Note that this function can be misleading. If the element foo was created from
1390 this XML:
1391 @verbatim
1392 <foo><b>This is text</b></foo>
1393 @endverbatim
1394
1395 then it will not change "This is text", but rather prefix it with a text element:
1396 @verbatim
1397 <foo>Hullaballoo!<b>This is text</b></foo>
1398 @endverbatim
1399
1400 For this XML:
1401 @verbatim
1402 <foo />
1403 @endverbatim
1404 SetText() will generate
1405 @verbatim
1406 <foo>Hullaballoo!</foo>
1407 @endverbatim
1408 */
Lee Thomason5bb2d802014-01-24 10:42:57 -08001409 void SetText( const char* inText );
Uli Kusterer35ce3092014-01-25 03:37:16 +01001410 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001411 void SetText( int value );
Uli Kusterer35ce3092014-01-25 03:37:16 +01001412 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001413 void SetText( unsigned value );
Uli Kusterer35ce3092014-01-25 03:37:16 +01001414 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001415 void SetText( bool value );
Uli Kusterer35ce3092014-01-25 03:37:16 +01001416 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001417 void SetText( double value );
Uli Kusterer35ce3092014-01-25 03:37:16 +01001418 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001419 void SetText( float value );
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001420
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001421 /// Convenience for QueryIntText when you don't care if the text won't convert.
1422 int IntText()
1423 {
1424 int i = 0;
1425 QueryIntText( &i );
1426 return i;
1427 }
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001428
Uli Kusterer4cd1f262014-01-21 02:54:36 +01001429 /// Convenience for QueryUnsignedText when you don't care if the text won't convert.
1430 unsigned UnsignedText()
1431 {
1432 unsigned i = 0;
1433 QueryUnsignedText( &i );
1434 return i;
1435 }
1436
1437 /// Convenience for QueryDoubleText when you don't care if the text won't convert.
1438 double DoubleText()
1439 {
1440 double i = 0;
1441 QueryDoubleText( &i );
1442 return i;
1443 }
1444
1445 /// Convenience for QueryFloatText when you don't care if the text won't convert.
1446 float FloatText()
1447 {
1448 float i = 0;
1449 QueryFloatText( &i );
1450 return i;
1451 }
Uli Kustererdcefa0e2014-01-21 01:36:41 +01001452
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001453 /// Adds a sub-element equivalent to the given boolean.
Uli Kustererff8e2042014-01-21 02:53:47 +01001454 void SetBoolFirstChild( bool inBool );
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001455
Uli Kustererff8e2042014-01-21 02:53:47 +01001456 /// Looks for a &lt;true /&gt; or &lt;false /&gt; as the first child and returns the corresponding bool.
1457 bool BoolFirstChild()
1458 {
1459 bool b = false;
1460 QueryBoolFirstChild(&b);
1461 return b;
1462 }
1463
1464 XMLError QueryBoolFirstChild( bool *outBool );
Uli Kustererc1c20bb2014-01-21 02:23:20 +01001465
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001466 /**
1467 Convenience method to query the value of a child text node. This is probably best
1468 shown by example. Given you have a document is this form:
1469 @verbatim
1470 <point>
1471 <x>1</x>
1472 <y>1.4</y>
1473 </point>
1474 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001475
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001476 The QueryIntText() and similar functions provide a safe and easier way to get to the
1477 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001478
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001479 @verbatim
1480 int x = 0;
1481 float y = 0; // types of x and y are contrived for example
1482 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1483 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1484 xElement->QueryIntText( &x );
1485 yElement->QueryFloatText( &y );
1486 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001487
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001488 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1489 to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001490
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001491 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001492 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001493 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001494 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001495 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001496 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001497 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001498 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001499 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001500 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001501
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001502 // internal:
1503 enum {
1504 OPEN, // <foo>
1505 CLOSED, // <foo/>
1506 CLOSING // </foo>
1507 };
1508 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001509 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001510 }
1511 char* ParseDeep( char* p, StrPair* endTag );
1512 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1513 virtual bool ShallowEqual( const XMLNode* compare ) const;
Uli Kusterer593a33d2014-02-01 12:48:51 +01001514
Lee Thomason50adb4c2012-02-13 15:07:09 -08001515private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001516 XMLElement( XMLDocument* doc );
1517 virtual ~XMLElement();
1518 XMLElement( const XMLElement& ); // not supported
1519 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001520
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001521 XMLAttribute* FindAttribute( const char* name );
1522 XMLAttribute* FindOrCreateAttribute( const char* name );
1523 //void LinkAttribute( XMLAttribute* attrib );
1524 char* ParseAttributes( char* p );
Lee Thomason67d61312012-01-24 16:01:51 -08001525
Lee Thomason5bb2d802014-01-24 10:42:57 -08001526 enum { BUF_SIZE = 200 };
Lee Thomason624d43f2012-10-12 10:58:48 -07001527 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001528 // The attribute list is ordered; there is no 'lastAttribute'
1529 // because the list needs to be scanned for dupes before adding
1530 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001531 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001532};
1533
1534
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001535enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001536 PRESERVE_WHITESPACE,
1537 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001538};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001539
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001540
1541/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001542 It can be saved, loaded, and printed to the screen.
1543 All Nodes are connected and allocated to a Document.
1544 If the Document is deleted, all its Nodes are also deleted.
1545*/
PKEuS16ed47d2013-07-06 12:02:43 +02001546class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001547{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001548 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001549public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001550 /// constructor
1551 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1552 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001553
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001554 virtual XMLDocument* ToDocument() {
1555 return this;
1556 }
1557 virtual const XMLDocument* ToDocument() const {
1558 return this;
1559 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001560
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001561 /**
1562 Parse an XML file from a character string.
1563 Returns XML_NO_ERROR (0) on success, or
1564 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001565
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001566 You may optionally pass in the 'nBytes', which is
1567 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001568 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001569 null terminated string.
1570 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001571 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001572
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001573 /**
1574 Load an XML file from disk.
1575 Returns XML_NO_ERROR (0) on success, or
1576 an errorID.
1577 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001578 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001579
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001580 /**
1581 Load an XML file from disk. You are responsible
1582 for providing and closing the FILE*.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001583
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001584 Returns XML_NO_ERROR (0) on success, or
1585 an errorID.
1586 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001587 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001588
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001589 /**
1590 Save the XML file to disk.
1591 Returns XML_NO_ERROR (0) on success, or
1592 an errorID.
1593 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001594 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001595
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001596 /**
1597 Save the XML file to disk. You are responsible
1598 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001599
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001600 Returns XML_NO_ERROR (0) on success, or
1601 an errorID.
1602 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001603 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001604
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001605 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001606 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001607 }
1608 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001609 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001610 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001611
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001612 /**
1613 Returns true if this document has a leading Byte Order Mark of UTF8.
1614 */
1615 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001616 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001617 }
1618 /** Sets whether to write the BOM when writing the file.
1619 */
1620 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001621 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001622 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001623
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001624 /** Return the root element of DOM. Equivalent to FirstChildElement().
1625 To get the first node, use FirstChild().
1626 */
1627 XMLElement* RootElement() {
1628 return FirstChildElement();
1629 }
1630 const XMLElement* RootElement() const {
1631 return FirstChildElement();
1632 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001633
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001634 /** Print the Document. If the Printer is not provided, it will
1635 print to stdout. If you provide Printer, this can print to a file:
1636 @verbatim
1637 XMLPrinter printer( fp );
1638 doc.Print( &printer );
1639 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001640
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001641 Or you can use a printer to print to memory:
1642 @verbatim
1643 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001644 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001645 // printer.CStr() has a const char* to the XML
1646 @endverbatim
1647 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001648 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001649 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001650
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001651 /**
1652 Create a new Element associated with
1653 this Document. The memory for the Element
1654 is managed by the Document.
1655 */
1656 XMLElement* NewElement( const char* name );
1657 /**
1658 Create a new Comment associated with
1659 this Document. The memory for the Comment
1660 is managed by the Document.
1661 */
1662 XMLComment* NewComment( const char* comment );
1663 /**
1664 Create a new Text associated with
1665 this Document. The memory for the Text
1666 is managed by the Document.
1667 */
1668 XMLText* NewText( const char* text );
1669 /**
1670 Create a new Declaration associated with
1671 this Document. The memory for the object
1672 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001673
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001674 If the 'text' param is null, the standard
1675 declaration is used.:
1676 @verbatim
1677 <?xml version="1.0" encoding="UTF-8"?>
1678 @endverbatim
1679 */
1680 XMLDeclaration* NewDeclaration( const char* text=0 );
1681 /**
1682 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001683 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001684 is managed by the Document.
1685 */
1686 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001687
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001688 /**
1689 Delete a node associated with this document.
1690 It will be unlinked from the DOM.
1691 */
1692 void DeleteNode( XMLNode* node ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001693 node->_parent->DeleteChild( node );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001694 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001695
Lee Thomason2fa81722012-11-09 12:37:46 -08001696 void SetError( XMLError error, const char* str1, const char* str2 );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001697
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001698 /// Return true if there was an error parsing the document.
1699 bool Error() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001700 return _errorID != XML_NO_ERROR;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001701 }
1702 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001703 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001704 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001705 }
1706 /// Return a possibly helpful diagnostic location or string.
1707 const char* GetErrorStr1() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001708 return _errorStr1;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001709 }
1710 /// Return a possibly helpful secondary diagnostic location or string.
1711 const char* GetErrorStr2() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001712 return _errorStr2;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001713 }
1714 /// If there is an error, print it to stdout.
1715 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001716
1717 /// Clear the document, resetting it to the initial state.
1718 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001719
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001720 // internal
1721 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001722
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001723 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1724 return 0;
1725 }
1726 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1727 return false;
1728 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001729
Lee Thomason3f57d272012-01-11 15:30:03 -08001730private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001731 XMLDocument( const XMLDocument& ); // not supported
1732 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001733
Lee Thomason2fa81722012-11-09 12:37:46 -08001734 bool _writeBOM;
1735 bool _processEntities;
1736 XMLError _errorID;
1737 Whitespace _whitespace;
Lee Thomason624d43f2012-10-12 10:58:48 -07001738 const char* _errorStr1;
1739 const char* _errorStr2;
Lee Thomason2fa81722012-11-09 12:37:46 -08001740 char* _charBuffer;
Lee Thomasond1983222012-02-06 08:41:24 -08001741
Lee Thomason624d43f2012-10-12 10:58:48 -07001742 MemPoolT< sizeof(XMLElement) > _elementPool;
1743 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1744 MemPoolT< sizeof(XMLText) > _textPool;
1745 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason5cae8972012-01-24 18:03:07 -08001746};
1747
Lee Thomason7c913cd2012-01-26 18:32:34 -08001748
Lee Thomason3ffdd392012-03-28 17:27:55 -07001749/**
1750 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001751 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001752 DOM structure. It is a separate utility class.
1753
1754 Take an example:
1755 @verbatim
1756 <Document>
1757 <Element attributeA = "valueA">
1758 <Child attributeB = "value1" />
1759 <Child attributeB = "value2" />
1760 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001761 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001762 @endverbatim
1763
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001764 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001765 easy to write a *lot* of code that looks like:
1766
1767 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001768 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001769 if ( root )
1770 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001771 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001772 if ( element )
1773 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001774 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001775 if ( child )
1776 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001777 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001778 if ( child2 )
1779 {
1780 // Finally do something useful.
1781 @endverbatim
1782
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001783 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001784 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001785 and correct to use:
1786
1787 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001788 XMLHandle docHandle( &document );
1789 XMLElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild().NextSibling().ToElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001790 if ( child2 )
1791 {
1792 // do something useful
1793 @endverbatim
1794
1795 Which is MUCH more concise and useful.
1796
1797 It is also safe to copy handles - internally they are nothing more than node pointers.
1798 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001799 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001800 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001801
1802 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001803*/
PKEuS16ed47d2013-07-06 12:02:43 +02001804class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001805{
1806public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001807 /// 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 -07001808 XMLHandle( XMLNode* node ) {
1809 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001810 }
1811 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001812 XMLHandle( XMLNode& node ) {
1813 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001814 }
1815 /// Copy constructor
1816 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001817 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001818 }
1819 /// Assignment
1820 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001821 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001822 return *this;
1823 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001824
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001825 /// Get the first child of this handle.
1826 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001827 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001828 }
1829 /// Get the first child element of this handle.
1830 XMLHandle FirstChildElement( const char* value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001831 return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001832 }
1833 /// Get the last child of this handle.
1834 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001835 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001836 }
1837 /// Get the last child element of this handle.
1838 XMLHandle LastChildElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001839 return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001840 }
1841 /// Get the previous sibling of this handle.
1842 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001843 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001844 }
1845 /// Get the previous sibling element of this handle.
1846 XMLHandle PreviousSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001847 return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001848 }
1849 /// Get the next sibling of this handle.
1850 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001851 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001852 }
1853 /// Get the next sibling element of this handle.
1854 XMLHandle NextSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001855 return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001856 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001857
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001858 /// Safe cast to XMLNode. This can return null.
1859 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001860 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001861 }
1862 /// Safe cast to XMLElement. This can return null.
1863 XMLElement* ToElement() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001864 return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001865 }
1866 /// Safe cast to XMLText. This can return null.
1867 XMLText* ToText() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001868 return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001869 }
1870 /// Safe cast to XMLUnknown. This can return null.
1871 XMLUnknown* ToUnknown() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001872 return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001873 }
1874 /// Safe cast to XMLDeclaration. This can return null.
1875 XMLDeclaration* ToDeclaration() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001876 return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001877 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001878
1879private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001880 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001881};
1882
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001883
1884/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001885 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1886 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001887*/
PKEuS16ed47d2013-07-06 12:02:43 +02001888class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001889{
1890public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001891 XMLConstHandle( const XMLNode* node ) {
1892 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001893 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001894 XMLConstHandle( const XMLNode& node ) {
1895 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001896 }
1897 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001898 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001899 }
Lee Thomason8b899812012-04-04 15:58:16 -07001900
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001901 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001902 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001903 return *this;
1904 }
Lee Thomason8b899812012-04-04 15:58:16 -07001905
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001906 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001907 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001908 }
1909 const XMLConstHandle FirstChildElement( const char* value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001910 return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001911 }
1912 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001913 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001914 }
1915 const XMLConstHandle LastChildElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001916 return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001917 }
1918 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001919 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001920 }
1921 const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001922 return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001923 }
1924 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001925 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001926 }
1927 const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001928 return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001929 }
Lee Thomason8b899812012-04-04 15:58:16 -07001930
1931
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001932 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001933 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001934 }
1935 const XMLElement* ToElement() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001936 return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001937 }
1938 const XMLText* ToText() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001939 return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001940 }
1941 const XMLUnknown* ToUnknown() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001942 return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001943 }
1944 const XMLDeclaration* ToDeclaration() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001945 return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001946 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08001947
Lee Thomason5cae8972012-01-24 18:03:07 -08001948private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001949 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08001950};
Lee Thomason6f381b72012-03-02 12:59:39 -08001951
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001952
1953/**
1954 Printing functionality. The XMLPrinter gives you more
1955 options than the XMLDocument::Print() method.
1956
1957 It can:
1958 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02001959 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001960 -# Print XML without a XMLDocument.
1961
1962 Print to Memory
1963
1964 @verbatim
1965 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001966 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02001967 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001968 @endverbatim
1969
1970 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001971
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001972 You provide the file pointer.
1973 @verbatim
1974 XMLPrinter printer( fp );
1975 doc.Print( &printer );
1976 @endverbatim
1977
1978 Print without a XMLDocument
1979
1980 When loading, an XML parser is very useful. However, sometimes
1981 when saving, it just gets in the way. The code is often set up
1982 for streaming, and constructing the DOM is just overhead.
1983
1984 The Printer supports the streaming case. The following code
1985 prints out a trivially simple XML file without ever creating
1986 an XML document.
1987
1988 @verbatim
1989 XMLPrinter printer( fp );
1990 printer.OpenElement( "foo" );
1991 printer.PushAttribute( "foo", "bar" );
1992 printer.CloseElement();
1993 @endverbatim
1994*/
PKEuS16ed47d2013-07-06 12:02:43 +02001995class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001996{
1997public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001998 /** Construct the printer. If the FILE* is specified,
1999 this will print to the FILE. Else it will print
2000 to memory, and the result is available in CStr().
2001 If 'compact' is set to true, then output is created
2002 with only required whitespace and newlines.
2003 */
PKEuS1bfb9542013-08-04 13:51:17 +02002004 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002005 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002006
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002007 /** If streaming, write the BOM and declaration. */
2008 void PushHeader( bool writeBOM, bool writeDeclaration );
2009 /** If streaming, start writing an element.
2010 The element must be closed with CloseElement()
2011 */
Uli Kusterer593a33d2014-02-01 12:48:51 +01002012 void OpenElement( const char* name, bool compactMode );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002013 /// If streaming, add an attribute to an open element.
2014 void PushAttribute( const char* name, const char* value );
2015 void PushAttribute( const char* name, int value );
2016 void PushAttribute( const char* name, unsigned value );
2017 void PushAttribute( const char* name, bool value );
2018 void PushAttribute( const char* name, double value );
2019 /// If streaming, close the Element.
Uli Kustererca412e82014-02-01 13:35:05 +01002020 virtual void CloseElement( bool compactMode );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002021
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002022 /// Add a text node.
2023 void PushText( const char* text, bool cdata=false );
2024 /// Add a text node from an integer.
2025 void PushText( int value );
2026 /// Add a text node from an unsigned.
2027 void PushText( unsigned value );
2028 /// Add a text node from a bool.
2029 void PushText( bool value );
2030 /// Add a text node from a float.
2031 void PushText( float value );
2032 /// Add a text node from a double.
2033 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07002034
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002035 /// Add a comment
2036 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002037
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002038 void PushDeclaration( const char* value );
2039 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002040
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002041 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
2042 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
2043 return true;
2044 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002045
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002046 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
2047 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002048
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002049 virtual bool Visit( const XMLText& text );
2050 virtual bool Visit( const XMLComment& comment );
2051 virtual bool Visit( const XMLDeclaration& declaration );
2052 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002053
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002054 /**
2055 If in print to memory mode, return a pointer to
2056 the XML file in memory.
2057 */
2058 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002059 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002060 }
2061 /**
2062 If in print to memory mode, return the size
2063 of the XML file in memory. (Note the size returned
2064 includes the terminating null.)
2065 */
2066 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002067 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002068 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002069 /**
2070 If in print to memory mode, reset the buffer to the
2071 beginning.
2072 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08002073 void ClearBuffer() {
2074 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002075 _buffer.Push(0);
2076 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002077
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002078protected:
Uli Kusterer5d1d27e2014-02-20 11:50:22 +01002079 virtual bool CompactMode( const XMLElement& elem ) { return _compactMode; };
2080
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002081 void SealElement();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002082 bool _elementJustOpened;
2083 DynArray< const char*, 10 > _stack;
2084
2085private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002086 void PrintSpace( int depth );
2087 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
2088 void Print( const char* format, ... );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002089
Lee Thomason624d43f2012-10-12 10:58:48 -07002090 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01002091 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07002092 int _depth;
2093 int _textDepth;
2094 bool _processEntities;
2095 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002096
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002097 enum {
2098 ENTITY_RANGE = 64,
2099 BUF_SIZE = 200
2100 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002101 bool _entityFlag[ENTITY_RANGE];
2102 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002103
Lee Thomason624d43f2012-10-12 10:58:48 -07002104 DynArray< char, 20 > _buffer;
PKEuSe736f292012-07-16 03:27:55 -07002105#ifdef _MSC_VER
Lee Thomason624d43f2012-10-12 10:58:48 -07002106 DynArray< char, 20 > _accumulator;
PKEuSe736f292012-07-16 03:27:55 -07002107#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002108};
2109
2110
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002111} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002112
PKEuS95060352013-07-26 10:42:44 +02002113#if defined(_MSC_VER)
2114# pragma warning(pop)
2115#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002116
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002117#endif // TINYXML2_INCLUDED