blob: 3ae1c32c70ec86c4d5524635e34ad5f41676587e [file] [log] [blame]
Lee Thomason (grinliz)28129862012-02-25 21:11:20 -08001/*
2Original code by Lee Thomason (www.grinninglizard.com)
3
4This software is provided 'as-is', without any express or implied
5warranty. In no event will the authors be held liable for any
6damages arising from the use of this software.
7
8Permission is granted to anyone to use this software for any
9purpose, including commercial applications, and to alter it and
10redistribute it freely, subject to the following restrictions:
11
121. The origin of this software must not be misrepresented; you must
13not claim that you wrote the original software. If you use this
14software in a product, an acknowledgment in the product documentation
15would be appreciated but is not required.
16
Lee Thomason (grinliz)db304252013-07-31 12:24:52 -070017
Lee Thomason (grinliz)28129862012-02-25 21:11:20 -0800182. Altered source versions must be plainly marked as such, and
19must not be misrepresented as being the original software.
20
213. This notice may not be removed or altered from any source
22distribution.
23*/
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -080024
Lee Thomason7d00b9a2012-02-27 17:54:22 -080025#ifndef TINYXML2_INCLUDED
U-Lama\Leee13c3e62011-12-28 14:36:55 -080026#define TINYXML2_INCLUDED
27
Jerome Martinez242c3ea2013-01-06 12:20:04 +010028#if defined(ANDROID_NDK) || defined(__BORLANDC__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070029# include <ctype.h>
30# include <limits.h>
31# include <stdio.h>
32# include <stdlib.h>
33# include <string.h>
34# include <stdarg.h>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070035#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -070036# include <cctype>
37# include <climits>
38# include <cstdio>
39# include <cstdlib>
40# include <cstring>
41# include <cstdarg>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070042#endif
Lee Thomason (grinliz)6a22be22012-04-04 12:39:05 -070043
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -070044/*
Lee Thomason7d00b9a2012-02-27 17:54:22 -080045 TODO: intern strings instead of allocation.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080046*/
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080047/*
Lee Thomasona9cf3f92012-10-11 16:56:51 -070048 gcc:
Lee Thomason5b0a6772012-11-19 13:54:42 -080049 g++ -Wall -DDEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
MortenMacFly4ee49f12013-01-14 20:03:14 +010050
Lee Thomasona9cf3f92012-10-11 16:56:51 -070051 Formatting, Artistic Style:
52 AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080053*/
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080054
U-Lama\Lee4cee6112011-12-31 14:58:18 -080055#if defined( _DEBUG ) || defined( DEBUG ) || defined (__DEBUG__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070056# ifndef DEBUG
57# define DEBUG
58# endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080059#endif
60
PKEuS95060352013-07-26 10:42:44 +020061#ifdef _MSC_VER
62# pragma warning(push)
63# pragma warning(disable: 4251)
64#endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080065
PKEuS16ed47d2013-07-06 12:02:43 +020066#ifdef _WIN32
67# ifdef TINYXML2_EXPORT
68# define TINYXML2_LIB __declspec(dllexport)
69# elif defined(TINYXML2_IMPORT)
70# define TINYXML2_LIB __declspec(dllimport)
71# else
72# define TINYXML2_LIB
73# endif
74#else
75# define TINYXML2_LIB
76#endif
77
78
U-Lama\Lee4cee6112011-12-31 14:58:18 -080079#if defined(DEBUG)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070080# if defined(_MSC_VER)
81# define TIXMLASSERT( x ) if ( !(x)) { __debugbreak(); } //if ( !(x)) WinDebugBreak()
82# elif defined (ANDROID_NDK)
83# include <android/log.h>
84# define TIXMLASSERT( x ) if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
85# else
86# include <assert.h>
87# define TIXMLASSERT assert
88# endif
89# else
90# define TIXMLASSERT( x ) {}
U-Lama\Lee4cee6112011-12-31 14:58:18 -080091#endif
92
U-Lama\Leee13c3e62011-12-28 14:36:55 -080093
Lee Thomason1a1d4a72012-02-15 09:09:25 -080094#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
Lee Thomasona9cf3f92012-10-11 16:56:51 -070095// Microsoft visual studio, version 2005 and higher.
96/*int _snprintf_s(
97 char *buffer,
98 size_t sizeOfBuffer,
99 size_t count,
100 const char *format [,
101 argument] ...
102);*/
103inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
104{
105 va_list va;
106 va_start( va, format );
107 int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
108 va_end( va );
109 return result;
110}
111#define TIXML_SSCANF sscanf_s
Lee Thomason (grinliz)b9e791f2012-04-06 21:27:10 -0700112#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700113// GCC version 3 and higher
114//#warning( "Using sn* functions." )
115#define TIXML_SNPRINTF snprintf
116#define TIXML_SSCANF sscanf
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800117#endif
Lee Thomason1ff38e02012-02-14 18:18:16 -0800118
Uli Kusterer8fe342a2014-01-21 01:12:47 +0100119static const int TIXML2_MAJOR_VERSION = 1;
120static const int TIXML2_MINOR_VERSION = 0;
121static const int TIXML2_PATCH_VERSION = 13;
Lee Thomason1ff38e02012-02-14 18:18:16 -0800122
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800123namespace tinyxml2
124{
Lee Thomasonce0763e2012-01-11 15:43:54 -0800125class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800126class XMLElement;
127class XMLAttribute;
128class XMLComment;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800129class XMLText;
Lee Thomason50f97b22012-02-11 16:33:40 -0800130class XMLDeclaration;
131class XMLUnknown;
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800132class XMLPrinter;
Lee Thomason5cae8972012-01-24 18:03:07 -0800133
U-Stream\Leeae25a442012-02-17 17:48:16 -0800134/*
135 A class that wraps strings. Normally stores the start and end
136 pointers into the XML file itself, and will apply normalization
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800137 and entity translation if actually read. Can also store (and memory
U-Stream\Leeae25a442012-02-17 17:48:16 -0800138 manage) a traditional char[]
139*/
PKEuS95060352013-07-26 10:42:44 +0200140class StrPair
Lee Thomason39ede242012-01-20 11:27:56 -0800141{
Lee Thomasond34f52c2012-01-20 12:55:24 -0800142public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700143 enum {
144 NEEDS_ENTITY_PROCESSING = 0x01,
145 NEEDS_NEWLINE_NORMALIZATION = 0x02,
selfpoisede77e1952013-03-13 14:08:29 +0800146 COLLAPSE_WHITESPACE = 0x04,
Lee Thomason18d68bd2012-01-26 18:17:26 -0800147
selfpoisede77e1952013-03-13 14:08:29 +0800148 TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700149 TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
selfpoisede77e1952013-03-13 14:08:29 +0800150 ATTRIBUTE_NAME = 0,
151 ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
152 ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
153 COMMENT = NEEDS_NEWLINE_NORMALIZATION
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700154 };
Lee Thomason39ede242012-01-20 11:27:56 -0800155
Lee Thomason120b3a62012-10-12 10:06:59 -0700156 StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700157 ~StrPair();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800158
Lee Thomason120b3a62012-10-12 10:06:59 -0700159 void Set( char* start, char* end, int flags ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700160 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700161 _start = start;
162 _end = end;
163 _flags = flags | NEEDS_FLUSH;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700164 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700165
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700166 const char* GetStr();
Lee Thomason120b3a62012-10-12 10:06:59 -0700167
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700168 bool Empty() const {
Lee Thomason120b3a62012-10-12 10:06:59 -0700169 return _start == _end;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700170 }
Lee Thomason39ede242012-01-20 11:27:56 -0800171
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700172 void SetInternedStr( const char* str ) {
173 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700174 _start = const_cast<char*>(str);
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700175 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700176
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700177 void SetStr( const char* str, int flags=0 );
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800178
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700179 char* ParseText( char* in, const char* endTag, int strFlags );
180 char* ParseName( char* in );
Lee Thomason56bdd022012-02-09 18:16:58 -0800181
Lee Thomason39ede242012-01-20 11:27:56 -0800182private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700183 void Reset();
184 void CollapseWhitespace();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800185
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700186 enum {
187 NEEDS_FLUSH = 0x100,
188 NEEDS_DELETE = 0x200
189 };
Lee Thomasone4422302012-01-20 17:59:50 -0800190
selfpoised4dd59bc2013-03-13 16:54:15 +0800191 // After parsing, if *_end != 0, it can be set to zero.
Lee Thomason120b3a62012-10-12 10:06:59 -0700192 int _flags;
193 char* _start;
194 char* _end;
Lee Thomason39ede242012-01-20 11:27:56 -0800195};
196
U-Lama\Lee560bd472011-12-28 19:42:49 -0800197
U-Stream\Leeae25a442012-02-17 17:48:16 -0800198/*
199 A dynamic array of Plain Old Data. Doesn't support constructors, etc.
200 Has a small initial memory pool, so that low or no usage will not
201 cause a call to new/delete
202*/
Lee Thomason2c85a712012-01-31 08:24:24 -0800203template <class T, int INIT>
PKEuS95060352013-07-26 10:42:44 +0200204class DynArray
Lee Thomason2c85a712012-01-31 08:24:24 -0800205{
206public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700207 DynArray< T, INIT >() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700208 _mem = _pool;
209 _allocated = INIT;
210 _size = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700211 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700212
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700213 ~DynArray() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700214 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700215 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700216 }
217 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700218
Lee Thomasonce0510b2013-11-26 21:29:37 -0800219 void Clear() {
Reinhard Klambauer4e74b132013-11-22 14:01:58 +0100220 _size = 0;
221 }
222
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700223 void Push( T t ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700224 EnsureCapacity( _size+1 );
225 _mem[_size++] = t;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700226 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800227
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700228 T* PushArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700229 EnsureCapacity( _size+count );
230 T* ret = &_mem[_size];
231 _size += count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700232 return ret;
233 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700234
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700235 T Pop() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700236 return _mem[--_size];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700237 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700238
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700239 void PopArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700240 TIXMLASSERT( _size >= count );
241 _size -= count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700242 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800243
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700244 bool Empty() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700245 return _size == 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700246 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700247
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700248 T& operator[](int i) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700249 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700250 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700251 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700252
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700253 const T& operator[](int i) const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700254 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700255 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700256 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700257
Dennis Jenkins59c75d32013-10-08 13:10:07 -0500258 const T& PeekTop() const {
259 TIXMLASSERT( _size > 0 );
260 return _mem[ _size - 1];
261 }
262
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700263 int Size() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700264 return _size;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700265 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700266
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700267 int Capacity() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700268 return _allocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700269 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700270
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700271 const T* Mem() const {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700272 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700273 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700274
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700275 T* Mem() {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700276 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700277 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800278
Lee Thomason2c85a712012-01-31 08:24:24 -0800279private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700280 void EnsureCapacity( int cap ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700281 if ( cap > _allocated ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700282 int newAllocated = cap * 2;
283 T* newMem = new T[newAllocated];
Lee Thomason624d43f2012-10-12 10:58:48 -0700284 memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
285 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700286 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700287 }
Lee Thomasoned5c8792012-10-12 10:09:48 -0700288 _mem = newMem;
Lee Thomason624d43f2012-10-12 10:58:48 -0700289 _allocated = newAllocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700290 }
291 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800292
Lee Thomason624d43f2012-10-12 10:58:48 -0700293 T* _mem;
294 T _pool[INIT];
295 int _allocated; // objects allocated
296 int _size; // number objects in use
Lee Thomason2c85a712012-01-31 08:24:24 -0800297};
298
Lee Thomason50adb4c2012-02-13 15:07:09 -0800299
U-Stream\Leeae25a442012-02-17 17:48:16 -0800300/*
Thomas Roß08bdf502012-05-12 14:21:23 +0200301 Parent virtual class of a pool for fast allocation
U-Stream\Leeae25a442012-02-17 17:48:16 -0800302 and deallocation of objects.
303*/
PKEuS95060352013-07-26 10:42:44 +0200304class MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800305{
306public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700307 MemPool() {}
308 virtual ~MemPool() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800309
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700310 virtual int ItemSize() const = 0;
311 virtual void* Alloc() = 0;
312 virtual void Free( void* ) = 0;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800313 virtual void SetTracked() = 0;
Lee Thomasond1983222012-02-06 08:41:24 -0800314};
315
Lee Thomason50adb4c2012-02-13 15:07:09 -0800316
U-Stream\Leeae25a442012-02-17 17:48:16 -0800317/*
318 Template child class to create pools of the correct type.
319*/
Lee Thomasond1983222012-02-06 08:41:24 -0800320template< int SIZE >
PKEuS95060352013-07-26 10:42:44 +0200321class MemPoolT : public MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800322{
323public:
Lee Thomason5b0a6772012-11-19 13:54:42 -0800324 MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700325 ~MemPoolT() {
326 // Delete the blocks.
Lee Thomason624d43f2012-10-12 10:58:48 -0700327 for( int i=0; i<_blockPtrs.Size(); ++i ) {
328 delete _blockPtrs[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700329 }
330 }
Lee Thomasond1983222012-02-06 08:41:24 -0800331
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700332 virtual int ItemSize() const {
333 return SIZE;
334 }
335 int CurrentAllocs() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700336 return _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700337 }
Lee Thomasond1983222012-02-06 08:41:24 -0800338
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700339 virtual void* Alloc() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700340 if ( !_root ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700341 // Need a new block.
342 Block* block = new Block();
Lee Thomason624d43f2012-10-12 10:58:48 -0700343 _blockPtrs.Push( block );
Lee Thomasond1983222012-02-06 08:41:24 -0800344
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700345 for( int i=0; i<COUNT-1; ++i ) {
346 block->chunk[i].next = &block->chunk[i+1];
347 }
348 block->chunk[COUNT-1].next = 0;
Lee Thomason624d43f2012-10-12 10:58:48 -0700349 _root = block->chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700350 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700351 void* result = _root;
352 _root = _root->next;
Lee Thomason455c9d42012-02-06 09:14:14 -0800353
Lee Thomason624d43f2012-10-12 10:58:48 -0700354 ++_currentAllocs;
355 if ( _currentAllocs > _maxAllocs ) {
356 _maxAllocs = _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700357 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700358 _nAllocs++;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800359 _nUntracked++;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700360 return result;
361 }
362 virtual void Free( void* mem ) {
363 if ( !mem ) {
364 return;
365 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700366 --_currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700367 Chunk* chunk = (Chunk*)mem;
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700368#ifdef DEBUG
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700369 memset( chunk, 0xfe, sizeof(Chunk) );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700370#endif
Lee Thomason624d43f2012-10-12 10:58:48 -0700371 chunk->next = _root;
372 _root = chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700373 }
374 void Trace( const char* name ) {
375 printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
Lee Thomason624d43f2012-10-12 10:58:48 -0700376 name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700377 }
Lee Thomasond1983222012-02-06 08:41:24 -0800378
Lee Thomason5b0a6772012-11-19 13:54:42 -0800379 void SetTracked() {
380 _nUntracked--;
381 }
382
383 int Untracked() const {
384 return _nUntracked;
385 }
386
Lee Thomason (grinliz)ac83b4e2013-02-01 09:02:34 -0800387 // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
388 // The test file is large, 170k.
389 // Release: VS2010 gcc(no opt)
390 // 1k: 4000
391 // 2k: 4000
392 // 4k: 3900 21000
393 // 16k: 5200
394 // 32k: 4300
395 // 64k: 4000 21000
396 enum { COUNT = (4*1024)/SIZE }; // Some compilers do not accept to use COUNT in private part if COUNT is private
Jerome Martinez7921df12012-10-24 11:45:44 +0200397
Lee Thomasond1983222012-02-06 08:41:24 -0800398private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700399 union Chunk {
Lee Thomason624d43f2012-10-12 10:58:48 -0700400 Chunk* next;
401 char mem[SIZE];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700402 };
403 struct Block {
Lee Thomason (grinliz)856da212012-10-19 09:08:15 -0700404 Chunk chunk[COUNT];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700405 };
Lee Thomason624d43f2012-10-12 10:58:48 -0700406 DynArray< Block*, 10 > _blockPtrs;
407 Chunk* _root;
Lee Thomason455c9d42012-02-06 09:14:14 -0800408
Lee Thomason624d43f2012-10-12 10:58:48 -0700409 int _currentAllocs;
410 int _nAllocs;
411 int _maxAllocs;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800412 int _nUntracked;
Lee Thomasond1983222012-02-06 08:41:24 -0800413};
414
Lee Thomason2c85a712012-01-31 08:24:24 -0800415
Lee Thomason56bdd022012-02-09 18:16:58 -0800416
417/**
418 Implements the interface to the "Visitor pattern" (see the Accept() method.)
419 If you call the Accept() method, it requires being passed a XMLVisitor
420 class to handle callbacks. For nodes that contain other nodes (Document, Element)
Thomas Roß08bdf502012-05-12 14:21:23 +0200421 you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
Lee Thomason56bdd022012-02-09 18:16:58 -0800422 are simply called with Visit().
423
424 If you return 'true' from a Visit method, recursive parsing will continue. If you return
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700425 false, <b>no children of this node or its siblings</b> will be visited.
Lee Thomason56bdd022012-02-09 18:16:58 -0800426
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700427 All flavors of Visit methods have a default implementation that returns 'true' (continue
Lee Thomason56bdd022012-02-09 18:16:58 -0800428 visiting). You need to only override methods that are interesting to you.
429
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600430 Generally Accept() is called on the XMLDocument, although all nodes support visiting.
Lee Thomason56bdd022012-02-09 18:16:58 -0800431
432 You should never change the document from a callback.
433
434 @sa XMLNode::Accept()
435*/
PKEuS16ed47d2013-07-06 12:02:43 +0200436class TINYXML2_LIB XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800437{
438public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700439 virtual ~XMLVisitor() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800440
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700441 /// Visit a document.
442 virtual bool VisitEnter( const XMLDocument& /*doc*/ ) {
443 return true;
444 }
445 /// Visit a document.
446 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
447 return true;
448 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800449
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700450 /// Visit an element.
451 virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ ) {
452 return true;
453 }
454 /// Visit an element.
455 virtual bool VisitExit( const XMLElement& /*element*/ ) {
456 return true;
457 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800458
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700459 /// Visit a declaration.
460 virtual bool Visit( const XMLDeclaration& /*declaration*/ ) {
461 return true;
462 }
463 /// Visit a text node.
464 virtual bool Visit( const XMLText& /*text*/ ) {
465 return true;
466 }
467 /// Visit a comment node.
468 virtual bool Visit( const XMLComment& /*comment*/ ) {
469 return true;
470 }
471 /// Visit an unknown node.
472 virtual bool Visit( const XMLUnknown& /*unknown*/ ) {
473 return true;
474 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800475};
476
477
U-Stream\Leeae25a442012-02-17 17:48:16 -0800478/*
479 Utility functionality.
480*/
Lee Thomason56bdd022012-02-09 18:16:58 -0800481class XMLUtil
482{
Lee Thomasond1983222012-02-06 08:41:24 -0800483public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700484 // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
485 // correct, but simple, and usually works.
486 static const char* SkipWhiteSpace( const char* p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100487 while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<const unsigned char*>(p) ) ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700488 ++p;
489 }
490 return p;
491 }
492 static char* SkipWhiteSpace( char* p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100493 while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<unsigned char*>(p) ) ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700494 ++p;
495 }
496 return p;
497 }
498 static bool IsWhiteSpace( char p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100499 return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700500 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200501
502 inline static bool IsNameStartChar( unsigned char ch ) {
503 return ( ( ch < 128 ) ? isalpha( ch ) : 1 )
504 || ch == ':'
505 || ch == '_';
506 }
507
508 inline static bool IsNameChar( unsigned char ch ) {
509 return IsNameStartChar( ch )
510 || isdigit( ch )
511 || ch == '.'
512 || ch == '-';
513 }
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800514
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700515 inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
516 int n = 0;
517 if ( p == q ) {
518 return true;
519 }
520 while( *p && *q && *p == *q && n<nChar ) {
521 ++p;
522 ++q;
523 ++n;
524 }
525 if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
526 return true;
527 }
528 return false;
529 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200530
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700531 inline static int IsUTF8Continuation( const char p ) {
532 return p & 0x80;
533 }
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800534
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700535 static const char* ReadBOM( const char* p, bool* hasBOM );
536 // p is the starting location,
537 // the UTF-8 value of the entity will be placed in value, and length filled in.
538 static const char* GetCharacterRef( const char* p, char* value, int* length );
539 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
Lee Thomason21be8822012-07-15 17:27:22 -0700540
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700541 // converts primitive types to strings
542 static void ToStr( int v, char* buffer, int bufferSize );
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* );
Lee Thomason3f57d272012-01-11 15:30:03 -0800824
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;
Lee Thomason3f57d272012-01-11 15:30:03 -0800840
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800841private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700842 MemPool* _memPool;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700843 void Unlink( XMLNode* child );
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800844};
845
846
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800847/** XML text.
848
849 Note that a text node can have child element nodes, for example:
850 @verbatim
851 <root>This is <b>bold</b></root>
852 @endverbatim
853
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700854 A text node can have 2 ways to output the next. "normal" output
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800855 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 -0700856 you generally want to leave it alone, but you can change the output mode with
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600857 SetCData() and query it with CData().
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800858*/
PKEuS16ed47d2013-07-06 12:02:43 +0200859class TINYXML2_LIB XMLText : public XMLNode
Lee Thomason5492a1c2012-01-23 15:32:10 -0800860{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700861 friend class XMLBase;
862 friend class XMLDocument;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800863public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700864 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -0800865
Lee Thomason624d43f2012-10-12 10:58:48 -0700866 virtual XMLText* ToText() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700867 return this;
868 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700869 virtual const XMLText* ToText() const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700870 return this;
871 }
Lee Thomason5492a1c2012-01-23 15:32:10 -0800872
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700873 /// Declare whether this should be CDATA or standard text.
Lee Thomason624d43f2012-10-12 10:58:48 -0700874 void SetCData( bool isCData ) {
875 _isCData = isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700876 }
877 /// Returns true if this is a CDATA text element.
878 bool CData() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700879 return _isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700880 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800881
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700882 char* ParseDeep( char*, StrPair* endTag );
883 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
884 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800885
Lee Thomason5492a1c2012-01-23 15:32:10 -0800886protected:
Lee Thomason624d43f2012-10-12 10:58:48 -0700887 XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700888 virtual ~XMLText() {}
889 XMLText( const XMLText& ); // not supported
890 XMLText& operator=( const XMLText& ); // not supported
Lee Thomason5492a1c2012-01-23 15:32:10 -0800891
892private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700893 bool _isCData;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800894};
895
896
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800897/** An XML Comment. */
PKEuS16ed47d2013-07-06 12:02:43 +0200898class TINYXML2_LIB XMLComment : public XMLNode
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800899{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700900 friend class XMLDocument;
Lee Thomason3f57d272012-01-11 15:30:03 -0800901public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700902 virtual XMLComment* ToComment() {
903 return this;
904 }
905 virtual const XMLComment* ToComment() const {
906 return this;
907 }
Lee Thomasonce0763e2012-01-11 15:43:54 -0800908
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700909 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800910
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700911 char* ParseDeep( char*, StrPair* endTag );
912 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
913 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomasonce0763e2012-01-11 15:43:54 -0800914
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800915protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700916 XMLComment( XMLDocument* doc );
917 virtual ~XMLComment();
918 XMLComment( const XMLComment& ); // not supported
919 XMLComment& operator=( const XMLComment& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800920
Lee Thomason3f57d272012-01-11 15:30:03 -0800921private:
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800922};
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800923
924
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800925/** In correct XML the declaration is the first entry in the file.
926 @verbatim
927 <?xml version="1.0" standalone="yes"?>
928 @endverbatim
929
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600930 TinyXML-2 will happily read or write files without a declaration,
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800931 however.
932
933 The text of the declaration isn't interpreted. It is parsed
934 and written as a string.
935*/
PKEuS16ed47d2013-07-06 12:02:43 +0200936class TINYXML2_LIB XMLDeclaration : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -0800937{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700938 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -0800939public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700940 virtual XMLDeclaration* ToDeclaration() {
941 return this;
942 }
943 virtual const XMLDeclaration* ToDeclaration() const {
944 return this;
945 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800946
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700947 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800948
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700949 char* ParseDeep( char*, StrPair* endTag );
950 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
951 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800952
953protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700954 XMLDeclaration( XMLDocument* doc );
955 virtual ~XMLDeclaration();
956 XMLDeclaration( const XMLDeclaration& ); // not supported
957 XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -0800958};
959
960
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600961/** Any tag that TinyXML-2 doesn't recognize is saved as an
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800962 unknown. It is a tag of text, but should not be modified.
963 It will be written back to the XML, unchanged, when the file
964 is saved.
965
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600966 DTD tags get thrown into XMLUnknowns.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800967*/
PKEuS16ed47d2013-07-06 12:02:43 +0200968class TINYXML2_LIB XMLUnknown : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -0800969{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700970 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -0800971public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700972 virtual XMLUnknown* ToUnknown() {
973 return this;
974 }
975 virtual const XMLUnknown* ToUnknown() const {
976 return this;
977 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800978
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700979 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800980
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700981 char* ParseDeep( char*, StrPair* endTag );
982 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
983 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800984
985protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700986 XMLUnknown( XMLDocument* doc );
987 virtual ~XMLUnknown();
988 XMLUnknown( const XMLUnknown& ); // not supported
989 XMLUnknown& operator=( const XMLUnknown& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -0800990};
991
992
Lee Thomason2fa81722012-11-09 12:37:46 -0800993enum XMLError {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700994 XML_NO_ERROR = 0,
995 XML_SUCCESS = 0,
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800996
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700997 XML_NO_ATTRIBUTE,
998 XML_WRONG_ATTRIBUTE_TYPE,
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800999
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001000 XML_ERROR_FILE_NOT_FOUND,
1001 XML_ERROR_FILE_COULD_NOT_BE_OPENED,
1002 XML_ERROR_FILE_READ_ERROR,
1003 XML_ERROR_ELEMENT_MISMATCH,
1004 XML_ERROR_PARSING_ELEMENT,
1005 XML_ERROR_PARSING_ATTRIBUTE,
1006 XML_ERROR_IDENTIFYING_TAG,
1007 XML_ERROR_PARSING_TEXT,
1008 XML_ERROR_PARSING_CDATA,
1009 XML_ERROR_PARSING_COMMENT,
1010 XML_ERROR_PARSING_DECLARATION,
1011 XML_ERROR_PARSING_UNKNOWN,
1012 XML_ERROR_EMPTY_DOCUMENT,
1013 XML_ERROR_MISMATCHED_ELEMENT,
1014 XML_ERROR_PARSING,
Lee Thomason21be8822012-07-15 17:27:22 -07001015
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001016 XML_CAN_NOT_CONVERT_TEXT,
1017 XML_NO_TEXT_NODE
Lee Thomason1ff38e02012-02-14 18:18:16 -08001018};
1019
1020
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001021/** An attribute is a name-value pair. Elements have an arbitrary
1022 number of attributes, each with a unique name.
1023
1024 @note The attributes are not XMLNodes. You may only query the
1025 Next() attribute in a list.
1026*/
PKEuS16ed47d2013-07-06 12:02:43 +02001027class TINYXML2_LIB XMLAttribute
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001028{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001029 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001030public:
Lee Thomason2fa81722012-11-09 12:37:46 -08001031 /// The name of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001032 const char* Name() const;
1033
Lee Thomason2fa81722012-11-09 12:37:46 -08001034 /// The value of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001035 const char* Value() const;
1036
Lee Thomason2fa81722012-11-09 12:37:46 -08001037 /// The next attribute in the list.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001038 const XMLAttribute* Next() const {
MortenMacFly4ee49f12013-01-14 20:03:14 +01001039 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001040 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001041
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001042 /** IntValue interprets the attribute as an integer, and returns the value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001043 If the value isn't an integer, 0 will be returned. There is no error checking;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001044 use QueryIntValue() if you need error checking.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001045 */
1046 int IntValue() const {
1047 int i=0;
1048 QueryIntValue( &i );
1049 return i;
1050 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001051 /// Query as an unsigned integer. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001052 unsigned UnsignedValue() const {
1053 unsigned i=0;
1054 QueryUnsignedValue( &i );
1055 return i;
1056 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001057 /// Query as a boolean. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001058 bool BoolValue() const {
1059 bool b=false;
1060 QueryBoolValue( &b );
1061 return b;
1062 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001063 /// Query as a double. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001064 double DoubleValue() const {
1065 double d=0;
1066 QueryDoubleValue( &d );
1067 return d;
1068 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001069 /// Query as a float. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001070 float FloatValue() const {
1071 float f=0;
1072 QueryFloatValue( &f );
1073 return f;
1074 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001075
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001076 /** QueryIntValue interprets the attribute as an integer, and returns the value
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001077 in the provided parameter. The function will return XML_NO_ERROR on success,
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001078 and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
1079 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001080 XMLError QueryIntValue( int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001081 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001082 XMLError QueryUnsignedValue( unsigned int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001083 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001084 XMLError QueryBoolValue( bool* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001085 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001086 XMLError QueryDoubleValue( double* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001087 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001088 XMLError QueryFloatValue( float* value ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -08001089
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001090 /// Set the attribute to a string value.
1091 void SetAttribute( const char* value );
1092 /// Set the attribute to value.
1093 void SetAttribute( int value );
1094 /// Set the attribute to value.
1095 void SetAttribute( unsigned value );
1096 /// Set the attribute to value.
1097 void SetAttribute( bool value );
1098 /// Set the attribute to value.
1099 void SetAttribute( double value );
1100 /// Set the attribute to value.
1101 void SetAttribute( float value );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001102
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001103private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001104 enum { BUF_SIZE = 200 };
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001105
Thomas Roß61892312013-05-12 14:07:38 +02001106 XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001107 virtual ~XMLAttribute() {}
Lee Thomason624d43f2012-10-12 10:58:48 -07001108
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001109 XMLAttribute( const XMLAttribute& ); // not supported
1110 void operator=( const XMLAttribute& ); // not supported
1111 void SetName( const char* name );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001112
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001113 char* ParseDeep( char* p, bool processEntities );
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001114
Lee Thomason624d43f2012-10-12 10:58:48 -07001115 mutable StrPair _name;
1116 mutable StrPair _value;
1117 XMLAttribute* _next;
1118 MemPool* _memPool;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001119};
1120
1121
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001122/** The element is a container class. It has a value, the element name,
1123 and can contain other elements, text, comments, and unknowns.
1124 Elements also contain an arbitrary number of attributes.
1125*/
PKEuS16ed47d2013-07-06 12:02:43 +02001126class TINYXML2_LIB XMLElement : public XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001127{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001128 friend class XMLBase;
1129 friend class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001130public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001131 /// Get the name of an element (which is the Value() of the node.)
1132 const char* Name() const {
1133 return Value();
1134 }
1135 /// Set the name of the element.
1136 void SetName( const char* str, bool staticMem=false ) {
1137 SetValue( str, staticMem );
1138 }
Lee Thomason2c85a712012-01-31 08:24:24 -08001139
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001140 virtual XMLElement* ToElement() {
1141 return this;
1142 }
1143 virtual const XMLElement* ToElement() const {
1144 return this;
1145 }
1146 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001147
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001148 /** Given an attribute name, Attribute() returns the value
1149 for the attribute of that name, or null if none
1150 exists. For example:
Lee Thomason92258152012-03-24 13:05:39 -07001151
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001152 @verbatim
1153 const char* value = ele->Attribute( "foo" );
1154 @endverbatim
Lee Thomason92258152012-03-24 13:05:39 -07001155
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001156 The 'value' parameter is normally null. However, if specified,
1157 the attribute will only be returned if the 'name' and 'value'
1158 match. This allow you to write code:
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001159
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001160 @verbatim
1161 if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
1162 @endverbatim
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001163
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001164 rather than:
1165 @verbatim
1166 if ( ele->Attribute( "foo" ) ) {
1167 if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
1168 }
1169 @endverbatim
1170 */
1171 const char* Attribute( const char* name, const char* value=0 ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001172
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001173 /** Given an attribute name, IntAttribute() returns the value
1174 of the attribute interpreted as an integer. 0 will be
1175 returned if there is an error. For a method with error
1176 checking, see QueryIntAttribute()
1177 */
1178 int IntAttribute( const char* name ) const {
1179 int i=0;
1180 QueryIntAttribute( name, &i );
1181 return i;
1182 }
1183 /// See IntAttribute()
1184 unsigned UnsignedAttribute( const char* name ) const {
1185 unsigned i=0;
1186 QueryUnsignedAttribute( name, &i );
1187 return i;
1188 }
1189 /// See IntAttribute()
1190 bool BoolAttribute( const char* name ) const {
1191 bool b=false;
1192 QueryBoolAttribute( name, &b );
1193 return b;
1194 }
1195 /// See IntAttribute()
1196 double DoubleAttribute( const char* name ) const {
1197 double d=0;
1198 QueryDoubleAttribute( name, &d );
1199 return d;
1200 }
1201 /// See IntAttribute()
1202 float FloatAttribute( const char* name ) const {
1203 float f=0;
1204 QueryFloatAttribute( name, &f );
1205 return f;
1206 }
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001207
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001208 /** Given an attribute name, QueryIntAttribute() returns
1209 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1210 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1211 doesn't exist. If successful, the result of the conversion
1212 will be written to 'value'. If not successful, nothing will
1213 be written to 'value'. This allows you to provide default
1214 value:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001215
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001216 @verbatim
1217 int value = 10;
1218 QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1219 @endverbatim
1220 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001221 XMLError QueryIntAttribute( const char* name, int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001222 const XMLAttribute* a = FindAttribute( name );
1223 if ( !a ) {
1224 return XML_NO_ATTRIBUTE;
1225 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001226 return a->QueryIntValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001227 }
1228 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001229 XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001230 const XMLAttribute* a = FindAttribute( name );
1231 if ( !a ) {
1232 return XML_NO_ATTRIBUTE;
1233 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001234 return a->QueryUnsignedValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001235 }
1236 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001237 XMLError QueryBoolAttribute( const char* name, bool* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001238 const XMLAttribute* a = FindAttribute( name );
1239 if ( !a ) {
1240 return XML_NO_ATTRIBUTE;
1241 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001242 return a->QueryBoolValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001243 }
1244 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001245 XMLError QueryDoubleAttribute( const char* name, double* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001246 const XMLAttribute* a = FindAttribute( name );
1247 if ( !a ) {
1248 return XML_NO_ATTRIBUTE;
1249 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001250 return a->QueryDoubleValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001251 }
1252 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001253 XMLError QueryFloatAttribute( const char* name, float* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001254 const XMLAttribute* a = FindAttribute( name );
1255 if ( !a ) {
1256 return XML_NO_ATTRIBUTE;
1257 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001258 return a->QueryFloatValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001259 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001260
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001261
1262 /** Given an attribute name, QueryAttribute() returns
1263 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1264 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1265 doesn't exist. It is overloaded for the primitive types,
1266 and is a generally more convenient replacement of
1267 QueryIntAttribute() and related functions.
1268
1269 If successful, the result of the conversion
1270 will be written to 'value'. If not successful, nothing will
1271 be written to 'value'. This allows you to provide default
1272 value:
1273
1274 @verbatim
1275 int value = 10;
1276 QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1277 @endverbatim
1278 */
1279 int QueryAttribute( const char* name, int* value ) const {
1280 return QueryIntAttribute( name, value );
1281 }
1282
1283 int QueryAttribute( const char* name, unsigned int* value ) const {
1284 return QueryUnsignedAttribute( name, value );
1285 }
1286
1287 int QueryAttribute( const char* name, bool* value ) const {
1288 return QueryBoolAttribute( name, value );
1289 }
1290
1291 int QueryAttribute( const char* name, double* value ) const {
1292 return QueryDoubleAttribute( name, value );
1293 }
1294
1295 int QueryAttribute( const char* name, float* value ) const {
1296 return QueryFloatAttribute( name, value );
1297 }
1298
1299 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001300 void SetAttribute( const char* name, const char* value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001301 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001302 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001303 }
1304 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001305 void SetAttribute( const char* name, int value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001306 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001307 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001308 }
1309 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001310 void SetAttribute( const char* name, unsigned value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001311 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001312 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001313 }
1314 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001315 void SetAttribute( const char* name, bool value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001316 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001317 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001318 }
1319 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001320 void SetAttribute( const char* name, double value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001321 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001322 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001323 }
Lee Thomasonc3708cc2014-01-14 12:30:03 -08001324 /// Sets the named attribute to value.
1325 void SetAttribute( const char* name, float value ) {
1326 XMLAttribute* a = FindOrCreateAttribute( name );
1327 a->SetAttribute( value );
1328 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001329
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001330 /**
1331 Delete an attribute.
1332 */
1333 void DeleteAttribute( const char* name );
Lee Thomason751da522012-02-10 08:50:51 -08001334
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001335 /// Return the first attribute in the list.
1336 const XMLAttribute* FirstAttribute() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001337 return _rootAttribute;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001338 }
1339 /// Query a specific attribute in the list.
1340 const XMLAttribute* FindAttribute( const char* name ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001341
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001342 /** Convenience function for easy access to the text inside an element. Although easy
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001343 and concise, GetText() is limited compared to getting the XMLText child
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001344 and accessing it directly.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001345
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001346 If the first child of 'this' is a XMLText, the GetText()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001347 returns the character string of the Text node, else null is returned.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001348
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001349 This is a convenient method for getting the text of simple contained text:
1350 @verbatim
1351 <foo>This is text</foo>
1352 const char* str = fooElement->GetText();
1353 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001354
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001355 'str' will be a pointer to "This is text".
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001356
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001357 Note that this function can be misleading. If the element foo was created from
1358 this XML:
1359 @verbatim
1360 <foo><b>This is text</b></foo>
1361 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001362
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001363 then the value of str would be null. The first child node isn't a text node, it is
1364 another element. From this XML:
1365 @verbatim
1366 <foo>This is <b>text</b></foo>
1367 @endverbatim
1368 GetText() will return "This is ".
1369 */
1370 const char* GetText() const;
Lee Thomason751da522012-02-10 08:50:51 -08001371
Uli Kusterer8fe342a2014-01-21 01:12:47 +01001372 void SetText( const char* inText );
1373
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001374 /**
1375 Convenience method to query the value of a child text node. This is probably best
1376 shown by example. Given you have a document is this form:
1377 @verbatim
1378 <point>
1379 <x>1</x>
1380 <y>1.4</y>
1381 </point>
1382 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001383
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001384 The QueryIntText() and similar functions provide a safe and easier way to get to the
1385 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001386
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001387 @verbatim
1388 int x = 0;
1389 float y = 0; // types of x and y are contrived for example
1390 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1391 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1392 xElement->QueryIntText( &x );
1393 yElement->QueryFloatText( &y );
1394 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001395
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001396 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1397 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 -07001398
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001399 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001400 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001401 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001402 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001403 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001404 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001405 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001406 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001407 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001408 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001409
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001410 // internal:
1411 enum {
1412 OPEN, // <foo>
1413 CLOSED, // <foo/>
1414 CLOSING // </foo>
1415 };
1416 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001417 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001418 }
1419 char* ParseDeep( char* p, StrPair* endTag );
1420 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1421 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001422
Lee Thomason50adb4c2012-02-13 15:07:09 -08001423private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001424 XMLElement( XMLDocument* doc );
1425 virtual ~XMLElement();
1426 XMLElement( const XMLElement& ); // not supported
1427 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001428
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001429 XMLAttribute* FindAttribute( const char* name );
1430 XMLAttribute* FindOrCreateAttribute( const char* name );
1431 //void LinkAttribute( XMLAttribute* attrib );
1432 char* ParseAttributes( char* p );
Lee Thomason67d61312012-01-24 16:01:51 -08001433
Lee Thomason624d43f2012-10-12 10:58:48 -07001434 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001435 // The attribute list is ordered; there is no 'lastAttribute'
1436 // because the list needs to be scanned for dupes before adding
1437 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001438 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001439};
1440
1441
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001442enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001443 PRESERVE_WHITESPACE,
1444 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001445};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001446
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001447
1448/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001449 It can be saved, loaded, and printed to the screen.
1450 All Nodes are connected and allocated to a Document.
1451 If the Document is deleted, all its Nodes are also deleted.
1452*/
PKEuS16ed47d2013-07-06 12:02:43 +02001453class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001454{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001455 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001456public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001457 /// constructor
1458 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1459 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001460
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001461 virtual XMLDocument* ToDocument() {
1462 return this;
1463 }
1464 virtual const XMLDocument* ToDocument() const {
1465 return this;
1466 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001467
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001468 /**
1469 Parse an XML file from a character string.
1470 Returns XML_NO_ERROR (0) on success, or
1471 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001472
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001473 You may optionally pass in the 'nBytes', which is
1474 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001475 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001476 null terminated string.
1477 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001478 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001479
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001480 /**
1481 Load an XML file from disk.
1482 Returns XML_NO_ERROR (0) on success, or
1483 an errorID.
1484 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001485 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001486
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001487 /**
1488 Load an XML file from disk. You are responsible
1489 for providing and closing the FILE*.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001490
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001491 Returns XML_NO_ERROR (0) on success, or
1492 an errorID.
1493 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001494 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001495
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001496 /**
1497 Save the XML file to disk.
1498 Returns XML_NO_ERROR (0) on success, or
1499 an errorID.
1500 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001501 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001502
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001503 /**
1504 Save the XML file to disk. You are responsible
1505 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001506
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001507 Returns XML_NO_ERROR (0) on success, or
1508 an errorID.
1509 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001510 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001511
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001512 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001513 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001514 }
1515 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001516 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001517 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001518
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001519 /**
1520 Returns true if this document has a leading Byte Order Mark of UTF8.
1521 */
1522 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001523 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001524 }
1525 /** Sets whether to write the BOM when writing the file.
1526 */
1527 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001528 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001529 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001530
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001531 /** Return the root element of DOM. Equivalent to FirstChildElement().
1532 To get the first node, use FirstChild().
1533 */
1534 XMLElement* RootElement() {
1535 return FirstChildElement();
1536 }
1537 const XMLElement* RootElement() const {
1538 return FirstChildElement();
1539 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001540
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001541 /** Print the Document. If the Printer is not provided, it will
1542 print to stdout. If you provide Printer, this can print to a file:
1543 @verbatim
1544 XMLPrinter printer( fp );
1545 doc.Print( &printer );
1546 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001547
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001548 Or you can use a printer to print to memory:
1549 @verbatim
1550 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001551 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001552 // printer.CStr() has a const char* to the XML
1553 @endverbatim
1554 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001555 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001556 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001557
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001558 /**
1559 Create a new Element associated with
1560 this Document. The memory for the Element
1561 is managed by the Document.
1562 */
1563 XMLElement* NewElement( const char* name );
1564 /**
1565 Create a new Comment associated with
1566 this Document. The memory for the Comment
1567 is managed by the Document.
1568 */
1569 XMLComment* NewComment( const char* comment );
1570 /**
1571 Create a new Text associated with
1572 this Document. The memory for the Text
1573 is managed by the Document.
1574 */
1575 XMLText* NewText( const char* text );
1576 /**
1577 Create a new Declaration associated with
1578 this Document. The memory for the object
1579 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001580
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001581 If the 'text' param is null, the standard
1582 declaration is used.:
1583 @verbatim
1584 <?xml version="1.0" encoding="UTF-8"?>
1585 @endverbatim
1586 */
1587 XMLDeclaration* NewDeclaration( const char* text=0 );
1588 /**
1589 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001590 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001591 is managed by the Document.
1592 */
1593 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001594
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001595 /**
1596 Delete a node associated with this document.
1597 It will be unlinked from the DOM.
1598 */
1599 void DeleteNode( XMLNode* node ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001600 node->_parent->DeleteChild( node );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001601 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001602
Lee Thomason2fa81722012-11-09 12:37:46 -08001603 void SetError( XMLError error, const char* str1, const char* str2 );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001604
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001605 /// Return true if there was an error parsing the document.
1606 bool Error() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001607 return _errorID != XML_NO_ERROR;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001608 }
1609 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001610 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001611 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001612 }
1613 /// Return a possibly helpful diagnostic location or string.
1614 const char* GetErrorStr1() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001615 return _errorStr1;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001616 }
1617 /// Return a possibly helpful secondary diagnostic location or string.
1618 const char* GetErrorStr2() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001619 return _errorStr2;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001620 }
1621 /// If there is an error, print it to stdout.
1622 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001623
1624 /// Clear the document, resetting it to the initial state.
1625 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001626
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001627 // internal
1628 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001629
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001630 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1631 return 0;
1632 }
1633 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1634 return false;
1635 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001636
Lee Thomason3f57d272012-01-11 15:30:03 -08001637private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001638 XMLDocument( const XMLDocument& ); // not supported
1639 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001640
Lee Thomason2fa81722012-11-09 12:37:46 -08001641 bool _writeBOM;
1642 bool _processEntities;
1643 XMLError _errorID;
1644 Whitespace _whitespace;
Lee Thomason624d43f2012-10-12 10:58:48 -07001645 const char* _errorStr1;
1646 const char* _errorStr2;
Lee Thomason2fa81722012-11-09 12:37:46 -08001647 char* _charBuffer;
Lee Thomasond1983222012-02-06 08:41:24 -08001648
Lee Thomason624d43f2012-10-12 10:58:48 -07001649 MemPoolT< sizeof(XMLElement) > _elementPool;
1650 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1651 MemPoolT< sizeof(XMLText) > _textPool;
1652 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason5cae8972012-01-24 18:03:07 -08001653};
1654
Lee Thomason7c913cd2012-01-26 18:32:34 -08001655
Lee Thomason3ffdd392012-03-28 17:27:55 -07001656/**
1657 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001658 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001659 DOM structure. It is a separate utility class.
1660
1661 Take an example:
1662 @verbatim
1663 <Document>
1664 <Element attributeA = "valueA">
1665 <Child attributeB = "value1" />
1666 <Child attributeB = "value2" />
1667 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001668 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001669 @endverbatim
1670
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001671 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001672 easy to write a *lot* of code that looks like:
1673
1674 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001675 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001676 if ( root )
1677 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001678 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001679 if ( element )
1680 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001681 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001682 if ( child )
1683 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001684 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001685 if ( child2 )
1686 {
1687 // Finally do something useful.
1688 @endverbatim
1689
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001690 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001691 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001692 and correct to use:
1693
1694 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001695 XMLHandle docHandle( &document );
1696 XMLElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild().NextSibling().ToElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001697 if ( child2 )
1698 {
1699 // do something useful
1700 @endverbatim
1701
1702 Which is MUCH more concise and useful.
1703
1704 It is also safe to copy handles - internally they are nothing more than node pointers.
1705 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001706 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001707 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001708
1709 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001710*/
PKEuS16ed47d2013-07-06 12:02:43 +02001711class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001712{
1713public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001714 /// 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 -07001715 XMLHandle( XMLNode* node ) {
1716 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001717 }
1718 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001719 XMLHandle( XMLNode& node ) {
1720 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001721 }
1722 /// Copy constructor
1723 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001724 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001725 }
1726 /// Assignment
1727 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001728 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001729 return *this;
1730 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001731
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001732 /// Get the first child of this handle.
1733 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001734 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001735 }
1736 /// Get the first child element of this handle.
1737 XMLHandle FirstChildElement( const char* value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001738 return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001739 }
1740 /// Get the last child of this handle.
1741 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001742 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001743 }
1744 /// Get the last child element of this handle.
1745 XMLHandle LastChildElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001746 return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001747 }
1748 /// Get the previous sibling of this handle.
1749 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001750 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001751 }
1752 /// Get the previous sibling element of this handle.
1753 XMLHandle PreviousSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001754 return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001755 }
1756 /// Get the next sibling of this handle.
1757 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001758 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001759 }
1760 /// Get the next sibling element of this handle.
1761 XMLHandle NextSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001762 return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001763 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001764
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001765 /// Safe cast to XMLNode. This can return null.
1766 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001767 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001768 }
1769 /// Safe cast to XMLElement. This can return null.
1770 XMLElement* ToElement() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001771 return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001772 }
1773 /// Safe cast to XMLText. This can return null.
1774 XMLText* ToText() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001775 return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001776 }
1777 /// Safe cast to XMLUnknown. This can return null.
1778 XMLUnknown* ToUnknown() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001779 return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001780 }
1781 /// Safe cast to XMLDeclaration. This can return null.
1782 XMLDeclaration* ToDeclaration() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001783 return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001784 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001785
1786private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001787 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001788};
1789
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001790
1791/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001792 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1793 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001794*/
PKEuS16ed47d2013-07-06 12:02:43 +02001795class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001796{
1797public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001798 XMLConstHandle( const XMLNode* node ) {
1799 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001800 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001801 XMLConstHandle( const XMLNode& node ) {
1802 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001803 }
1804 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001805 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001806 }
Lee Thomason8b899812012-04-04 15:58:16 -07001807
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001808 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001809 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001810 return *this;
1811 }
Lee Thomason8b899812012-04-04 15:58:16 -07001812
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001813 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001814 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001815 }
1816 const XMLConstHandle FirstChildElement( const char* value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001817 return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001818 }
1819 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001820 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001821 }
1822 const XMLConstHandle LastChildElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001823 return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001824 }
1825 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001826 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001827 }
1828 const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001829 return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001830 }
1831 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001832 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001833 }
1834 const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001835 return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001836 }
Lee Thomason8b899812012-04-04 15:58:16 -07001837
1838
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001839 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001840 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001841 }
1842 const XMLElement* ToElement() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001843 return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001844 }
1845 const XMLText* ToText() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001846 return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001847 }
1848 const XMLUnknown* ToUnknown() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001849 return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001850 }
1851 const XMLDeclaration* ToDeclaration() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001852 return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001853 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08001854
Lee Thomason5cae8972012-01-24 18:03:07 -08001855private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001856 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08001857};
Lee Thomason6f381b72012-03-02 12:59:39 -08001858
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001859
1860/**
1861 Printing functionality. The XMLPrinter gives you more
1862 options than the XMLDocument::Print() method.
1863
1864 It can:
1865 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02001866 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001867 -# Print XML without a XMLDocument.
1868
1869 Print to Memory
1870
1871 @verbatim
1872 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001873 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02001874 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001875 @endverbatim
1876
1877 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001878
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001879 You provide the file pointer.
1880 @verbatim
1881 XMLPrinter printer( fp );
1882 doc.Print( &printer );
1883 @endverbatim
1884
1885 Print without a XMLDocument
1886
1887 When loading, an XML parser is very useful. However, sometimes
1888 when saving, it just gets in the way. The code is often set up
1889 for streaming, and constructing the DOM is just overhead.
1890
1891 The Printer supports the streaming case. The following code
1892 prints out a trivially simple XML file without ever creating
1893 an XML document.
1894
1895 @verbatim
1896 XMLPrinter printer( fp );
1897 printer.OpenElement( "foo" );
1898 printer.PushAttribute( "foo", "bar" );
1899 printer.CloseElement();
1900 @endverbatim
1901*/
PKEuS16ed47d2013-07-06 12:02:43 +02001902class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001903{
1904public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001905 /** Construct the printer. If the FILE* is specified,
1906 this will print to the FILE. Else it will print
1907 to memory, and the result is available in CStr().
1908 If 'compact' is set to true, then output is created
1909 with only required whitespace and newlines.
1910 */
PKEuS1bfb9542013-08-04 13:51:17 +02001911 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05001912 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001913
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001914 /** If streaming, write the BOM and declaration. */
1915 void PushHeader( bool writeBOM, bool writeDeclaration );
1916 /** If streaming, start writing an element.
1917 The element must be closed with CloseElement()
1918 */
1919 void OpenElement( const char* name );
1920 /// If streaming, add an attribute to an open element.
1921 void PushAttribute( const char* name, const char* value );
1922 void PushAttribute( const char* name, int value );
1923 void PushAttribute( const char* name, unsigned value );
1924 void PushAttribute( const char* name, bool value );
1925 void PushAttribute( const char* name, double value );
1926 /// If streaming, close the Element.
Dennis Jenkins59c75d32013-10-08 13:10:07 -05001927 virtual void CloseElement();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001928
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001929 /// Add a text node.
1930 void PushText( const char* text, bool cdata=false );
1931 /// Add a text node from an integer.
1932 void PushText( int value );
1933 /// Add a text node from an unsigned.
1934 void PushText( unsigned value );
1935 /// Add a text node from a bool.
1936 void PushText( bool value );
1937 /// Add a text node from a float.
1938 void PushText( float value );
1939 /// Add a text node from a double.
1940 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07001941
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001942 /// Add a comment
1943 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001944
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001945 void PushDeclaration( const char* value );
1946 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001947
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001948 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
1949 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
1950 return true;
1951 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001952
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001953 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
1954 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001955
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001956 virtual bool Visit( const XMLText& text );
1957 virtual bool Visit( const XMLComment& comment );
1958 virtual bool Visit( const XMLDeclaration& declaration );
1959 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001960
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001961 /**
1962 If in print to memory mode, return a pointer to
1963 the XML file in memory.
1964 */
1965 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001966 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001967 }
1968 /**
1969 If in print to memory mode, return the size
1970 of the XML file in memory. (Note the size returned
1971 includes the terminating null.)
1972 */
1973 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001974 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001975 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01001976 /**
1977 If in print to memory mode, reset the buffer to the
1978 beginning.
1979 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08001980 void ClearBuffer() {
1981 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01001982 _buffer.Push(0);
1983 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001984
Dennis Jenkins59c75d32013-10-08 13:10:07 -05001985protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001986 void SealElement();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05001987 bool _elementJustOpened;
1988 DynArray< const char*, 10 > _stack;
1989
1990private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001991 void PrintSpace( int depth );
1992 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
1993 void Print( const char* format, ... );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001994
Lee Thomason624d43f2012-10-12 10:58:48 -07001995 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001996 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07001997 int _depth;
1998 int _textDepth;
1999 bool _processEntities;
2000 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002001
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002002 enum {
2003 ENTITY_RANGE = 64,
2004 BUF_SIZE = 200
2005 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002006 bool _entityFlag[ENTITY_RANGE];
2007 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002008
Lee Thomason624d43f2012-10-12 10:58:48 -07002009 DynArray< char, 20 > _buffer;
PKEuSe736f292012-07-16 03:27:55 -07002010#ifdef _MSC_VER
Lee Thomason624d43f2012-10-12 10:58:48 -07002011 DynArray< char, 20 > _accumulator;
PKEuSe736f292012-07-16 03:27:55 -07002012#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002013};
2014
2015
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002016} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002017
PKEuS95060352013-07-26 10:42:44 +02002018#if defined(_MSC_VER)
2019# pragma warning(pop)
2020#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002021
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002022#endif // TINYXML2_INCLUDED