blob: 52b6d2ca299d16f2735f6f78d8759c74d2b50b5b [file] [log] [blame]
Lee Thomason (grinliz)28129862012-02-25 21:11:20 -08001/*
2Original code by Lee Thomason (www.grinninglizard.com)
3
4This software is provided 'as-is', without any express or implied
5warranty. In no event will the authors be held liable for any
6damages arising from the use of this software.
7
8Permission is granted to anyone to use this software for any
9purpose, including commercial applications, and to alter it and
10redistribute it freely, subject to the following restrictions:
11
121. The origin of this software must not be misrepresented; you must
13not claim that you wrote the original software. If you use this
14software in a product, an acknowledgment in the product documentation
15would be appreciated but is not required.
16
172. Altered source versions must be plainly marked as such, and
18must not be misrepresented as being the original software.
19
203. This notice may not be removed or altered from any source
21distribution.
22*/
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -080023
Lee Thomason7d00b9a2012-02-27 17:54:22 -080024#ifndef TINYXML2_INCLUDED
U-Lama\Leee13c3e62011-12-28 14:36:55 -080025#define TINYXML2_INCLUDED
26
Jerome Martinez242c3ea2013-01-06 12:20:04 +010027#if defined(ANDROID_NDK) || defined(__BORLANDC__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070028# include <ctype.h>
29# include <limits.h>
30# include <stdio.h>
31# include <stdlib.h>
32# include <string.h>
33# include <stdarg.h>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070034#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -070035# include <cctype>
36# include <climits>
37# include <cstdio>
38# include <cstdlib>
39# include <cstring>
40# include <cstdarg>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070041#endif
Lee Thomason (grinliz)6a22be22012-04-04 12:39:05 -070042
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -070043/*
Lee Thomason7d00b9a2012-02-27 17:54:22 -080044 TODO: intern strings instead of allocation.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080045*/
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080046/*
Lee Thomasona9cf3f92012-10-11 16:56:51 -070047 gcc:
Lee Thomason5b0a6772012-11-19 13:54:42 -080048 g++ -Wall -DDEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
MortenMacFly4ee49f12013-01-14 20:03:14 +010049
Lee Thomasona9cf3f92012-10-11 16:56:51 -070050 Formatting, Artistic Style:
51 AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080052*/
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080053
U-Lama\Lee4cee6112011-12-31 14:58:18 -080054#if defined( _DEBUG ) || defined( DEBUG ) || defined (__DEBUG__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070055# ifndef DEBUG
56# define DEBUG
57# endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080058#endif
59
PKEuS95060352013-07-26 10:42:44 +020060#ifdef _MSC_VER
61# pragma warning(push)
62# pragma warning(disable: 4251)
63#endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080064
PKEuS16ed47d2013-07-06 12:02:43 +020065#ifdef _WIN32
66# ifdef TINYXML2_EXPORT
67# define TINYXML2_LIB __declspec(dllexport)
68# elif defined(TINYXML2_IMPORT)
69# define TINYXML2_LIB __declspec(dllimport)
70# else
71# define TINYXML2_LIB
72# endif
73#else
74# define TINYXML2_LIB
75#endif
76
77
U-Lama\Lee4cee6112011-12-31 14:58:18 -080078#if defined(DEBUG)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070079# if defined(_MSC_VER)
80# define TIXMLASSERT( x ) if ( !(x)) { __debugbreak(); } //if ( !(x)) WinDebugBreak()
81# elif defined (ANDROID_NDK)
82# include <android/log.h>
83# define TIXMLASSERT( x ) if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
84# else
85# include <assert.h>
86# define TIXMLASSERT assert
87# endif
88# else
89# define TIXMLASSERT( x ) {}
U-Lama\Lee4cee6112011-12-31 14:58:18 -080090#endif
91
U-Lama\Leee13c3e62011-12-28 14:36:55 -080092
pffang91d34a02014-07-10 10:02:35 +080093#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070094// Microsoft visual studio, version 2005 and higher.
95/*int _snprintf_s(
96 char *buffer,
97 size_t sizeOfBuffer,
98 size_t count,
99 const char *format [,
100 argument] ...
101);*/
102inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
103{
104 va_list va;
105 va_start( va, format );
106 int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
107 va_end( va );
108 return result;
109}
110#define TIXML_SSCANF sscanf_s
pffang91d34a02014-07-10 10:02:35 +0800111#elif defined WINCE
112#define TIXML_SNPRINTF _snprintf
113#define TIXML_SSCANF sscanf
Lee Thomason (grinliz)b9e791f2012-04-06 21:27:10 -0700114#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700115// GCC version 3 and higher
116//#warning( "Using sn* functions." )
117#define TIXML_SNPRINTF snprintf
118#define TIXML_SSCANF sscanf
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800119#endif
Lee Thomason1ff38e02012-02-14 18:18:16 -0800120
Lee Thomasonc18eb232014-02-21 17:31:17 -0800121/* Versioning, past 1.0.14:
Lee Thomason85afe9c2014-02-23 21:42:16 -0800122 http://semver.org/
Lee Thomasonc18eb232014-02-21 17:31:17 -0800123*/
Lee Thomasonf07b9522014-10-30 13:25:12 -0700124static const int TIXML2_MAJOR_VERSION = 2;
125static const int TIXML2_MINOR_VERSION = 2;
126static const int TIXML2_PATCH_VERSION = 0;
Lee Thomason1ff38e02012-02-14 18:18:16 -0800127
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800128namespace tinyxml2
129{
Lee Thomasonce0763e2012-01-11 15:43:54 -0800130class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800131class XMLElement;
132class XMLAttribute;
133class XMLComment;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800134class XMLText;
Lee Thomason50f97b22012-02-11 16:33:40 -0800135class XMLDeclaration;
136class XMLUnknown;
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800137class XMLPrinter;
Lee Thomason5cae8972012-01-24 18:03:07 -0800138
U-Stream\Leeae25a442012-02-17 17:48:16 -0800139/*
140 A class that wraps strings. Normally stores the start and end
141 pointers into the XML file itself, and will apply normalization
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800142 and entity translation if actually read. Can also store (and memory
U-Stream\Leeae25a442012-02-17 17:48:16 -0800143 manage) a traditional char[]
144*/
PKEuS95060352013-07-26 10:42:44 +0200145class StrPair
Lee Thomason39ede242012-01-20 11:27:56 -0800146{
Lee Thomasond34f52c2012-01-20 12:55:24 -0800147public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700148 enum {
149 NEEDS_ENTITY_PROCESSING = 0x01,
150 NEEDS_NEWLINE_NORMALIZATION = 0x02,
selfpoisede77e1952013-03-13 14:08:29 +0800151 COLLAPSE_WHITESPACE = 0x04,
Lee Thomason18d68bd2012-01-26 18:17:26 -0800152
selfpoisede77e1952013-03-13 14:08:29 +0800153 TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700154 TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
selfpoisede77e1952013-03-13 14:08:29 +0800155 ATTRIBUTE_NAME = 0,
156 ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
157 ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
158 COMMENT = NEEDS_NEWLINE_NORMALIZATION
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700159 };
Lee Thomason39ede242012-01-20 11:27:56 -0800160
Lee Thomason120b3a62012-10-12 10:06:59 -0700161 StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700162 ~StrPair();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800163
Lee Thomason120b3a62012-10-12 10:06:59 -0700164 void Set( char* start, char* end, int flags ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700165 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700166 _start = start;
167 _end = end;
168 _flags = flags | NEEDS_FLUSH;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700169 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700170
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700171 const char* GetStr();
Lee Thomason120b3a62012-10-12 10:06:59 -0700172
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700173 bool Empty() const {
Lee Thomason120b3a62012-10-12 10:06:59 -0700174 return _start == _end;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700175 }
Lee Thomason39ede242012-01-20 11:27:56 -0800176
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700177 void SetInternedStr( const char* str ) {
178 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700179 _start = const_cast<char*>(str);
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700180 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700181
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700182 void SetStr( const char* str, int flags=0 );
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800183
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700184 char* ParseText( char* in, const char* endTag, int strFlags );
185 char* ParseName( char* in );
Lee Thomason56bdd022012-02-09 18:16:58 -0800186
Lee Thomason39ede242012-01-20 11:27:56 -0800187private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700188 void Reset();
189 void CollapseWhitespace();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800190
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700191 enum {
192 NEEDS_FLUSH = 0x100,
193 NEEDS_DELETE = 0x200
194 };
Lee Thomasone4422302012-01-20 17:59:50 -0800195
selfpoised4dd59bc2013-03-13 16:54:15 +0800196 // After parsing, if *_end != 0, it can be set to zero.
Lee Thomason120b3a62012-10-12 10:06:59 -0700197 int _flags;
198 char* _start;
199 char* _end;
Lee Thomason39ede242012-01-20 11:27:56 -0800200};
201
U-Lama\Lee560bd472011-12-28 19:42:49 -0800202
U-Stream\Leeae25a442012-02-17 17:48:16 -0800203/*
204 A dynamic array of Plain Old Data. Doesn't support constructors, etc.
205 Has a small initial memory pool, so that low or no usage will not
206 cause a call to new/delete
207*/
Lee Thomason2c85a712012-01-31 08:24:24 -0800208template <class T, int INIT>
PKEuS95060352013-07-26 10:42:44 +0200209class DynArray
Lee Thomason2c85a712012-01-31 08:24:24 -0800210{
211public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700212 DynArray< T, INIT >() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700213 _mem = _pool;
214 _allocated = INIT;
215 _size = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700216 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700217
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700218 ~DynArray() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700219 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700220 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700221 }
222 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700223
Lee Thomasonce0510b2013-11-26 21:29:37 -0800224 void Clear() {
Reinhard Klambauer4e74b132013-11-22 14:01:58 +0100225 _size = 0;
226 }
227
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700228 void Push( T t ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700229 EnsureCapacity( _size+1 );
230 _mem[_size++] = t;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700231 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800232
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700233 T* PushArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700234 EnsureCapacity( _size+count );
235 T* ret = &_mem[_size];
236 _size += count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700237 return ret;
238 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700239
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700240 T Pop() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700241 return _mem[--_size];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700242 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700243
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700244 void PopArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700245 TIXMLASSERT( _size >= count );
246 _size -= count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700247 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800248
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700249 bool Empty() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700250 return _size == 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700251 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700252
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700253 T& operator[](int i) {
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
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700258 const T& operator[](int i) const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700259 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700260 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700261 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700262
Lee Thomasonf07b9522014-10-30 13:25:12 -0700263 const T& PeekTop() const {
Dennis Jenkins59c75d32013-10-08 13:10:07 -0500264 TIXMLASSERT( _size > 0 );
265 return _mem[ _size - 1];
266 }
267
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700268 int Size() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700269 return _size;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700270 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700271
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700272 int Capacity() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700273 return _allocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700274 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700275
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700276 const T* Mem() const {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700277 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700278 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700279
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700280 T* Mem() {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700281 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700282 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800283
Lee Thomason2c85a712012-01-31 08:24:24 -0800284private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700285 void EnsureCapacity( int cap ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700286 if ( cap > _allocated ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700287 int newAllocated = cap * 2;
288 T* newMem = new T[newAllocated];
Lee Thomason624d43f2012-10-12 10:58:48 -0700289 memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
290 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700291 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700292 }
Lee Thomasoned5c8792012-10-12 10:09:48 -0700293 _mem = newMem;
Lee Thomason624d43f2012-10-12 10:58:48 -0700294 _allocated = newAllocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700295 }
296 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800297
Lee Thomason624d43f2012-10-12 10:58:48 -0700298 T* _mem;
299 T _pool[INIT];
300 int _allocated; // objects allocated
301 int _size; // number objects in use
Lee Thomason2c85a712012-01-31 08:24:24 -0800302};
303
Lee Thomason50adb4c2012-02-13 15:07:09 -0800304
U-Stream\Leeae25a442012-02-17 17:48:16 -0800305/*
Thomas Roß08bdf502012-05-12 14:21:23 +0200306 Parent virtual class of a pool for fast allocation
U-Stream\Leeae25a442012-02-17 17:48:16 -0800307 and deallocation of objects.
308*/
PKEuS95060352013-07-26 10:42:44 +0200309class MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800310{
311public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700312 MemPool() {}
313 virtual ~MemPool() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800314
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700315 virtual int ItemSize() const = 0;
316 virtual void* Alloc() = 0;
317 virtual void Free( void* ) = 0;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800318 virtual void SetTracked() = 0;
Lee Thomasonf07b9522014-10-30 13:25:12 -0700319 virtual void Clear() = 0;
Lee Thomasond1983222012-02-06 08:41:24 -0800320};
321
Lee Thomason50adb4c2012-02-13 15:07:09 -0800322
U-Stream\Leeae25a442012-02-17 17:48:16 -0800323/*
324 Template child class to create pools of the correct type.
325*/
Lee Thomasond1983222012-02-06 08:41:24 -0800326template< int SIZE >
PKEuS95060352013-07-26 10:42:44 +0200327class MemPoolT : public MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800328{
329public:
Lee Thomason5b0a6772012-11-19 13:54:42 -0800330 MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700331 ~MemPoolT() {
Lee Thomasonf07b9522014-10-30 13:25:12 -0700332 Clear();
333 }
334
335 void Clear() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700336 // Delete the blocks.
Lee Thomasonf07b9522014-10-30 13:25:12 -0700337 while( !_blockPtrs.Empty()) {
338 Block* b = _blockPtrs.Pop();
339 delete b;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700340 }
Lee Thomasonf07b9522014-10-30 13:25:12 -0700341 _root = 0;
342 _currentAllocs = 0;
343 _nAllocs = 0;
344 _maxAllocs = 0;
345 _nUntracked = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700346 }
Lee Thomasond1983222012-02-06 08:41:24 -0800347
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700348 virtual int ItemSize() const {
349 return SIZE;
350 }
351 int CurrentAllocs() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700352 return _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700353 }
Lee Thomasond1983222012-02-06 08:41:24 -0800354
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700355 virtual void* Alloc() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700356 if ( !_root ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700357 // Need a new block.
358 Block* block = new Block();
Lee Thomason624d43f2012-10-12 10:58:48 -0700359 _blockPtrs.Push( block );
Lee Thomasond1983222012-02-06 08:41:24 -0800360
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700361 for( int i=0; i<COUNT-1; ++i ) {
362 block->chunk[i].next = &block->chunk[i+1];
363 }
364 block->chunk[COUNT-1].next = 0;
Lee Thomason624d43f2012-10-12 10:58:48 -0700365 _root = block->chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700366 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700367 void* result = _root;
368 _root = _root->next;
Lee Thomason455c9d42012-02-06 09:14:14 -0800369
Lee Thomason624d43f2012-10-12 10:58:48 -0700370 ++_currentAllocs;
371 if ( _currentAllocs > _maxAllocs ) {
372 _maxAllocs = _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700373 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700374 _nAllocs++;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800375 _nUntracked++;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700376 return result;
377 }
Lee Thomasonf07b9522014-10-30 13:25:12 -0700378
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700379 virtual void Free( void* mem ) {
380 if ( !mem ) {
381 return;
382 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700383 --_currentAllocs;
Dmitry-Me56571762014-08-15 11:03:47 +0400384 Chunk* chunk = static_cast<Chunk*>( mem );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700385#ifdef DEBUG
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700386 memset( chunk, 0xfe, sizeof(Chunk) );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700387#endif
Lee Thomason624d43f2012-10-12 10:58:48 -0700388 chunk->next = _root;
389 _root = chunk;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700390 }
391 void Trace( const char* name ) {
392 printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
Lee Thomason624d43f2012-10-12 10:58:48 -0700393 name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700394 }
Lee Thomasond1983222012-02-06 08:41:24 -0800395
Lee Thomason5b0a6772012-11-19 13:54:42 -0800396 void SetTracked() {
397 _nUntracked--;
398 }
399
400 int Untracked() const {
401 return _nUntracked;
402 }
403
Lee Thomason (grinliz)ac83b4e2013-02-01 09:02:34 -0800404 // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
405 // The test file is large, 170k.
406 // Release: VS2010 gcc(no opt)
407 // 1k: 4000
408 // 2k: 4000
409 // 4k: 3900 21000
410 // 16k: 5200
411 // 32k: 4300
412 // 64k: 4000 21000
413 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 +0200414
Lee Thomasond1983222012-02-06 08:41:24 -0800415private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700416 union Chunk {
Lee Thomason624d43f2012-10-12 10:58:48 -0700417 Chunk* next;
418 char mem[SIZE];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700419 };
420 struct Block {
Lee Thomason (grinliz)856da212012-10-19 09:08:15 -0700421 Chunk chunk[COUNT];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700422 };
Lee Thomason624d43f2012-10-12 10:58:48 -0700423 DynArray< Block*, 10 > _blockPtrs;
424 Chunk* _root;
Lee Thomason455c9d42012-02-06 09:14:14 -0800425
Lee Thomason624d43f2012-10-12 10:58:48 -0700426 int _currentAllocs;
427 int _nAllocs;
428 int _maxAllocs;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800429 int _nUntracked;
Lee Thomasond1983222012-02-06 08:41:24 -0800430};
431
Lee Thomason2c85a712012-01-31 08:24:24 -0800432
Lee Thomason56bdd022012-02-09 18:16:58 -0800433
434/**
435 Implements the interface to the "Visitor pattern" (see the Accept() method.)
436 If you call the Accept() method, it requires being passed a XMLVisitor
437 class to handle callbacks. For nodes that contain other nodes (Document, Element)
Thomas Roß08bdf502012-05-12 14:21:23 +0200438 you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
Lee Thomason56bdd022012-02-09 18:16:58 -0800439 are simply called with Visit().
440
441 If you return 'true' from a Visit method, recursive parsing will continue. If you return
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700442 false, <b>no children of this node or its siblings</b> will be visited.
Lee Thomason56bdd022012-02-09 18:16:58 -0800443
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700444 All flavors of Visit methods have a default implementation that returns 'true' (continue
Lee Thomason56bdd022012-02-09 18:16:58 -0800445 visiting). You need to only override methods that are interesting to you.
446
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600447 Generally Accept() is called on the XMLDocument, although all nodes support visiting.
Lee Thomason56bdd022012-02-09 18:16:58 -0800448
449 You should never change the document from a callback.
450
451 @sa XMLNode::Accept()
452*/
PKEuS16ed47d2013-07-06 12:02:43 +0200453class TINYXML2_LIB XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800454{
455public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700456 virtual ~XMLVisitor() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800457
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700458 /// Visit a document.
459 virtual bool VisitEnter( const XMLDocument& /*doc*/ ) {
460 return true;
461 }
462 /// Visit a document.
463 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
464 return true;
465 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800466
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700467 /// Visit an element.
468 virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ ) {
469 return true;
470 }
471 /// Visit an element.
472 virtual bool VisitExit( const XMLElement& /*element*/ ) {
473 return true;
474 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800475
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700476 /// Visit a declaration.
477 virtual bool Visit( const XMLDeclaration& /*declaration*/ ) {
478 return true;
479 }
480 /// Visit a text node.
481 virtual bool Visit( const XMLText& /*text*/ ) {
482 return true;
483 }
484 /// Visit a comment node.
485 virtual bool Visit( const XMLComment& /*comment*/ ) {
486 return true;
487 }
488 /// Visit an unknown node.
489 virtual bool Visit( const XMLUnknown& /*unknown*/ ) {
490 return true;
491 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800492};
493
Lee Thomason331596e2014-09-11 14:56:43 -0700494// WARNING: must match XMLErrorNames[]
numatrumpetbb5ffac2014-09-06 22:56:46 +0900495enum XMLError {
numatrumpetcd8550c2014-09-08 16:59:39 +0900496 XML_SUCCESS = 0,
497 XML_NO_ERROR = 0,
498 XML_NO_ATTRIBUTE,
499 XML_WRONG_ATTRIBUTE_TYPE,
500 XML_ERROR_FILE_NOT_FOUND,
501 XML_ERROR_FILE_COULD_NOT_BE_OPENED,
502 XML_ERROR_FILE_READ_ERROR,
503 XML_ERROR_ELEMENT_MISMATCH,
504 XML_ERROR_PARSING_ELEMENT,
505 XML_ERROR_PARSING_ATTRIBUTE,
506 XML_ERROR_IDENTIFYING_TAG,
507 XML_ERROR_PARSING_TEXT,
508 XML_ERROR_PARSING_CDATA,
509 XML_ERROR_PARSING_COMMENT,
510 XML_ERROR_PARSING_DECLARATION,
511 XML_ERROR_PARSING_UNKNOWN,
512 XML_ERROR_EMPTY_DOCUMENT,
513 XML_ERROR_MISMATCHED_ELEMENT,
514 XML_ERROR_PARSING,
515 XML_CAN_NOT_CONVERT_TEXT,
Lee Thomason331596e2014-09-11 14:56:43 -0700516 XML_NO_TEXT_NODE,
517
518 XML_ERROR_COUNT
numatrumpetbb5ffac2014-09-06 22:56:46 +0900519};
numatrumpetbb5ffac2014-09-06 22:56:46 +0900520
numatrumpetcd8550c2014-09-08 16:59:39 +0900521
U-Stream\Leeae25a442012-02-17 17:48:16 -0800522/*
523 Utility functionality.
524*/
Lee Thomason56bdd022012-02-09 18:16:58 -0800525class XMLUtil
526{
Lee Thomasond1983222012-02-06 08:41:24 -0800527public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700528 // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
529 // correct, but simple, and usually works.
530 static const char* SkipWhiteSpace( const char* p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100531 while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<const unsigned char*>(p) ) ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700532 ++p;
533 }
534 return p;
535 }
536 static char* SkipWhiteSpace( char* p ) {
Dmitry-Me9de541f2014-09-24 14:21:36 +0400537 return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p) ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700538 }
539 static bool IsWhiteSpace( char p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100540 return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700541 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200542
543 inline static bool IsNameStartChar( unsigned char ch ) {
544 return ( ( ch < 128 ) ? isalpha( ch ) : 1 )
545 || ch == ':'
546 || ch == '_';
547 }
548
549 inline static bool IsNameChar( unsigned char ch ) {
550 return IsNameStartChar( ch )
551 || isdigit( ch )
552 || ch == '.'
553 || ch == '-';
554 }
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800555
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700556 inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
557 int n = 0;
558 if ( p == q ) {
559 return true;
560 }
561 while( *p && *q && *p == *q && n<nChar ) {
562 ++p;
563 ++q;
564 ++n;
565 }
566 if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
567 return true;
568 }
569 return false;
570 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200571
Dmitry-Me72bb0ec2014-09-24 16:14:24 +0400572 inline static bool IsUTF8Continuation( const char p ) {
573 return ( p & 0x80 ) != 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700574 }
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800575
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700576 static const char* ReadBOM( const char* p, bool* hasBOM );
577 // p is the starting location,
578 // the UTF-8 value of the entity will be placed in value, and length filled in.
579 static const char* GetCharacterRef( const char* p, char* value, int* length );
580 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
Lee Thomason21be8822012-07-15 17:27:22 -0700581
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700582 // converts primitive types to strings
583 static void ToStr( int v, char* buffer, int bufferSize );
584 static void ToStr( unsigned v, char* buffer, int bufferSize );
585 static void ToStr( bool v, char* buffer, int bufferSize );
586 static void ToStr( float v, char* buffer, int bufferSize );
587 static void ToStr( double v, char* buffer, int bufferSize );
Lee Thomason21be8822012-07-15 17:27:22 -0700588
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700589 // converts strings to primitive types
590 static bool ToInt( const char* str, int* value );
591 static bool ToUnsigned( const char* str, unsigned* value );
592 static bool ToBool( const char* str, bool* value );
593 static bool ToFloat( const char* str, float* value );
594 static bool ToDouble( const char* str, double* value );
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800595};
596
Lee Thomason5cae8972012-01-24 18:03:07 -0800597
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800598/** XMLNode is a base class for every object that is in the
599 XML Document Object Model (DOM), except XMLAttributes.
600 Nodes have siblings, a parent, and children which can
601 be navigated. A node is always in a XMLDocument.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700602 The type of a XMLNode can be queried, and it can
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800603 be cast to its more defined type.
604
Thomas Roß08bdf502012-05-12 14:21:23 +0200605 A XMLDocument allocates memory for all its Nodes.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800606 When the XMLDocument gets deleted, all its Nodes
607 will also be deleted.
608
609 @verbatim
610 A Document can contain: Element (container or leaf)
611 Comment (leaf)
612 Unknown (leaf)
613 Declaration( leaf )
614
615 An Element can contain: Element (container or leaf)
616 Text (leaf)
617 Attributes (not on tree)
618 Comment (leaf)
619 Unknown (leaf)
620
621 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800622*/
PKEuS16ed47d2013-07-06 12:02:43 +0200623class TINYXML2_LIB XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800624{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700625 friend class XMLDocument;
626 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800627public:
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800628
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700629 /// Get the XMLDocument that owns this XMLNode.
630 const XMLDocument* GetDocument() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700631 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700632 }
633 /// Get the XMLDocument that owns this XMLNode.
634 XMLDocument* GetDocument() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700635 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700636 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800637
Lee Thomason2fa81722012-11-09 12:37:46 -0800638 /// Safely cast to an Element, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700639 virtual XMLElement* ToElement() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100640 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700641 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800642 /// Safely cast to Text, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700643 virtual XMLText* ToText() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100644 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700645 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800646 /// Safely cast to a Comment, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700647 virtual XMLComment* ToComment() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100648 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700649 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800650 /// Safely cast to a Document, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700651 virtual XMLDocument* ToDocument() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100652 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700653 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800654 /// Safely cast to a Declaration, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700655 virtual XMLDeclaration* ToDeclaration() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100656 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700657 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800658 /// Safely cast to an Unknown, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700659 virtual XMLUnknown* ToUnknown() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100660 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700661 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800662
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700663 virtual const XMLElement* ToElement() const {
664 return 0;
665 }
666 virtual const XMLText* ToText() const {
667 return 0;
668 }
669 virtual const XMLComment* ToComment() const {
670 return 0;
671 }
672 virtual const XMLDocument* ToDocument() const {
673 return 0;
674 }
675 virtual const XMLDeclaration* ToDeclaration() const {
676 return 0;
677 }
678 virtual const XMLUnknown* ToUnknown() const {
679 return 0;
680 }
Lee Thomason751da522012-02-10 08:50:51 -0800681
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700682 /** The meaning of 'value' changes for the specific type.
683 @verbatim
684 Document: empty
685 Element: name of the element
686 Comment: the comment text
687 Unknown: the tag contents
688 Text: the text string
689 @endverbatim
690 */
Michael Daumling21626882013-10-22 17:03:37 +0200691 const char* Value() const;
MortenMacFly4ee49f12013-01-14 20:03:14 +0100692
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700693 /** Set the Value of an XML node.
694 @sa Value()
695 */
696 void SetValue( const char* val, bool staticMem=false );
Lee Thomason2c85a712012-01-31 08:24:24 -0800697
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700698 /// Get the parent of this node on the DOM.
699 const XMLNode* Parent() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700700 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700701 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100702
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700703 XMLNode* Parent() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700704 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700705 }
Lee Thomason751da522012-02-10 08:50:51 -0800706
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700707 /// Returns true if this node has no children.
708 bool NoChildren() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700709 return !_firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700710 }
Lee Thomason751da522012-02-10 08:50:51 -0800711
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700712 /// Get the first child node, or null if none exists.
713 const XMLNode* FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700714 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700715 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100716
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700717 XMLNode* FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700718 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700719 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100720
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700721 /** Get the first child element, or optionally the first child
722 element with the specified name.
723 */
724 const XMLElement* FirstChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700725
726 XMLElement* FirstChildElement( const char* value=0 ) {
727 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700728 }
Lee Thomason3f57d272012-01-11 15:30:03 -0800729
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700730 /// Get the last child node, or null if none exists.
731 const XMLNode* LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700732 return _lastChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700733 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700734
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700735 XMLNode* LastChild() {
736 return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
737 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800738
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700739 /** Get the last child element or optionally the last child
740 element with the specified name.
741 */
742 const XMLElement* LastChildElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700743
744 XMLElement* LastChildElement( const char* value=0 ) {
745 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700746 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700747
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700748 /// Get the previous (left) sibling node of this node.
749 const XMLNode* PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700750 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700751 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700752
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700753 XMLNode* PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700754 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700755 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800756
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700757 /// Get the previous (left) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700758 const XMLElement* PreviousSiblingElement( const char* value=0 ) const ;
Lee Thomason624d43f2012-10-12 10:58:48 -0700759
760 XMLElement* PreviousSiblingElement( const char* value=0 ) {
761 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700762 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700763
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700764 /// Get the next (right) sibling node of this node.
765 const XMLNode* NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700766 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700767 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700768
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700769 XMLNode* NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700770 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700771 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700772
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700773 /// Get the next (right) sibling element of this node, with an optionally supplied name.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700774 const XMLElement* NextSiblingElement( const char* value=0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700775
776 XMLElement* NextSiblingElement( const char* value=0 ) {
777 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700778 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800779
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700780 /**
781 Add a child node as the last (right) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200782 If the child node is already part of the document,
783 it is moved from its old location to the new location.
784 Returns the addThis argument or 0 if the node does not
785 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700786 */
787 XMLNode* InsertEndChild( XMLNode* addThis );
Lee Thomason618dbf82012-02-28 12:34:27 -0800788
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700789 XMLNode* LinkEndChild( XMLNode* addThis ) {
790 return InsertEndChild( addThis );
791 }
792 /**
793 Add a child node as the first (left) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200794 If the child node is already part of the document,
795 it is moved from its old location to the new location.
796 Returns the addThis argument or 0 if the node does not
797 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700798 */
799 XMLNode* InsertFirstChild( XMLNode* addThis );
800 /**
801 Add a node after the specified child node.
Michael Daumlinged523282013-10-23 07:47:29 +0200802 If the child node is already part of the document,
803 it is moved from its old location to the new location.
804 Returns the addThis argument or 0 if the afterThis node
805 is not a child of this node, or if the node does not
806 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700807 */
808 XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700809
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700810 /**
811 Delete all the children of this node.
812 */
813 void DeleteChildren();
U-Stream\Leeae25a442012-02-17 17:48:16 -0800814
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700815 /**
816 Delete a child of this node.
817 */
818 void DeleteChild( XMLNode* node );
Lee Thomason56bdd022012-02-09 18:16:58 -0800819
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700820 /**
821 Make a copy of this node, but not its children.
822 You may pass in a Document pointer that will be
823 the owner of the new Node. If the 'document' is
824 null, then the node returned will be allocated
825 from the current Document. (this->GetDocument())
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800826
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700827 Note: if called on a XMLDocument, this will return null.
828 */
829 virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800830
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700831 /**
832 Test if 2 nodes are the same, but don't test children.
833 The 2 nodes do not need to be in the same Document.
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800834
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700835 Note: if called on a XMLDocument, this will return false.
836 */
837 virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800838
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600839 /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700840 XML tree will be conditionally visited and the host will be called back
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600841 via the XMLVisitor interface.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800842
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600843 This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
844 the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700845 interface versus any other.)
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800846
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700847 The interface has been based on ideas from:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800848
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700849 - http://www.saxproject.org/
850 - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800851
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700852 Which are both good references for "visiting".
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800853
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700854 An example of using Accept():
855 @verbatim
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600856 XMLPrinter printer;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700857 tinyxmlDoc.Accept( &printer );
858 const char* xmlcstr = printer.CStr();
859 @endverbatim
860 */
861 virtual bool Accept( XMLVisitor* visitor ) const = 0;
Lee Thomason56bdd022012-02-09 18:16:58 -0800862
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700863 // internal
864 virtual char* ParseDeep( char*, StrPair* );
Lee Thomason3f57d272012-01-11 15:30:03 -0800865
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800866protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700867 XMLNode( XMLDocument* );
868 virtual ~XMLNode();
869 XMLNode( const XMLNode& ); // not supported
870 XMLNode& operator=( const XMLNode& ); // not supported
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700871
Lee Thomason624d43f2012-10-12 10:58:48 -0700872 XMLDocument* _document;
873 XMLNode* _parent;
874 mutable StrPair _value;
Lee Thomason3f57d272012-01-11 15:30:03 -0800875
Lee Thomason624d43f2012-10-12 10:58:48 -0700876 XMLNode* _firstChild;
877 XMLNode* _lastChild;
Lee Thomason3f57d272012-01-11 15:30:03 -0800878
Lee Thomason624d43f2012-10-12 10:58:48 -0700879 XMLNode* _prev;
880 XMLNode* _next;
Lee Thomason3f57d272012-01-11 15:30:03 -0800881
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800882private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700883 MemPool* _memPool;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700884 void Unlink( XMLNode* child );
Dmitry-Mee3225b12014-09-03 11:03:11 +0400885 static void DeleteNode( XMLNode* node );
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800886};
887
888
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800889/** XML text.
890
891 Note that a text node can have child element nodes, for example:
892 @verbatim
893 <root>This is <b>bold</b></root>
894 @endverbatim
895
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700896 A text node can have 2 ways to output the next. "normal" output
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800897 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 -0700898 you generally want to leave it alone, but you can change the output mode with
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600899 SetCData() and query it with CData().
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800900*/
PKEuS16ed47d2013-07-06 12:02:43 +0200901class TINYXML2_LIB XMLText : public XMLNode
Lee Thomason5492a1c2012-01-23 15:32:10 -0800902{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700903 friend class XMLBase;
904 friend class XMLDocument;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800905public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700906 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -0800907
Lee Thomason624d43f2012-10-12 10:58:48 -0700908 virtual XMLText* ToText() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700909 return this;
910 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700911 virtual const XMLText* ToText() const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700912 return this;
913 }
Lee Thomason5492a1c2012-01-23 15:32:10 -0800914
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700915 /// Declare whether this should be CDATA or standard text.
Lee Thomason624d43f2012-10-12 10:58:48 -0700916 void SetCData( bool isCData ) {
917 _isCData = isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700918 }
919 /// Returns true if this is a CDATA text element.
920 bool CData() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700921 return _isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700922 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800923
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700924 char* ParseDeep( char*, StrPair* endTag );
925 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
926 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800927
Lee Thomason5492a1c2012-01-23 15:32:10 -0800928protected:
Lee Thomason624d43f2012-10-12 10:58:48 -0700929 XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700930 virtual ~XMLText() {}
931 XMLText( const XMLText& ); // not supported
932 XMLText& operator=( const XMLText& ); // not supported
Lee Thomason5492a1c2012-01-23 15:32:10 -0800933
934private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700935 bool _isCData;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800936};
937
938
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800939/** An XML Comment. */
PKEuS16ed47d2013-07-06 12:02:43 +0200940class TINYXML2_LIB XMLComment : public XMLNode
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800941{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700942 friend class XMLDocument;
Lee Thomason3f57d272012-01-11 15:30:03 -0800943public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700944 virtual XMLComment* ToComment() {
945 return this;
946 }
947 virtual const XMLComment* ToComment() const {
948 return this;
949 }
Lee Thomasonce0763e2012-01-11 15:43:54 -0800950
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700951 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800952
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700953 char* ParseDeep( char*, StrPair* endTag );
954 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
955 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomasonce0763e2012-01-11 15:43:54 -0800956
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800957protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700958 XMLComment( XMLDocument* doc );
959 virtual ~XMLComment();
960 XMLComment( const XMLComment& ); // not supported
961 XMLComment& operator=( const XMLComment& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800962
Lee Thomason3f57d272012-01-11 15:30:03 -0800963private:
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800964};
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800965
966
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800967/** In correct XML the declaration is the first entry in the file.
968 @verbatim
969 <?xml version="1.0" standalone="yes"?>
970 @endverbatim
971
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600972 TinyXML-2 will happily read or write files without a declaration,
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800973 however.
974
975 The text of the declaration isn't interpreted. It is parsed
976 and written as a string.
977*/
PKEuS16ed47d2013-07-06 12:02:43 +0200978class TINYXML2_LIB XMLDeclaration : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -0800979{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700980 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -0800981public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700982 virtual XMLDeclaration* ToDeclaration() {
983 return this;
984 }
985 virtual const XMLDeclaration* ToDeclaration() const {
986 return this;
987 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800988
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700989 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800990
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700991 char* ParseDeep( char*, StrPair* endTag );
992 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
993 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -0800994
995protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700996 XMLDeclaration( XMLDocument* doc );
997 virtual ~XMLDeclaration();
998 XMLDeclaration( const XMLDeclaration& ); // not supported
999 XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001000};
1001
1002
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001003/** Any tag that TinyXML-2 doesn't recognize is saved as an
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001004 unknown. It is a tag of text, but should not be modified.
1005 It will be written back to the XML, unchanged, when the file
1006 is saved.
1007
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001008 DTD tags get thrown into XMLUnknowns.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001009*/
PKEuS16ed47d2013-07-06 12:02:43 +02001010class TINYXML2_LIB XMLUnknown : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -08001011{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001012 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -08001013public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001014 virtual XMLUnknown* ToUnknown() {
1015 return this;
1016 }
1017 virtual const XMLUnknown* ToUnknown() const {
1018 return this;
1019 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001020
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001021 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001022
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001023 char* ParseDeep( char*, StrPair* endTag );
1024 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1025 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001026
1027protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001028 XMLUnknown( XMLDocument* doc );
1029 virtual ~XMLUnknown();
1030 XMLUnknown( const XMLUnknown& ); // not supported
1031 XMLUnknown& operator=( const XMLUnknown& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001032};
1033
1034
Lee Thomason1ff38e02012-02-14 18:18:16 -08001035
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001036/** An attribute is a name-value pair. Elements have an arbitrary
1037 number of attributes, each with a unique name.
1038
1039 @note The attributes are not XMLNodes. You may only query the
1040 Next() attribute in a list.
1041*/
PKEuS16ed47d2013-07-06 12:02:43 +02001042class TINYXML2_LIB XMLAttribute
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001043{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001044 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001045public:
Lee Thomason2fa81722012-11-09 12:37:46 -08001046 /// The name of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001047 const char* Name() const;
1048
Lee Thomason2fa81722012-11-09 12:37:46 -08001049 /// The value of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001050 const char* Value() const;
1051
Lee Thomason2fa81722012-11-09 12:37:46 -08001052 /// The next attribute in the list.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001053 const XMLAttribute* Next() const {
MortenMacFly4ee49f12013-01-14 20:03:14 +01001054 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001055 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001056
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001057 /** IntValue interprets the attribute as an integer, and returns the value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001058 If the value isn't an integer, 0 will be returned. There is no error checking;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001059 use QueryIntValue() if you need error checking.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001060 */
1061 int IntValue() const {
1062 int i=0;
1063 QueryIntValue( &i );
1064 return i;
1065 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001066 /// Query as an unsigned integer. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001067 unsigned UnsignedValue() const {
1068 unsigned i=0;
1069 QueryUnsignedValue( &i );
1070 return i;
1071 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001072 /// Query as a boolean. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001073 bool BoolValue() const {
1074 bool b=false;
1075 QueryBoolValue( &b );
1076 return b;
1077 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001078 /// Query as a double. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001079 double DoubleValue() const {
1080 double d=0;
1081 QueryDoubleValue( &d );
1082 return d;
1083 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001084 /// Query as a float. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001085 float FloatValue() const {
1086 float f=0;
1087 QueryFloatValue( &f );
1088 return f;
1089 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001090
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001091 /** QueryIntValue interprets the attribute as an integer, and returns the value
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001092 in the provided parameter. The function will return XML_NO_ERROR on success,
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001093 and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
1094 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001095 XMLError QueryIntValue( int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001096 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001097 XMLError QueryUnsignedValue( unsigned int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001098 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001099 XMLError QueryBoolValue( bool* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001100 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001101 XMLError QueryDoubleValue( double* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001102 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001103 XMLError QueryFloatValue( float* value ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -08001104
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001105 /// Set the attribute to a string value.
1106 void SetAttribute( const char* value );
1107 /// Set the attribute to value.
1108 void SetAttribute( int value );
1109 /// Set the attribute to value.
1110 void SetAttribute( unsigned value );
1111 /// Set the attribute to value.
1112 void SetAttribute( bool value );
1113 /// Set the attribute to value.
1114 void SetAttribute( double value );
1115 /// Set the attribute to value.
1116 void SetAttribute( float value );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001117
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001118private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001119 enum { BUF_SIZE = 200 };
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001120
Thomas Roß61892312013-05-12 14:07:38 +02001121 XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001122 virtual ~XMLAttribute() {}
Lee Thomason624d43f2012-10-12 10:58:48 -07001123
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001124 XMLAttribute( const XMLAttribute& ); // not supported
1125 void operator=( const XMLAttribute& ); // not supported
1126 void SetName( const char* name );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001127
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001128 char* ParseDeep( char* p, bool processEntities );
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001129
Lee Thomason624d43f2012-10-12 10:58:48 -07001130 mutable StrPair _name;
1131 mutable StrPair _value;
1132 XMLAttribute* _next;
1133 MemPool* _memPool;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001134};
1135
1136
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001137/** The element is a container class. It has a value, the element name,
1138 and can contain other elements, text, comments, and unknowns.
1139 Elements also contain an arbitrary number of attributes.
1140*/
PKEuS16ed47d2013-07-06 12:02:43 +02001141class TINYXML2_LIB XMLElement : public XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001142{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001143 friend class XMLBase;
1144 friend class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001145public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001146 /// Get the name of an element (which is the Value() of the node.)
1147 const char* Name() const {
1148 return Value();
1149 }
1150 /// Set the name of the element.
1151 void SetName( const char* str, bool staticMem=false ) {
1152 SetValue( str, staticMem );
1153 }
Lee Thomason2c85a712012-01-31 08:24:24 -08001154
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001155 virtual XMLElement* ToElement() {
1156 return this;
1157 }
1158 virtual const XMLElement* ToElement() const {
1159 return this;
1160 }
1161 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001162
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001163 /** Given an attribute name, Attribute() returns the value
1164 for the attribute of that name, or null if none
1165 exists. For example:
Lee Thomason92258152012-03-24 13:05:39 -07001166
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001167 @verbatim
1168 const char* value = ele->Attribute( "foo" );
1169 @endverbatim
Lee Thomason92258152012-03-24 13:05:39 -07001170
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001171 The 'value' parameter is normally null. However, if specified,
1172 the attribute will only be returned if the 'name' and 'value'
1173 match. This allow you to write code:
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001174
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001175 @verbatim
1176 if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
1177 @endverbatim
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001178
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001179 rather than:
1180 @verbatim
1181 if ( ele->Attribute( "foo" ) ) {
1182 if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
1183 }
1184 @endverbatim
1185 */
1186 const char* Attribute( const char* name, const char* value=0 ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001187
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001188 /** Given an attribute name, IntAttribute() returns the value
1189 of the attribute interpreted as an integer. 0 will be
1190 returned if there is an error. For a method with error
1191 checking, see QueryIntAttribute()
1192 */
1193 int IntAttribute( const char* name ) const {
1194 int i=0;
1195 QueryIntAttribute( name, &i );
1196 return i;
1197 }
1198 /// See IntAttribute()
1199 unsigned UnsignedAttribute( const char* name ) const {
1200 unsigned i=0;
1201 QueryUnsignedAttribute( name, &i );
1202 return i;
1203 }
1204 /// See IntAttribute()
1205 bool BoolAttribute( const char* name ) const {
1206 bool b=false;
1207 QueryBoolAttribute( name, &b );
1208 return b;
1209 }
1210 /// See IntAttribute()
1211 double DoubleAttribute( const char* name ) const {
1212 double d=0;
1213 QueryDoubleAttribute( name, &d );
1214 return d;
1215 }
1216 /// See IntAttribute()
1217 float FloatAttribute( const char* name ) const {
1218 float f=0;
1219 QueryFloatAttribute( name, &f );
1220 return f;
1221 }
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001222
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001223 /** Given an attribute name, QueryIntAttribute() returns
1224 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1225 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1226 doesn't exist. If successful, the result of the conversion
1227 will be written to 'value'. If not successful, nothing will
1228 be written to 'value'. This allows you to provide default
1229 value:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001230
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001231 @verbatim
1232 int value = 10;
1233 QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1234 @endverbatim
1235 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001236 XMLError QueryIntAttribute( const char* name, int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001237 const XMLAttribute* a = FindAttribute( name );
1238 if ( !a ) {
1239 return XML_NO_ATTRIBUTE;
1240 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001241 return a->QueryIntValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001242 }
1243 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001244 XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001245 const XMLAttribute* a = FindAttribute( name );
1246 if ( !a ) {
1247 return XML_NO_ATTRIBUTE;
1248 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001249 return a->QueryUnsignedValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001250 }
1251 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001252 XMLError QueryBoolAttribute( const char* name, bool* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001253 const XMLAttribute* a = FindAttribute( name );
1254 if ( !a ) {
1255 return XML_NO_ATTRIBUTE;
1256 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001257 return a->QueryBoolValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001258 }
1259 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001260 XMLError QueryDoubleAttribute( const char* name, double* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001261 const XMLAttribute* a = FindAttribute( name );
1262 if ( !a ) {
1263 return XML_NO_ATTRIBUTE;
1264 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001265 return a->QueryDoubleValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001266 }
1267 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001268 XMLError QueryFloatAttribute( const char* name, float* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001269 const XMLAttribute* a = FindAttribute( name );
1270 if ( !a ) {
1271 return XML_NO_ATTRIBUTE;
1272 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001273 return a->QueryFloatValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001274 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001275
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001276
1277 /** Given an attribute name, QueryAttribute() returns
1278 XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
1279 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1280 doesn't exist. It is overloaded for the primitive types,
1281 and is a generally more convenient replacement of
1282 QueryIntAttribute() and related functions.
1283
1284 If successful, the result of the conversion
1285 will be written to 'value'. If not successful, nothing will
1286 be written to 'value'. This allows you to provide default
1287 value:
1288
1289 @verbatim
1290 int value = 10;
1291 QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1292 @endverbatim
1293 */
1294 int QueryAttribute( const char* name, int* value ) const {
1295 return QueryIntAttribute( name, value );
1296 }
1297
1298 int QueryAttribute( const char* name, unsigned int* value ) const {
1299 return QueryUnsignedAttribute( name, value );
1300 }
1301
1302 int QueryAttribute( const char* name, bool* value ) const {
1303 return QueryBoolAttribute( name, value );
1304 }
1305
1306 int QueryAttribute( const char* name, double* value ) const {
1307 return QueryDoubleAttribute( name, value );
1308 }
1309
1310 int QueryAttribute( const char* name, float* value ) const {
1311 return QueryFloatAttribute( name, value );
1312 }
1313
1314 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001315 void SetAttribute( const char* name, const char* 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, int value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001321 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001322 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001323 }
1324 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001325 void SetAttribute( const char* name, unsigned value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001326 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001327 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001328 }
1329 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001330 void SetAttribute( const char* name, bool value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001331 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001332 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001333 }
1334 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001335 void SetAttribute( const char* name, double value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001336 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001337 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001338 }
Lee Thomasonc3708cc2014-01-14 12:30:03 -08001339 /// Sets the named attribute to value.
1340 void SetAttribute( const char* name, float value ) {
1341 XMLAttribute* a = FindOrCreateAttribute( name );
1342 a->SetAttribute( value );
1343 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001344
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001345 /**
1346 Delete an attribute.
1347 */
1348 void DeleteAttribute( const char* name );
Lee Thomason751da522012-02-10 08:50:51 -08001349
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001350 /// Return the first attribute in the list.
1351 const XMLAttribute* FirstAttribute() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001352 return _rootAttribute;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001353 }
1354 /// Query a specific attribute in the list.
1355 const XMLAttribute* FindAttribute( const char* name ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001356
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001357 /** Convenience function for easy access to the text inside an element. Although easy
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001358 and concise, GetText() is limited compared to getting the XMLText child
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001359 and accessing it directly.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001360
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001361 If the first child of 'this' is a XMLText, the GetText()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001362 returns the character string of the Text node, else null is returned.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001363
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001364 This is a convenient method for getting the text of simple contained text:
1365 @verbatim
1366 <foo>This is text</foo>
1367 const char* str = fooElement->GetText();
1368 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001369
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001370 'str' will be a pointer to "This is text".
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001371
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001372 Note that this function can be misleading. If the element foo was created from
1373 this XML:
1374 @verbatim
1375 <foo><b>This is text</b></foo>
1376 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001377
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001378 then the value of str would be null. The first child node isn't a text node, it is
1379 another element. From this XML:
1380 @verbatim
1381 <foo>This is <b>text</b></foo>
1382 @endverbatim
1383 GetText() will return "This is ".
1384 */
1385 const char* GetText() const;
Lee Thomason751da522012-02-10 08:50:51 -08001386
Uli Kusterer85fff5e2014-01-21 01:35:30 +01001387 /** Convenience function for easy access to the text inside an element. Although easy
1388 and concise, SetText() is limited compared to creating an XMLText child
1389 and mutating it directly.
1390
1391 If the first child of 'this' is a XMLText, SetText() sets its value to
1392 the given string, otherwise it will create a first child that is an XMLText.
1393
1394 This is a convenient method for setting the text of simple contained text:
1395 @verbatim
1396 <foo>This is text</foo>
1397 fooElement->SetText( "Hullaballoo!" );
1398 <foo>Hullaballoo!</foo>
1399 @endverbatim
1400
1401 Note that this function can be misleading. If the element foo was created from
1402 this XML:
1403 @verbatim
1404 <foo><b>This is text</b></foo>
1405 @endverbatim
1406
1407 then it will not change "This is text", but rather prefix it with a text element:
1408 @verbatim
1409 <foo>Hullaballoo!<b>This is text</b></foo>
1410 @endverbatim
1411
1412 For this XML:
1413 @verbatim
1414 <foo />
1415 @endverbatim
1416 SetText() will generate
1417 @verbatim
1418 <foo>Hullaballoo!</foo>
1419 @endverbatim
1420 */
Lee Thomason5bb2d802014-01-24 10:42:57 -08001421 void SetText( const char* inText );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001422 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001423 void SetText( int value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001424 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001425 void SetText( unsigned value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001426 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001427 void SetText( bool value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001428 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001429 void SetText( double value );
Lee Thomasonc18eb232014-02-21 17:31:17 -08001430 /// Convenience method for setting text inside and element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001431 void SetText( float value );
Uli Kusterer8fe342a2014-01-21 01:12:47 +01001432
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001433 /**
1434 Convenience method to query the value of a child text node. This is probably best
1435 shown by example. Given you have a document is this form:
1436 @verbatim
1437 <point>
1438 <x>1</x>
1439 <y>1.4</y>
1440 </point>
1441 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001442
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001443 The QueryIntText() and similar functions provide a safe and easier way to get to the
1444 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001445
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001446 @verbatim
1447 int x = 0;
1448 float y = 0; // types of x and y are contrived for example
1449 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1450 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1451 xElement->QueryIntText( &x );
1452 yElement->QueryFloatText( &y );
1453 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001454
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001455 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1456 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 -07001457
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001458 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001459 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001460 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001461 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001462 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001463 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001464 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001465 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001466 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001467 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001468
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001469 // internal:
1470 enum {
1471 OPEN, // <foo>
1472 CLOSED, // <foo/>
1473 CLOSING // </foo>
1474 };
1475 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001476 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001477 }
1478 char* ParseDeep( char* p, StrPair* endTag );
1479 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1480 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001481
Lee Thomason50adb4c2012-02-13 15:07:09 -08001482private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001483 XMLElement( XMLDocument* doc );
1484 virtual ~XMLElement();
1485 XMLElement( const XMLElement& ); // not supported
1486 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001487
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001488 XMLAttribute* FindAttribute( const char* name );
1489 XMLAttribute* FindOrCreateAttribute( const char* name );
1490 //void LinkAttribute( XMLAttribute* attrib );
1491 char* ParseAttributes( char* p );
Dmitry-Mee3225b12014-09-03 11:03:11 +04001492 static void DeleteAttribute( XMLAttribute* attribute );
Lee Thomason67d61312012-01-24 16:01:51 -08001493
Lee Thomason5bb2d802014-01-24 10:42:57 -08001494 enum { BUF_SIZE = 200 };
Lee Thomason624d43f2012-10-12 10:58:48 -07001495 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001496 // The attribute list is ordered; there is no 'lastAttribute'
1497 // because the list needs to be scanned for dupes before adding
1498 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001499 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001500};
1501
1502
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001503enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001504 PRESERVE_WHITESPACE,
1505 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001506};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001507
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001508
1509/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001510 It can be saved, loaded, and printed to the screen.
1511 All Nodes are connected and allocated to a Document.
1512 If the Document is deleted, all its Nodes are also deleted.
1513*/
PKEuS16ed47d2013-07-06 12:02:43 +02001514class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001515{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001516 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001517public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001518 /// constructor
1519 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1520 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001521
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001522 virtual XMLDocument* ToDocument() {
1523 return this;
1524 }
1525 virtual const XMLDocument* ToDocument() const {
1526 return this;
1527 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001528
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001529 /**
1530 Parse an XML file from a character string.
1531 Returns XML_NO_ERROR (0) on success, or
1532 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001533
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001534 You may optionally pass in the 'nBytes', which is
1535 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001536 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001537 null terminated string.
1538 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001539 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001540
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001541 /**
1542 Load an XML file from disk.
1543 Returns XML_NO_ERROR (0) on success, or
1544 an errorID.
1545 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001546 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001547
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001548 /**
1549 Load an XML file from disk. You are responsible
1550 for providing and closing the FILE*.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001551
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001552 Returns XML_NO_ERROR (0) on success, or
1553 an errorID.
1554 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001555 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001556
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001557 /**
1558 Save the XML file to disk.
1559 Returns XML_NO_ERROR (0) on success, or
1560 an errorID.
1561 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001562 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001563
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001564 /**
1565 Save the XML file to disk. You are responsible
1566 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001567
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001568 Returns XML_NO_ERROR (0) on success, or
1569 an errorID.
1570 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001571 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001572
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001573 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001574 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001575 }
1576 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001577 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001578 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001579
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001580 /**
1581 Returns true if this document has a leading Byte Order Mark of UTF8.
1582 */
1583 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001584 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001585 }
1586 /** Sets whether to write the BOM when writing the file.
1587 */
1588 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001589 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001590 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001591
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001592 /** Return the root element of DOM. Equivalent to FirstChildElement().
1593 To get the first node, use FirstChild().
1594 */
1595 XMLElement* RootElement() {
1596 return FirstChildElement();
1597 }
1598 const XMLElement* RootElement() const {
1599 return FirstChildElement();
1600 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001601
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001602 /** Print the Document. If the Printer is not provided, it will
1603 print to stdout. If you provide Printer, this can print to a file:
1604 @verbatim
1605 XMLPrinter printer( fp );
1606 doc.Print( &printer );
1607 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001608
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001609 Or you can use a printer to print to memory:
1610 @verbatim
1611 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001612 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001613 // printer.CStr() has a const char* to the XML
1614 @endverbatim
1615 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001616 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001617 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001618
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001619 /**
1620 Create a new Element associated with
1621 this Document. The memory for the Element
1622 is managed by the Document.
1623 */
1624 XMLElement* NewElement( const char* name );
1625 /**
1626 Create a new Comment associated with
1627 this Document. The memory for the Comment
1628 is managed by the Document.
1629 */
1630 XMLComment* NewComment( const char* comment );
1631 /**
1632 Create a new Text associated with
1633 this Document. The memory for the Text
1634 is managed by the Document.
1635 */
1636 XMLText* NewText( const char* text );
1637 /**
1638 Create a new Declaration associated with
1639 this Document. The memory for the object
1640 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001641
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001642 If the 'text' param is null, the standard
1643 declaration is used.:
1644 @verbatim
1645 <?xml version="1.0" encoding="UTF-8"?>
1646 @endverbatim
1647 */
1648 XMLDeclaration* NewDeclaration( const char* text=0 );
1649 /**
1650 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001651 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001652 is managed by the Document.
1653 */
1654 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001655
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001656 /**
1657 Delete a node associated with this document.
1658 It will be unlinked from the DOM.
1659 */
1660 void DeleteNode( XMLNode* node ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001661 node->_parent->DeleteChild( node );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001662 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001663
Lee Thomason2fa81722012-11-09 12:37:46 -08001664 void SetError( XMLError error, const char* str1, const char* str2 );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001665
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001666 /// Return true if there was an error parsing the document.
1667 bool Error() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001668 return _errorID != XML_NO_ERROR;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001669 }
1670 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001671 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001672 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001673 }
Lee Thomason331596e2014-09-11 14:56:43 -07001674 const char* ErrorName() const;
1675
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001676 /// Return a possibly helpful diagnostic location or string.
1677 const char* GetErrorStr1() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001678 return _errorStr1;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001679 }
1680 /// Return a possibly helpful secondary diagnostic location or string.
1681 const char* GetErrorStr2() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001682 return _errorStr2;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001683 }
1684 /// If there is an error, print it to stdout.
1685 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001686
1687 /// Clear the document, resetting it to the initial state.
1688 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001689
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001690 // internal
1691 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001692
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001693 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1694 return 0;
1695 }
1696 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1697 return false;
1698 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001699
Lee Thomason3f57d272012-01-11 15:30:03 -08001700private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001701 XMLDocument( const XMLDocument& ); // not supported
1702 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001703
Lee Thomason2fa81722012-11-09 12:37:46 -08001704 bool _writeBOM;
1705 bool _processEntities;
1706 XMLError _errorID;
1707 Whitespace _whitespace;
Lee Thomason624d43f2012-10-12 10:58:48 -07001708 const char* _errorStr1;
1709 const char* _errorStr2;
Lee Thomason2fa81722012-11-09 12:37:46 -08001710 char* _charBuffer;
Lee Thomasond1983222012-02-06 08:41:24 -08001711
Lee Thomason624d43f2012-10-12 10:58:48 -07001712 MemPoolT< sizeof(XMLElement) > _elementPool;
1713 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1714 MemPoolT< sizeof(XMLText) > _textPool;
1715 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason331596e2014-09-11 14:56:43 -07001716
1717 static const char* _errorNames[XML_ERROR_COUNT];
Lee Thomason5cae8972012-01-24 18:03:07 -08001718};
1719
Lee Thomason7c913cd2012-01-26 18:32:34 -08001720
Lee Thomason3ffdd392012-03-28 17:27:55 -07001721/**
1722 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001723 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001724 DOM structure. It is a separate utility class.
1725
1726 Take an example:
1727 @verbatim
1728 <Document>
1729 <Element attributeA = "valueA">
1730 <Child attributeB = "value1" />
1731 <Child attributeB = "value2" />
1732 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001733 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001734 @endverbatim
1735
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001736 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001737 easy to write a *lot* of code that looks like:
1738
1739 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001740 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001741 if ( root )
1742 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001743 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001744 if ( element )
1745 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001746 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001747 if ( child )
1748 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001749 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001750 if ( child2 )
1751 {
1752 // Finally do something useful.
1753 @endverbatim
1754
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001755 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001756 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001757 and correct to use:
1758
1759 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001760 XMLHandle docHandle( &document );
1761 XMLElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild().NextSibling().ToElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001762 if ( child2 )
1763 {
1764 // do something useful
1765 @endverbatim
1766
1767 Which is MUCH more concise and useful.
1768
1769 It is also safe to copy handles - internally they are nothing more than node pointers.
1770 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001771 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001772 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001773
1774 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001775*/
PKEuS16ed47d2013-07-06 12:02:43 +02001776class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001777{
1778public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001779 /// 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 -07001780 XMLHandle( XMLNode* node ) {
1781 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001782 }
1783 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001784 XMLHandle( XMLNode& node ) {
1785 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001786 }
1787 /// Copy constructor
1788 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001789 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001790 }
1791 /// Assignment
1792 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001793 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001794 return *this;
1795 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001796
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001797 /// Get the first child of this handle.
1798 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001799 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001800 }
1801 /// Get the first child element of this handle.
1802 XMLHandle FirstChildElement( const char* value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001803 return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001804 }
1805 /// Get the last child of this handle.
1806 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001807 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001808 }
1809 /// Get the last child element of this handle.
1810 XMLHandle LastChildElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001811 return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001812 }
1813 /// Get the previous sibling of this handle.
1814 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001815 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001816 }
1817 /// Get the previous sibling element of this handle.
1818 XMLHandle PreviousSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001819 return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001820 }
1821 /// Get the next sibling of this handle.
1822 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001823 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001824 }
1825 /// Get the next sibling element of this handle.
1826 XMLHandle NextSiblingElement( const char* _value=0 ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001827 return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001828 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001829
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001830 /// Safe cast to XMLNode. This can return null.
1831 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001832 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001833 }
1834 /// Safe cast to XMLElement. This can return null.
1835 XMLElement* ToElement() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001836 return ( ( _node == 0 ) ? 0 : _node->ToElement() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001837 }
1838 /// Safe cast to XMLText. This can return null.
1839 XMLText* ToText() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001840 return ( ( _node == 0 ) ? 0 : _node->ToText() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001841 }
1842 /// Safe cast to XMLUnknown. This can return null.
1843 XMLUnknown* ToUnknown() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001844 return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001845 }
1846 /// Safe cast to XMLDeclaration. This can return null.
1847 XMLDeclaration* ToDeclaration() {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001848 return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001849 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001850
1851private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001852 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001853};
1854
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001855
1856/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001857 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1858 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001859*/
PKEuS16ed47d2013-07-06 12:02:43 +02001860class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001861{
1862public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001863 XMLConstHandle( const XMLNode* node ) {
1864 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001865 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001866 XMLConstHandle( const XMLNode& node ) {
1867 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001868 }
1869 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001870 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001871 }
Lee Thomason8b899812012-04-04 15:58:16 -07001872
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001873 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001874 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001875 return *this;
1876 }
Lee Thomason8b899812012-04-04 15:58:16 -07001877
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001878 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001879 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001880 }
1881 const XMLConstHandle FirstChildElement( const char* value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001882 return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001883 }
1884 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001885 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001886 }
1887 const XMLConstHandle LastChildElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001888 return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001889 }
1890 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001891 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001892 }
1893 const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001894 return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001895 }
1896 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001897 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001898 }
1899 const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001900 return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001901 }
Lee Thomason8b899812012-04-04 15:58:16 -07001902
1903
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001904 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001905 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001906 }
1907 const XMLElement* ToElement() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001908 return ( ( _node == 0 ) ? 0 : _node->ToElement() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001909 }
1910 const XMLText* ToText() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001911 return ( ( _node == 0 ) ? 0 : _node->ToText() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001912 }
1913 const XMLUnknown* ToUnknown() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001914 return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001915 }
1916 const XMLDeclaration* ToDeclaration() const {
Dmitry-Meb6b4e822014-08-27 17:17:47 +04001917 return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001918 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08001919
Lee Thomason5cae8972012-01-24 18:03:07 -08001920private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001921 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08001922};
Lee Thomason6f381b72012-03-02 12:59:39 -08001923
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001924
1925/**
1926 Printing functionality. The XMLPrinter gives you more
1927 options than the XMLDocument::Print() method.
1928
1929 It can:
1930 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02001931 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001932 -# Print XML without a XMLDocument.
1933
1934 Print to Memory
1935
1936 @verbatim
1937 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001938 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02001939 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001940 @endverbatim
1941
1942 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001943
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001944 You provide the file pointer.
1945 @verbatim
1946 XMLPrinter printer( fp );
1947 doc.Print( &printer );
1948 @endverbatim
1949
1950 Print without a XMLDocument
1951
1952 When loading, an XML parser is very useful. However, sometimes
1953 when saving, it just gets in the way. The code is often set up
1954 for streaming, and constructing the DOM is just overhead.
1955
1956 The Printer supports the streaming case. The following code
1957 prints out a trivially simple XML file without ever creating
1958 an XML document.
1959
1960 @verbatim
1961 XMLPrinter printer( fp );
1962 printer.OpenElement( "foo" );
1963 printer.PushAttribute( "foo", "bar" );
1964 printer.CloseElement();
1965 @endverbatim
1966*/
PKEuS16ed47d2013-07-06 12:02:43 +02001967class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001968{
1969public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001970 /** Construct the printer. If the FILE* is specified,
1971 this will print to the FILE. Else it will print
1972 to memory, and the result is available in CStr().
1973 If 'compact' is set to true, then output is created
1974 with only required whitespace and newlines.
1975 */
PKEuS1bfb9542013-08-04 13:51:17 +02001976 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05001977 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001978
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001979 /** If streaming, write the BOM and declaration. */
1980 void PushHeader( bool writeBOM, bool writeDeclaration );
1981 /** If streaming, start writing an element.
1982 The element must be closed with CloseElement()
1983 */
Lee Thomason256adb62014-04-06 14:41:46 -07001984 void OpenElement( const char* name, bool compactMode=false );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001985 /// If streaming, add an attribute to an open element.
1986 void PushAttribute( const char* name, const char* value );
1987 void PushAttribute( const char* name, int value );
1988 void PushAttribute( const char* name, unsigned value );
1989 void PushAttribute( const char* name, bool value );
1990 void PushAttribute( const char* name, double value );
1991 /// If streaming, close the Element.
Lee Thomason256adb62014-04-06 14:41:46 -07001992 virtual void CloseElement( bool compactMode=false );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001993
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001994 /// Add a text node.
1995 void PushText( const char* text, bool cdata=false );
1996 /// Add a text node from an integer.
1997 void PushText( int value );
1998 /// Add a text node from an unsigned.
1999 void PushText( unsigned value );
2000 /// Add a text node from a bool.
2001 void PushText( bool value );
2002 /// Add a text node from a float.
2003 void PushText( float value );
2004 /// Add a text node from a double.
2005 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07002006
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002007 /// Add a comment
2008 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002009
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002010 void PushDeclaration( const char* value );
2011 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002012
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002013 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
2014 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
2015 return true;
2016 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002017
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002018 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
2019 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002020
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002021 virtual bool Visit( const XMLText& text );
2022 virtual bool Visit( const XMLComment& comment );
2023 virtual bool Visit( const XMLDeclaration& declaration );
2024 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002025
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002026 /**
2027 If in print to memory mode, return a pointer to
2028 the XML file in memory.
2029 */
2030 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002031 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002032 }
2033 /**
2034 If in print to memory mode, return the size
2035 of the XML file in memory. (Note the size returned
2036 includes the terminating null.)
2037 */
2038 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002039 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002040 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002041 /**
2042 If in print to memory mode, reset the buffer to the
2043 beginning.
2044 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08002045 void ClearBuffer() {
2046 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002047 _buffer.Push(0);
2048 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002049
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002050protected:
Alexander Maid740b642014-05-20 22:04:42 +02002051 virtual bool CompactMode( const XMLElement& ) { return _compactMode; }
Uli Kusterer5d1d27e2014-02-20 11:50:22 +01002052
Lee Thomasonc18eb232014-02-21 17:31:17 -08002053 /** Prints out the space before an element. You may override to change
2054 the space and tabs used. A PrintSpace() override should call Print().
2055 */
2056 virtual void PrintSpace( int depth );
2057 void Print( const char* format, ... );
2058
2059 void SealElement();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002060 bool _elementJustOpened;
2061 DynArray< const char*, 10 > _stack;
2062
2063private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002064 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002065
Lee Thomason624d43f2012-10-12 10:58:48 -07002066 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01002067 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07002068 int _depth;
2069 int _textDepth;
2070 bool _processEntities;
Lee Thomasonc18eb232014-02-21 17:31:17 -08002071 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002072
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002073 enum {
2074 ENTITY_RANGE = 64,
2075 BUF_SIZE = 200
2076 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002077 bool _entityFlag[ENTITY_RANGE];
2078 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002079
Lee Thomason624d43f2012-10-12 10:58:48 -07002080 DynArray< char, 20 > _buffer;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002081};
2082
2083
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002084} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002085
PKEuS95060352013-07-26 10:42:44 +02002086#if defined(_MSC_VER)
2087# pragma warning(pop)
2088#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002089
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002090#endif // TINYXML2_INCLUDED