blob: 473a6f15d820be314bc95c4660a9838d3aa9b173 [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
Anton Indrawanf59e2d62014-11-18 20:50:42 +010027#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
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>
Lee Thomasona572db12016-06-04 19:16:24 -070033# if defined(__PS3__)
34# include <stddef.h>
35# endif
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070036#else
Lee Thomasona9cf3f92012-10-11 16:56:51 -070037# include <cctype>
38# include <climits>
39# include <cstdio>
40# include <cstdlib>
41# include <cstring>
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -070042#endif
Lee Thomason1889c3e2016-06-04 20:22:57 -070043#include <stdint.h>
Lee Thomason (grinliz)6a22be22012-04-04 12:39:05 -070044
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -070045/*
Lee Thomason7d00b9a2012-02-27 17:54:22 -080046 TODO: intern strings instead of allocation.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080047*/
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080048/*
Lee Thomasona9cf3f92012-10-11 16:56:51 -070049 gcc:
Lee Thomason5b0a6772012-11-19 13:54:42 -080050 g++ -Wall -DDEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
MortenMacFly4ee49f12013-01-14 20:03:14 +010051
Lee Thomasona9cf3f92012-10-11 16:56:51 -070052 Formatting, Artistic Style:
53 AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
Lee Thomason (grinliz)9b093cc2012-02-25 21:30:18 -080054*/
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -080055
Lee Thomason7085f002017-06-01 18:09:43 -070056#if defined( _DEBUG ) || defined (__DEBUG__)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070057# ifndef DEBUG
58# define DEBUG
59# endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080060#endif
61
PKEuS95060352013-07-26 10:42:44 +020062#ifdef _MSC_VER
63# pragma warning(push)
64# pragma warning(disable: 4251)
65#endif
U-Lama\Lee4cee6112011-12-31 14:58:18 -080066
PKEuS16ed47d2013-07-06 12:02:43 +020067#ifdef _WIN32
68# ifdef TINYXML2_EXPORT
69# define TINYXML2_LIB __declspec(dllexport)
70# elif defined(TINYXML2_IMPORT)
71# define TINYXML2_LIB __declspec(dllimport)
72# else
73# define TINYXML2_LIB
74# endif
Matthew Woehlkea8e7ea72016-08-09 13:16:26 -040075#elif __GNUC__ >= 4
76# define TINYXML2_LIB __attribute__((visibility("default")))
PKEuS16ed47d2013-07-06 12:02:43 +020077#else
78# define TINYXML2_LIB
79#endif
80
81
U-Lama\Lee4cee6112011-12-31 14:58:18 -080082#if defined(DEBUG)
Lee Thomasona9cf3f92012-10-11 16:56:51 -070083# if defined(_MSC_VER)
Dmitry-Me4bcbf142014-12-25 19:05:18 +030084# // "(void)0," is for suppressing C4127 warning in "assert(false)", "assert(true)" and the like
Lee Thomason598a88d2015-10-09 14:42:12 -070085# define TIXMLASSERT( x ) if ( !((void)0,(x))) { __debugbreak(); }
Lee Thomasona9cf3f92012-10-11 16:56:51 -070086# elif defined (ANDROID_NDK)
87# include <android/log.h>
88# define TIXMLASSERT( x ) if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
89# else
90# include <assert.h>
91# define TIXMLASSERT assert
92# endif
Lee Thomason598a88d2015-10-09 14:42:12 -070093#else
94# define TIXMLASSERT( x ) {}
U-Lama\Lee4cee6112011-12-31 14:58:18 -080095#endif
96
U-Lama\Leee13c3e62011-12-28 14:36:55 -080097
Lee Thomasonc18eb232014-02-21 17:31:17 -080098/* Versioning, past 1.0.14:
Lee Thomason85afe9c2014-02-23 21:42:16 -080099 http://semver.org/
Lee Thomasonc18eb232014-02-21 17:31:17 -0800100*/
Lee Thomason6ba2a072016-07-17 22:40:43 -0700101static const int TIXML2_MAJOR_VERSION = 4;
Sarat Addepalli9afd1d02015-05-19 12:56:27 +0530102static const int TIXML2_MINOR_VERSION = 0;
Lee Thomason74d44ac2016-07-17 22:57:36 -0700103static const int TIXML2_PATCH_VERSION = 1;
Lee Thomason1ff38e02012-02-14 18:18:16 -0800104
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800105namespace tinyxml2
106{
Lee Thomasonce0763e2012-01-11 15:43:54 -0800107class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800108class XMLElement;
109class XMLAttribute;
110class XMLComment;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800111class XMLText;
Lee Thomason50f97b22012-02-11 16:33:40 -0800112class XMLDeclaration;
113class XMLUnknown;
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800114class XMLPrinter;
Lee Thomason5cae8972012-01-24 18:03:07 -0800115
U-Stream\Leeae25a442012-02-17 17:48:16 -0800116/*
117 A class that wraps strings. Normally stores the start and end
118 pointers into the XML file itself, and will apply normalization
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800119 and entity translation if actually read. Can also store (and memory
U-Stream\Leeae25a442012-02-17 17:48:16 -0800120 manage) a traditional char[]
121*/
PKEuS95060352013-07-26 10:42:44 +0200122class StrPair
Lee Thomason39ede242012-01-20 11:27:56 -0800123{
Lee Thomasond34f52c2012-01-20 12:55:24 -0800124public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700125 enum {
126 NEEDS_ENTITY_PROCESSING = 0x01,
127 NEEDS_NEWLINE_NORMALIZATION = 0x02,
Dmitry-Me5420e542015-05-20 10:51:26 +0300128 NEEDS_WHITESPACE_COLLAPSING = 0x04,
Lee Thomason18d68bd2012-01-26 18:17:26 -0800129
Lee Thomason584af572016-09-05 14:14:16 -0700130 TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700131 TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
Lee Thomason584af572016-09-05 14:14:16 -0700132 ATTRIBUTE_NAME = 0,
133 ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
134 ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
135 COMMENT = NEEDS_NEWLINE_NORMALIZATION
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700136 };
Lee Thomason39ede242012-01-20 11:27:56 -0800137
Lee Thomason120b3a62012-10-12 10:06:59 -0700138 StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700139 ~StrPair();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800140
Lee Thomason120b3a62012-10-12 10:06:59 -0700141 void Set( char* start, char* end, int flags ) {
Dmitry-Me6fc38ec2016-09-01 17:59:44 +0300142 TIXMLASSERT( start );
143 TIXMLASSERT( end );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700144 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700145 _start = start;
146 _end = end;
147 _flags = flags | NEEDS_FLUSH;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700148 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700149
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700150 const char* GetStr();
Lee Thomason120b3a62012-10-12 10:06:59 -0700151
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700152 bool Empty() const {
Lee Thomason120b3a62012-10-12 10:06:59 -0700153 return _start == _end;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700154 }
Lee Thomason39ede242012-01-20 11:27:56 -0800155
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700156 void SetInternedStr( const char* str ) {
157 Reset();
Lee Thomason120b3a62012-10-12 10:06:59 -0700158 _start = const_cast<char*>(str);
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700159 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700160
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700161 void SetStr( const char* str, int flags=0 );
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800162
kezenator4f756162016-11-29 19:46:27 +1000163 char* ParseText( char* in, const char* endTag, int strFlags, int* curLineNumPtr );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700164 char* ParseName( char* in );
Lee Thomason56bdd022012-02-09 18:16:58 -0800165
Lee Thomason29658802014-11-27 22:31:11 -0800166 void TransferTo( StrPair* other );
Lee Thomason584af572016-09-05 14:14:16 -0700167 void Reset();
Dmitry-Me08b40dd2014-11-10 11:17:21 +0300168
Lee Thomason39ede242012-01-20 11:27:56 -0800169private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700170 void CollapseWhitespace();
Lee Thomason1a1d4a72012-02-15 09:09:25 -0800171
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700172 enum {
173 NEEDS_FLUSH = 0x100,
174 NEEDS_DELETE = 0x200
175 };
Lee Thomasone4422302012-01-20 17:59:50 -0800176
Lee Thomason120b3a62012-10-12 10:06:59 -0700177 int _flags;
178 char* _start;
179 char* _end;
Dmitry-Me08b40dd2014-11-10 11:17:21 +0300180
181 StrPair( const StrPair& other ); // not supported
182 void operator=( StrPair& other ); // not supported, use TransferTo()
Lee Thomason39ede242012-01-20 11:27:56 -0800183};
184
U-Lama\Lee560bd472011-12-28 19:42:49 -0800185
U-Stream\Leeae25a442012-02-17 17:48:16 -0800186/*
187 A dynamic array of Plain Old Data. Doesn't support constructors, etc.
188 Has a small initial memory pool, so that low or no usage will not
189 cause a call to new/delete
190*/
Dmitry-Me04009222015-04-06 18:07:18 +0300191template <class T, int INITIAL_SIZE>
PKEuS95060352013-07-26 10:42:44 +0200192class DynArray
Lee Thomason2c85a712012-01-31 08:24:24 -0800193{
194public:
Dmitry-Me9a5a48d2015-01-14 08:27:32 +0300195 DynArray() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700196 _mem = _pool;
Dmitry-Me04009222015-04-06 18:07:18 +0300197 _allocated = INITIAL_SIZE;
Lee Thomason624d43f2012-10-12 10:58:48 -0700198 _size = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700199 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700200
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700201 ~DynArray() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700202 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700203 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700204 }
205 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700206
Lee Thomasonce0510b2013-11-26 21:29:37 -0800207 void Clear() {
Reinhard Klambauer4e74b132013-11-22 14:01:58 +0100208 _size = 0;
209 }
210
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700211 void Push( T t ) {
Dmitry-Meed7a7dc2015-01-14 08:36:12 +0300212 TIXMLASSERT( _size < INT_MAX );
Lee Thomason624d43f2012-10-12 10:58:48 -0700213 EnsureCapacity( _size+1 );
Dmitry-Mefed51122016-09-06 18:08:55 +0300214 _mem[_size] = t;
215 ++_size;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700216 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800217
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700218 T* PushArr( int count ) {
Dmitry-Me74fb8702015-01-13 10:27:36 +0300219 TIXMLASSERT( count >= 0 );
Dmitry-Meed7a7dc2015-01-14 08:36:12 +0300220 TIXMLASSERT( _size <= INT_MAX - count );
Lee Thomason624d43f2012-10-12 10:58:48 -0700221 EnsureCapacity( _size+count );
222 T* ret = &_mem[_size];
223 _size += count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700224 return ret;
225 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700226
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700227 T Pop() {
Dmitry-Me74fb8702015-01-13 10:27:36 +0300228 TIXMLASSERT( _size > 0 );
Dmitry-Mefed51122016-09-06 18:08:55 +0300229 --_size;
230 return _mem[_size];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700231 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700232
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700233 void PopArr( int count ) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700234 TIXMLASSERT( _size >= count );
235 _size -= count;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700236 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800237
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700238 bool Empty() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700239 return _size == 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700240 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700241
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700242 T& operator[](int i) {
Lee Thomason624d43f2012-10-12 10:58:48 -0700243 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700244 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700245 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700246
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700247 const T& operator[](int i) const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700248 TIXMLASSERT( i>= 0 && i < _size );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700249 return _mem[i];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700250 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700251
Lee Thomasonf07b9522014-10-30 13:25:12 -0700252 const T& PeekTop() const {
Dennis Jenkins59c75d32013-10-08 13:10:07 -0500253 TIXMLASSERT( _size > 0 );
254 return _mem[ _size - 1];
255 }
256
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700257 int Size() const {
Dmitry-Me30bdc972015-01-14 08:32:23 +0300258 TIXMLASSERT( _size >= 0 );
Lee Thomason624d43f2012-10-12 10:58:48 -0700259 return _size;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700260 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700261
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700262 int Capacity() const {
Dmitry-Me2f5a1032015-06-18 16:40:09 +0300263 TIXMLASSERT( _allocated >= INITIAL_SIZE );
Lee Thomason624d43f2012-10-12 10:58:48 -0700264 return _allocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700265 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700266
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700267 const T* Mem() const {
Dmitry-Me2f5a1032015-06-18 16:40:09 +0300268 TIXMLASSERT( _mem );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700269 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700270 }
Lee Thomason120b3a62012-10-12 10:06:59 -0700271
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700272 T* Mem() {
Dmitry-Me2f5a1032015-06-18 16:40:09 +0300273 TIXMLASSERT( _mem );
Lee Thomasoned5c8792012-10-12 10:09:48 -0700274 return _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700275 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800276
Lee Thomason2c85a712012-01-31 08:24:24 -0800277private:
Dmitry-Me3e0af372015-01-09 15:30:00 +0300278 DynArray( const DynArray& ); // not supported
279 void operator=( const DynArray& ); // not supported
280
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700281 void EnsureCapacity( int cap ) {
Dmitry-Me9fae8692014-12-22 17:59:59 +0300282 TIXMLASSERT( cap > 0 );
Lee Thomason624d43f2012-10-12 10:58:48 -0700283 if ( cap > _allocated ) {
Dmitry-Me9fae8692014-12-22 17:59:59 +0300284 TIXMLASSERT( cap <= INT_MAX / 2 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700285 int newAllocated = cap * 2;
286 T* newMem = new T[newAllocated];
Lee Thomason624d43f2012-10-12 10:58:48 -0700287 memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
288 if ( _mem != _pool ) {
Lee Thomasoned5c8792012-10-12 10:09:48 -0700289 delete [] _mem;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700290 }
Lee Thomasoned5c8792012-10-12 10:09:48 -0700291 _mem = newMem;
Lee Thomason624d43f2012-10-12 10:58:48 -0700292 _allocated = newAllocated;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700293 }
294 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800295
Lee Thomason624d43f2012-10-12 10:58:48 -0700296 T* _mem;
Dmitry-Me04009222015-04-06 18:07:18 +0300297 T _pool[INITIAL_SIZE];
Lee Thomason624d43f2012-10-12 10:58:48 -0700298 int _allocated; // objects allocated
299 int _size; // number objects in use
Lee Thomason2c85a712012-01-31 08:24:24 -0800300};
301
Lee Thomason50adb4c2012-02-13 15:07:09 -0800302
U-Stream\Leeae25a442012-02-17 17:48:16 -0800303/*
Thomas Roß08bdf502012-05-12 14:21:23 +0200304 Parent virtual class of a pool for fast allocation
U-Stream\Leeae25a442012-02-17 17:48:16 -0800305 and deallocation of objects.
306*/
PKEuS95060352013-07-26 10:42:44 +0200307class MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800308{
309public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700310 MemPool() {}
311 virtual ~MemPool() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800312
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700313 virtual int ItemSize() const = 0;
314 virtual void* Alloc() = 0;
315 virtual void Free( void* ) = 0;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800316 virtual void SetTracked() = 0;
Lee Thomasonf07b9522014-10-30 13:25:12 -0700317 virtual void Clear() = 0;
Lee Thomasond1983222012-02-06 08:41:24 -0800318};
319
Lee Thomason50adb4c2012-02-13 15:07:09 -0800320
U-Stream\Leeae25a442012-02-17 17:48:16 -0800321/*
322 Template child class to create pools of the correct type.
323*/
Dmitry-Me88145b82016-08-09 17:59:31 +0300324template< int ITEM_SIZE >
PKEuS95060352013-07-26 10:42:44 +0200325class MemPoolT : public MemPool
Lee Thomasond1983222012-02-06 08:41:24 -0800326{
327public:
Lee Thomason5b0a6772012-11-19 13:54:42 -0800328 MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700329 ~MemPoolT() {
Lee Thomasonf07b9522014-10-30 13:25:12 -0700330 Clear();
331 }
332
333 void Clear() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700334 // Delete the blocks.
Lee Thomasonf07b9522014-10-30 13:25:12 -0700335 while( !_blockPtrs.Empty()) {
336 Block* b = _blockPtrs.Pop();
337 delete b;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700338 }
Lee Thomasonf07b9522014-10-30 13:25:12 -0700339 _root = 0;
340 _currentAllocs = 0;
341 _nAllocs = 0;
342 _maxAllocs = 0;
343 _nUntracked = 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700344 }
Lee Thomasond1983222012-02-06 08:41:24 -0800345
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700346 virtual int ItemSize() const {
Dmitry-Me88145b82016-08-09 17:59:31 +0300347 return ITEM_SIZE;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700348 }
349 int CurrentAllocs() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700350 return _currentAllocs;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700351 }
Lee Thomasond1983222012-02-06 08:41:24 -0800352
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700353 virtual void* Alloc() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700354 if ( !_root ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700355 // Need a new block.
356 Block* block = new Block();
Lee Thomason624d43f2012-10-12 10:58:48 -0700357 _blockPtrs.Push( block );
Lee Thomasond1983222012-02-06 08:41:24 -0800358
Dmitry-Me88145b82016-08-09 17:59:31 +0300359 Item* blockItems = block->items;
360 for( int i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {
361 blockItems[i].next = &(blockItems[i + 1]);
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700362 }
Dmitry-Me88145b82016-08-09 17:59:31 +0300363 blockItems[ITEMS_PER_BLOCK - 1].next = 0;
364 _root = blockItems;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700365 }
Dmitry-Me88145b82016-08-09 17:59:31 +0300366 Item* const result = _root;
367 TIXMLASSERT( result != 0 );
Lee Thomason624d43f2012-10-12 10:58:48 -0700368 _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 }
Dmitry-Me3161a332016-09-02 16:58:06 +0300374 ++_nAllocs;
375 ++_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-Me88145b82016-08-09 17:59:31 +0300384 Item* item = static_cast<Item*>( mem );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700385#ifdef DEBUG
Dmitry-Me88145b82016-08-09 17:59:31 +0300386 memset( item, 0xfe, sizeof( *item ) );
Lee Thomason (grinliz)6020a012012-09-08 21:15:09 -0700387#endif
Dmitry-Me88145b82016-08-09 17:59:31 +0300388 item->next = _root;
389 _root = item;
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",
Dmitry-Me88145b82016-08-09 17:59:31 +0300393 name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,
394 ITEM_SIZE, _nAllocs, _blockPtrs.Size() );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700395 }
Lee Thomasond1983222012-02-06 08:41:24 -0800396
Lee Thomason5b0a6772012-11-19 13:54:42 -0800397 void SetTracked() {
Dmitry-Me3161a332016-09-02 16:58:06 +0300398 --_nUntracked;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800399 }
400
401 int Untracked() const {
402 return _nUntracked;
403 }
404
Lee Thomason (grinliz)ac83b4e2013-02-01 09:02:34 -0800405 // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
406 // The test file is large, 170k.
407 // Release: VS2010 gcc(no opt)
408 // 1k: 4000
409 // 2k: 4000
410 // 4k: 3900 21000
411 // 16k: 5200
412 // 32k: 4300
413 // 64k: 4000 21000
Dmitry-Me88145b82016-08-09 17:59:31 +0300414 // Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
415 // in private part if ITEMS_PER_BLOCK is private
416 enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };
Jerome Martinez7921df12012-10-24 11:45:44 +0200417
Lee Thomasond1983222012-02-06 08:41:24 -0800418private:
Dmitry-Me3e0af372015-01-09 15:30:00 +0300419 MemPoolT( const MemPoolT& ); // not supported
420 void operator=( const MemPoolT& ); // not supported
421
Dmitry-Me88145b82016-08-09 17:59:31 +0300422 union Item {
423 Item* next;
424 char itemData[ITEM_SIZE];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700425 };
426 struct Block {
Dmitry-Me88145b82016-08-09 17:59:31 +0300427 Item items[ITEMS_PER_BLOCK];
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700428 };
Lee Thomason624d43f2012-10-12 10:58:48 -0700429 DynArray< Block*, 10 > _blockPtrs;
Dmitry-Me88145b82016-08-09 17:59:31 +0300430 Item* _root;
Lee Thomason455c9d42012-02-06 09:14:14 -0800431
Lee Thomason624d43f2012-10-12 10:58:48 -0700432 int _currentAllocs;
433 int _nAllocs;
434 int _maxAllocs;
Lee Thomason5b0a6772012-11-19 13:54:42 -0800435 int _nUntracked;
Lee Thomasond1983222012-02-06 08:41:24 -0800436};
437
Lee Thomason2c85a712012-01-31 08:24:24 -0800438
Lee Thomason56bdd022012-02-09 18:16:58 -0800439
440/**
441 Implements the interface to the "Visitor pattern" (see the Accept() method.)
442 If you call the Accept() method, it requires being passed a XMLVisitor
443 class to handle callbacks. For nodes that contain other nodes (Document, Element)
Thomas Roß08bdf502012-05-12 14:21:23 +0200444 you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
Lee Thomason56bdd022012-02-09 18:16:58 -0800445 are simply called with Visit().
446
447 If you return 'true' from a Visit method, recursive parsing will continue. If you return
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700448 false, <b>no children of this node or its siblings</b> will be visited.
Lee Thomason56bdd022012-02-09 18:16:58 -0800449
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700450 All flavors of Visit methods have a default implementation that returns 'true' (continue
Lee Thomason56bdd022012-02-09 18:16:58 -0800451 visiting). You need to only override methods that are interesting to you.
452
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600453 Generally Accept() is called on the XMLDocument, although all nodes support visiting.
Lee Thomason56bdd022012-02-09 18:16:58 -0800454
455 You should never change the document from a callback.
456
457 @sa XMLNode::Accept()
458*/
PKEuS16ed47d2013-07-06 12:02:43 +0200459class TINYXML2_LIB XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -0800460{
461public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700462 virtual ~XMLVisitor() {}
Lee Thomasond1983222012-02-06 08:41:24 -0800463
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700464 /// Visit a document.
465 virtual bool VisitEnter( const XMLDocument& /*doc*/ ) {
466 return true;
467 }
468 /// Visit a document.
469 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
470 return true;
471 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800472
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700473 /// Visit an element.
474 virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ ) {
475 return true;
476 }
477 /// Visit an element.
478 virtual bool VisitExit( const XMLElement& /*element*/ ) {
479 return true;
480 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800481
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700482 /// Visit a declaration.
483 virtual bool Visit( const XMLDeclaration& /*declaration*/ ) {
484 return true;
485 }
486 /// Visit a text node.
487 virtual bool Visit( const XMLText& /*text*/ ) {
488 return true;
489 }
490 /// Visit a comment node.
491 virtual bool Visit( const XMLComment& /*comment*/ ) {
492 return true;
493 }
494 /// Visit an unknown node.
495 virtual bool Visit( const XMLUnknown& /*unknown*/ ) {
496 return true;
497 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800498};
499
Dmitry-Me66d2a842014-11-08 15:24:52 +0300500// WARNING: must match XMLDocument::_errorNames[]
numatrumpetbb5ffac2014-09-06 22:56:46 +0900501enum XMLError {
numatrumpetcd8550c2014-09-08 16:59:39 +0900502 XML_SUCCESS = 0,
numatrumpetcd8550c2014-09-08 16:59:39 +0900503 XML_NO_ATTRIBUTE,
504 XML_WRONG_ATTRIBUTE_TYPE,
505 XML_ERROR_FILE_NOT_FOUND,
506 XML_ERROR_FILE_COULD_NOT_BE_OPENED,
507 XML_ERROR_FILE_READ_ERROR,
508 XML_ERROR_ELEMENT_MISMATCH,
509 XML_ERROR_PARSING_ELEMENT,
510 XML_ERROR_PARSING_ATTRIBUTE,
511 XML_ERROR_IDENTIFYING_TAG,
512 XML_ERROR_PARSING_TEXT,
513 XML_ERROR_PARSING_CDATA,
514 XML_ERROR_PARSING_COMMENT,
515 XML_ERROR_PARSING_DECLARATION,
516 XML_ERROR_PARSING_UNKNOWN,
517 XML_ERROR_EMPTY_DOCUMENT,
518 XML_ERROR_MISMATCHED_ELEMENT,
519 XML_ERROR_PARSING,
520 XML_CAN_NOT_CONVERT_TEXT,
Lee Thomason331596e2014-09-11 14:56:43 -0700521 XML_NO_TEXT_NODE,
522
523 XML_ERROR_COUNT
numatrumpetbb5ffac2014-09-06 22:56:46 +0900524};
numatrumpetbb5ffac2014-09-06 22:56:46 +0900525
numatrumpetcd8550c2014-09-08 16:59:39 +0900526
U-Stream\Leeae25a442012-02-17 17:48:16 -0800527/*
528 Utility functionality.
529*/
Lee Thomason56bdd022012-02-09 18:16:58 -0800530class XMLUtil
531{
Lee Thomasond1983222012-02-06 08:41:24 -0800532public:
kezenator4f756162016-11-29 19:46:27 +1000533 static const char* SkipWhiteSpace( const char* p, int* curLineNumPtr ) {
Dmitry-Mebb836dc2014-12-24 11:54:05 +0300534 TIXMLASSERT( p );
Lee Thomasone90e9012016-12-24 07:34:39 -0800535
Dmitry-Mefa20b222014-10-31 12:53:04 +0300536 while( IsWhiteSpace(*p) ) {
Lee Thomasone90e9012016-12-24 07:34:39 -0800537 if (curLineNumPtr && *p == '\n') {
kezenator4f756162016-11-29 19:46:27 +1000538 ++(*curLineNumPtr);
kezenatorec694152016-11-26 17:21:43 +1000539 }
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700540 ++p;
541 }
Dmitry-Mebb836dc2014-12-24 11:54:05 +0300542 TIXMLASSERT( p );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700543 return p;
544 }
kezenator4f756162016-11-29 19:46:27 +1000545 static char* SkipWhiteSpace( char* p, int* curLineNumPtr ) {
546 return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p), curLineNumPtr ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700547 }
Dmitry-Mefa20b222014-10-31 12:53:04 +0300548
549 // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
550 // correct, but simple, and usually works.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700551 static bool IsWhiteSpace( char p ) {
Jerome Martinez242c3ea2013-01-06 12:20:04 +0100552 return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700553 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200554
555 inline static bool IsNameStartChar( unsigned char ch ) {
Dmitry-Meea617f92015-01-01 16:32:01 +0300556 if ( ch >= 128 ) {
557 // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
558 return true;
559 }
560 if ( isalpha( ch ) ) {
561 return true;
562 }
563 return ch == ':' || ch == '_';
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200564 }
565
566 inline static bool IsNameChar( unsigned char ch ) {
567 return IsNameStartChar( ch )
568 || isdigit( ch )
569 || ch == '.'
570 || ch == '-';
571 }
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800572
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700573 inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700574 if ( p == q ) {
575 return true;
576 }
Dmitry-Me21f99692016-10-03 13:01:57 +0300577 TIXMLASSERT( p );
578 TIXMLASSERT( q );
579 TIXMLASSERT( nChar >= 0 );
Lee Thomason598a88d2015-10-09 14:42:12 -0700580 return strncmp( p, q, nChar ) == 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700581 }
Martinsh Shaitersc6d02f42013-01-26 21:22:57 +0200582
Dmitry-Me7865aad2015-06-19 16:23:35 +0300583 inline static bool IsUTF8Continuation( char p ) {
Dmitry-Me72bb0ec2014-09-24 16:14:24 +0400584 return ( p & 0x80 ) != 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700585 }
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -0800586
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700587 static const char* ReadBOM( const char* p, bool* hasBOM );
588 // p is the starting location,
589 // the UTF-8 value of the entity will be placed in value, and length filled in.
590 static const char* GetCharacterRef( const char* p, char* value, int* length );
591 static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
Lee Thomason21be8822012-07-15 17:27:22 -0700592
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700593 // converts primitive types to strings
594 static void ToStr( int v, char* buffer, int bufferSize );
595 static void ToStr( unsigned v, char* buffer, int bufferSize );
596 static void ToStr( bool v, char* buffer, int bufferSize );
597 static void ToStr( float v, char* buffer, int bufferSize );
598 static void ToStr( double v, char* buffer, int bufferSize );
Lee Thomason51c12712016-06-04 20:18:49 -0700599 static void ToStr(int64_t v, char* buffer, int bufferSize);
Lee Thomason21be8822012-07-15 17:27:22 -0700600
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700601 // converts strings to primitive types
602 static bool ToInt( const char* str, int* value );
603 static bool ToUnsigned( const char* str, unsigned* value );
604 static bool ToBool( const char* str, bool* value );
605 static bool ToFloat( const char* str, float* value );
606 static bool ToDouble( const char* str, double* value );
Lee Thomason51c12712016-06-04 20:18:49 -0700607 static bool ToInt64(const char* str, int64_t* value);
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800608};
609
Lee Thomason5cae8972012-01-24 18:03:07 -0800610
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800611/** XMLNode is a base class for every object that is in the
612 XML Document Object Model (DOM), except XMLAttributes.
613 Nodes have siblings, a parent, and children which can
614 be navigated. A node is always in a XMLDocument.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700615 The type of a XMLNode can be queried, and it can
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800616 be cast to its more defined type.
617
Thomas Roß08bdf502012-05-12 14:21:23 +0200618 A XMLDocument allocates memory for all its Nodes.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800619 When the XMLDocument gets deleted, all its Nodes
620 will also be deleted.
621
622 @verbatim
623 A Document can contain: Element (container or leaf)
624 Comment (leaf)
625 Unknown (leaf)
626 Declaration( leaf )
627
628 An Element can contain: Element (container or leaf)
629 Text (leaf)
630 Attributes (not on tree)
631 Comment (leaf)
632 Unknown (leaf)
633
634 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800635*/
PKEuS16ed47d2013-07-06 12:02:43 +0200636class TINYXML2_LIB XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800637{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700638 friend class XMLDocument;
639 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800640public:
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800641
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700642 /// Get the XMLDocument that owns this XMLNode.
643 const XMLDocument* GetDocument() const {
Dmitry-Me66487eb2015-07-20 18:21:04 +0300644 TIXMLASSERT( _document );
Lee Thomason624d43f2012-10-12 10:58:48 -0700645 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700646 }
647 /// Get the XMLDocument that owns this XMLNode.
648 XMLDocument* GetDocument() {
Dmitry-Me66487eb2015-07-20 18:21:04 +0300649 TIXMLASSERT( _document );
Lee Thomason624d43f2012-10-12 10:58:48 -0700650 return _document;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700651 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800652
Lee Thomason2fa81722012-11-09 12:37:46 -0800653 /// Safely cast to an Element, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700654 virtual XMLElement* ToElement() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100655 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700656 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800657 /// Safely cast to Text, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700658 virtual XMLText* ToText() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100659 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700660 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800661 /// Safely cast to a Comment, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700662 virtual XMLComment* ToComment() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100663 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700664 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800665 /// Safely cast to a Document, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700666 virtual XMLDocument* ToDocument() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100667 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700668 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800669 /// Safely cast to a Declaration, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700670 virtual XMLDeclaration* ToDeclaration() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100671 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700672 }
Lee Thomason2fa81722012-11-09 12:37:46 -0800673 /// Safely cast to an Unknown, or null.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700674 virtual XMLUnknown* ToUnknown() {
MortenMacFly4ee49f12013-01-14 20:03:14 +0100675 return 0;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700676 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800677
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700678 virtual const XMLElement* ToElement() const {
679 return 0;
680 }
681 virtual const XMLText* ToText() const {
682 return 0;
683 }
684 virtual const XMLComment* ToComment() const {
685 return 0;
686 }
687 virtual const XMLDocument* ToDocument() const {
688 return 0;
689 }
690 virtual const XMLDeclaration* ToDeclaration() const {
691 return 0;
692 }
693 virtual const XMLUnknown* ToUnknown() const {
694 return 0;
695 }
Lee Thomason751da522012-02-10 08:50:51 -0800696
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700697 /** The meaning of 'value' changes for the specific type.
698 @verbatim
Sarat Addepalli9afd1d02015-05-19 12:56:27 +0530699 Document: empty (NULL is returned, not an empty string)
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700700 Element: name of the element
701 Comment: the comment text
702 Unknown: the tag contents
703 Text: the text string
704 @endverbatim
705 */
Michael Daumling21626882013-10-22 17:03:37 +0200706 const char* Value() const;
MortenMacFly4ee49f12013-01-14 20:03:14 +0100707
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700708 /** Set the Value of an XML node.
709 @sa Value()
710 */
711 void SetValue( const char* val, bool staticMem=false );
Lee Thomason2c85a712012-01-31 08:24:24 -0800712
kezenatorec694152016-11-26 17:21:43 +1000713 /// Gets the line number the node is in, if the document was parsed from a file.
kezenator19d8ea82016-11-29 19:50:27 +1000714 int GetLineNum() const { return _parseLineNum; }
kezenatorec694152016-11-26 17:21:43 +1000715
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700716 /// Get the parent of this node on the DOM.
717 const XMLNode* Parent() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700718 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700719 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100720
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700721 XMLNode* Parent() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700722 return _parent;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700723 }
Lee Thomason751da522012-02-10 08:50:51 -0800724
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700725 /// Returns true if this node has no children.
726 bool NoChildren() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700727 return !_firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700728 }
Lee Thomason751da522012-02-10 08:50:51 -0800729
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700730 /// Get the first child node, or null if none exists.
731 const XMLNode* FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700732 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700733 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100734
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700735 XMLNode* FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700736 return _firstChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700737 }
MortenMacFly4ee49f12013-01-14 20:03:14 +0100738
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700739 /** Get the first child element, or optionally the first child
740 element with the specified name.
741 */
Dmitry-Me886ad972015-07-22 11:00:51 +0300742 const XMLElement* FirstChildElement( const char* name = 0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700743
Dmitry-Me886ad972015-07-22 11:00:51 +0300744 XMLElement* FirstChildElement( const char* name = 0 ) {
745 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( name ));
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700746 }
Lee Thomason3f57d272012-01-11 15:30:03 -0800747
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700748 /// Get the last child node, or null if none exists.
749 const XMLNode* LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700750 return _lastChild;
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* LastChild() {
Dmitry-Me8d4e0ec2015-03-30 12:58:28 +0300754 return _lastChild;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700755 }
Lee Thomason2c85a712012-01-31 08:24:24 -0800756
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700757 /** Get the last child element or optionally the last child
758 element with the specified name.
759 */
Dmitry-Me886ad972015-07-22 11:00:51 +0300760 const XMLElement* LastChildElement( const char* name = 0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700761
Dmitry-Me886ad972015-07-22 11:00:51 +0300762 XMLElement* LastChildElement( const char* name = 0 ) {
763 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(name) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700764 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700765
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700766 /// Get the previous (left) sibling node of this node.
767 const XMLNode* PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700768 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700769 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700770
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700771 XMLNode* PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700772 return _prev;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700773 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800774
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700775 /// Get the previous (left) sibling element of this node, with an optionally supplied name.
Dmitry-Me886ad972015-07-22 11:00:51 +0300776 const XMLElement* PreviousSiblingElement( const char* name = 0 ) const ;
Lee Thomason624d43f2012-10-12 10:58:48 -0700777
Dmitry-Me886ad972015-07-22 11:00:51 +0300778 XMLElement* PreviousSiblingElement( const char* name = 0 ) {
779 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( name ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700780 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700781
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700782 /// Get the next (right) sibling node of this node.
783 const XMLNode* NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700784 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700785 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700786
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700787 XMLNode* NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -0700788 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700789 }
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700790
Andrew C. Martin0fd87462013-03-09 20:09:45 -0700791 /// Get the next (right) sibling element of this node, with an optionally supplied name.
Dmitry-Me886ad972015-07-22 11:00:51 +0300792 const XMLElement* NextSiblingElement( const char* name = 0 ) const;
Lee Thomason624d43f2012-10-12 10:58:48 -0700793
Dmitry-Me886ad972015-07-22 11:00:51 +0300794 XMLElement* NextSiblingElement( const char* name = 0 ) {
795 return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( name ) );
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700796 }
Lee Thomason56bdd022012-02-09 18:16:58 -0800797
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700798 /**
799 Add a child node as the last (right) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200800 If the child node is already part of the document,
801 it is moved from its old location to the new location.
802 Returns the addThis argument or 0 if the node does not
803 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700804 */
805 XMLNode* InsertEndChild( XMLNode* addThis );
Lee Thomason618dbf82012-02-28 12:34:27 -0800806
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700807 XMLNode* LinkEndChild( XMLNode* addThis ) {
808 return InsertEndChild( addThis );
809 }
810 /**
811 Add a child node as the first (left) child.
Michael Daumlinged523282013-10-23 07:47:29 +0200812 If the child node is already part of the document,
813 it is moved from its old location to the new location.
814 Returns the addThis argument or 0 if the node does not
815 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700816 */
817 XMLNode* InsertFirstChild( XMLNode* addThis );
818 /**
819 Add a node after the specified child node.
Michael Daumlinged523282013-10-23 07:47:29 +0200820 If the child node is already part of the document,
821 it is moved from its old location to the new location.
822 Returns the addThis argument or 0 if the afterThis node
823 is not a child of this node, or if the node does not
824 belong to the same document.
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700825 */
826 XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700827
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700828 /**
829 Delete all the children of this node.
830 */
831 void DeleteChildren();
U-Stream\Leeae25a442012-02-17 17:48:16 -0800832
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700833 /**
834 Delete a child of this node.
835 */
836 void DeleteChild( XMLNode* node );
Lee Thomason56bdd022012-02-09 18:16:58 -0800837
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700838 /**
839 Make a copy of this node, but not its children.
840 You may pass in a Document pointer that will be
841 the owner of the new Node. If the 'document' is
842 null, then the node returned will be allocated
843 from the current Document. (this->GetDocument())
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800844
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700845 Note: if called on a XMLDocument, this will return null.
846 */
847 virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800848
Lee Thomason7085f002017-06-01 18:09:43 -0700849 /**
850 Make a copy of this node and all of the children
851 of this node.
852
853 If the 'document' is null, then the nodes will
854 be allocated in the current document. If specified,
855 memory will e allocated is the specified document.
856
857 NOTE: This is probably not the correct tool to
858 copy a document, since XMLDocuments can have multiple
859 top level XMLNodes. You probably want XMLDocument::DeepCopy()
860 */
861 XMLNode* DeepClone( XMLDocument* document ) const;
862
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700863 /**
864 Test if 2 nodes are the same, but don't test children.
865 The 2 nodes do not need to be in the same Document.
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800866
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700867 Note: if called on a XMLDocument, this will return false.
868 */
869 virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800870
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600871 /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700872 XML tree will be conditionally visited and the host will be called back
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600873 via the XMLVisitor interface.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800874
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600875 This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
876 the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700877 interface versus any other.)
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800878
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700879 The interface has been based on ideas from:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800880
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700881 - http://www.saxproject.org/
882 - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800883
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700884 Which are both good references for "visiting".
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800885
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700886 An example of using Accept():
887 @verbatim
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600888 XMLPrinter printer;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700889 tinyxmlDoc.Accept( &printer );
890 const char* xmlcstr = printer.CStr();
891 @endverbatim
892 */
893 virtual bool Accept( XMLVisitor* visitor ) const = 0;
Lee Thomason56bdd022012-02-09 18:16:58 -0800894
Lee Thomasonaf9bce12016-07-17 22:35:52 -0700895 /**
896 Set user data into the XMLNode. TinyXML-2 in
897 no way processes or interprets user data.
898 It is initially 0.
899 */
900 void SetUserData(void* userData) { _userData = userData; }
901
902 /**
903 Get user data set into the XMLNode. TinyXML-2 in
904 no way processes or interprets user data.
905 It is initially 0.
906 */
907 void* GetUserData() const { return _userData; }
908
Lee Thomason8a5dfee2012-01-18 17:43:40 -0800909protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700910 XMLNode( XMLDocument* );
911 virtual ~XMLNode();
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700912
kezenator4f756162016-11-29 19:46:27 +1000913 virtual char* ParseDeep( char*, StrPair*, int* );
Dmitry-Me9b0f1772015-04-03 10:37:31 +0300914
Lee Thomason624d43f2012-10-12 10:58:48 -0700915 XMLDocument* _document;
916 XMLNode* _parent;
917 mutable StrPair _value;
kezenatorec694152016-11-26 17:21:43 +1000918 int _parseLineNum;
Lee Thomason3f57d272012-01-11 15:30:03 -0800919
Lee Thomason624d43f2012-10-12 10:58:48 -0700920 XMLNode* _firstChild;
921 XMLNode* _lastChild;
Lee Thomason3f57d272012-01-11 15:30:03 -0800922
Lee Thomason624d43f2012-10-12 10:58:48 -0700923 XMLNode* _prev;
924 XMLNode* _next;
Lee Thomason3f57d272012-01-11 15:30:03 -0800925
Lee Thomasonaf9bce12016-07-17 22:35:52 -0700926 void* _userData;
927
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800928private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700929 MemPool* _memPool;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700930 void Unlink( XMLNode* child );
Dmitry-Mee3225b12014-09-03 11:03:11 +0400931 static void DeleteNode( XMLNode* node );
Lee Thomason3cebdc42015-01-05 17:16:28 -0800932 void InsertChildPreamble( XMLNode* insertThis ) const;
Dmitry-Meecb9b072016-10-12 16:44:59 +0300933 const XMLElement* ToElementWithName( const char* name ) const;
Dmitry-Mef547a992015-01-09 15:17:09 +0300934
935 XMLNode( const XMLNode& ); // not supported
936 XMLNode& operator=( const XMLNode& ); // not supported
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800937};
938
939
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800940/** XML text.
941
942 Note that a text node can have child element nodes, for example:
943 @verbatim
944 <root>This is <b>bold</b></root>
945 @endverbatim
946
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -0700947 A text node can have 2 ways to output the next. "normal" output
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800948 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 -0700949 you generally want to leave it alone, but you can change the output mode with
Vasily Biryukov9a975b72013-05-11 21:41:42 +0600950 SetCData() and query it with CData().
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -0800951*/
PKEuS16ed47d2013-07-06 12:02:43 +0200952class TINYXML2_LIB XMLText : public XMLNode
Lee Thomason5492a1c2012-01-23 15:32:10 -0800953{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700954 friend class XMLDocument;
Lee Thomason5492a1c2012-01-23 15:32:10 -0800955public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700956 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -0800957
Lee Thomason624d43f2012-10-12 10:58:48 -0700958 virtual XMLText* ToText() {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700959 return this;
960 }
Lee Thomason624d43f2012-10-12 10:58:48 -0700961 virtual const XMLText* ToText() const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700962 return this;
963 }
Lee Thomason5492a1c2012-01-23 15:32:10 -0800964
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700965 /// Declare whether this should be CDATA or standard text.
Lee Thomason624d43f2012-10-12 10:58:48 -0700966 void SetCData( bool isCData ) {
967 _isCData = isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700968 }
969 /// Returns true if this is a CDATA text element.
970 bool CData() const {
Lee Thomason624d43f2012-10-12 10:58:48 -0700971 return _isCData;
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700972 }
Lee Thomason50f97b22012-02-11 16:33:40 -0800973
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700974 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
975 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason7d00b9a2012-02-27 17:54:22 -0800976
Lee Thomason5492a1c2012-01-23 15:32:10 -0800977protected:
Lee Thomason624d43f2012-10-12 10:58:48 -0700978 XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700979 virtual ~XMLText() {}
Lee Thomason5492a1c2012-01-23 15:32:10 -0800980
kezenator4f756162016-11-29 19:46:27 +1000981 char* ParseDeep( char*, StrPair* endTag, int* curLineNumPtr );
Dmitry-Me9b0f1772015-04-03 10:37:31 +0300982
Lee Thomason5492a1c2012-01-23 15:32:10 -0800983private:
Lee Thomason624d43f2012-10-12 10:58:48 -0700984 bool _isCData;
Dmitry-Mef547a992015-01-09 15:17:09 +0300985
986 XMLText( const XMLText& ); // not supported
987 XMLText& operator=( const XMLText& ); // not supported
Lee Thomason5492a1c2012-01-23 15:32:10 -0800988};
989
990
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -0800991/** An XML Comment. */
PKEuS16ed47d2013-07-06 12:02:43 +0200992class TINYXML2_LIB XMLComment : public XMLNode
U-Lama\Lee4cee6112011-12-31 14:58:18 -0800993{
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700994 friend class XMLDocument;
Lee Thomason3f57d272012-01-11 15:30:03 -0800995public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -0700996 virtual XMLComment* ToComment() {
997 return this;
998 }
999 virtual const XMLComment* ToComment() const {
1000 return this;
1001 }
Lee Thomasonce0763e2012-01-11 15:43:54 -08001002
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001003 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001004
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001005 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1006 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomasonce0763e2012-01-11 15:43:54 -08001007
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001008protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001009 XMLComment( XMLDocument* doc );
1010 virtual ~XMLComment();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001011
kezenator4f756162016-11-29 19:46:27 +10001012 char* ParseDeep( char*, StrPair* endTag, int* curLineNumPtr);
Dmitry-Me9b0f1772015-04-03 10:37:31 +03001013
Lee Thomason3f57d272012-01-11 15:30:03 -08001014private:
Dmitry-Mef547a992015-01-09 15:17:09 +03001015 XMLComment( const XMLComment& ); // not supported
1016 XMLComment& operator=( const XMLComment& ); // not supported
U-Lama\Lee4cee6112011-12-31 14:58:18 -08001017};
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001018
1019
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001020/** In correct XML the declaration is the first entry in the file.
1021 @verbatim
1022 <?xml version="1.0" standalone="yes"?>
1023 @endverbatim
1024
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001025 TinyXML-2 will happily read or write files without a declaration,
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001026 however.
1027
1028 The text of the declaration isn't interpreted. It is parsed
1029 and written as a string.
1030*/
PKEuS16ed47d2013-07-06 12:02:43 +02001031class TINYXML2_LIB XMLDeclaration : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -08001032{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001033 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -08001034public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001035 virtual XMLDeclaration* ToDeclaration() {
1036 return this;
1037 }
1038 virtual const XMLDeclaration* ToDeclaration() const {
1039 return this;
1040 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001041
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001042 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001043
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001044 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1045 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001046
1047protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001048 XMLDeclaration( XMLDocument* doc );
1049 virtual ~XMLDeclaration();
Dmitry-Mef547a992015-01-09 15:17:09 +03001050
kezenator4f756162016-11-29 19:46:27 +10001051 char* ParseDeep( char*, StrPair* endTag, int* curLineNumPtr );
Dmitry-Me9b0f1772015-04-03 10:37:31 +03001052
Dmitry-Mef547a992015-01-09 15:17:09 +03001053private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001054 XMLDeclaration( const XMLDeclaration& ); // not supported
1055 XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001056};
1057
1058
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001059/** Any tag that TinyXML-2 doesn't recognize is saved as an
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001060 unknown. It is a tag of text, but should not be modified.
1061 It will be written back to the XML, unchanged, when the file
1062 is saved.
1063
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001064 DTD tags get thrown into XMLUnknowns.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001065*/
PKEuS16ed47d2013-07-06 12:02:43 +02001066class TINYXML2_LIB XMLUnknown : public XMLNode
Lee Thomason50f97b22012-02-11 16:33:40 -08001067{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001068 friend class XMLDocument;
Lee Thomason50f97b22012-02-11 16:33:40 -08001069public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001070 virtual XMLUnknown* ToUnknown() {
1071 return this;
1072 }
1073 virtual const XMLUnknown* ToUnknown() const {
1074 return this;
1075 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001076
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001077 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001078
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001079 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1080 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason50f97b22012-02-11 16:33:40 -08001081
1082protected:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001083 XMLUnknown( XMLDocument* doc );
1084 virtual ~XMLUnknown();
Dmitry-Mef547a992015-01-09 15:17:09 +03001085
kezenator4f756162016-11-29 19:46:27 +10001086 char* ParseDeep( char*, StrPair* endTag, int* curLineNumPtr );
Dmitry-Me9b0f1772015-04-03 10:37:31 +03001087
Dmitry-Mef547a992015-01-09 15:17:09 +03001088private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001089 XMLUnknown( const XMLUnknown& ); // not supported
1090 XMLUnknown& operator=( const XMLUnknown& ); // not supported
Lee Thomason50f97b22012-02-11 16:33:40 -08001091};
1092
1093
Lee Thomason1ff38e02012-02-14 18:18:16 -08001094
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001095/** An attribute is a name-value pair. Elements have an arbitrary
1096 number of attributes, each with a unique name.
1097
1098 @note The attributes are not XMLNodes. You may only query the
1099 Next() attribute in a list.
1100*/
PKEuS16ed47d2013-07-06 12:02:43 +02001101class TINYXML2_LIB XMLAttribute
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001102{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001103 friend class XMLElement;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001104public:
Lee Thomason2fa81722012-11-09 12:37:46 -08001105 /// The name of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001106 const char* Name() const;
1107
Lee Thomason2fa81722012-11-09 12:37:46 -08001108 /// The value of the attribute.
Michael Daumling21626882013-10-22 17:03:37 +02001109 const char* Value() const;
1110
kezenatorec694152016-11-26 17:21:43 +10001111 /// Gets the line number the attribute is in, if the document was parsed from a file.
kezenator19d8ea82016-11-29 19:50:27 +10001112 int GetLineNum() const { return _parseLineNum; }
kezenatorec694152016-11-26 17:21:43 +10001113
Lee Thomason2fa81722012-11-09 12:37:46 -08001114 /// The next attribute in the list.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001115 const XMLAttribute* Next() const {
MortenMacFly4ee49f12013-01-14 20:03:14 +01001116 return _next;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001117 }
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001118
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001119 /** IntValue interprets the attribute as an integer, and returns the value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001120 If the value isn't an integer, 0 will be returned. There is no error checking;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001121 use QueryIntValue() if you need error checking.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001122 */
Lee Thomason51c12712016-06-04 20:18:49 -07001123 int IntValue() const {
1124 int i = 0;
1125 QueryIntValue(&i);
1126 return i;
1127 }
1128
1129 int64_t Int64Value() const {
1130 int64_t i = 0;
1131 QueryInt64Value(&i);
1132 return i;
1133 }
1134
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001135 /// Query as an unsigned integer. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001136 unsigned UnsignedValue() const {
1137 unsigned i=0;
1138 QueryUnsignedValue( &i );
1139 return i;
1140 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001141 /// Query as a boolean. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001142 bool BoolValue() const {
1143 bool b=false;
1144 QueryBoolValue( &b );
1145 return b;
1146 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001147 /// Query as a double. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001148 double DoubleValue() const {
1149 double d=0;
1150 QueryDoubleValue( &d );
1151 return d;
1152 }
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001153 /// Query as a float. See IntValue()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001154 float FloatValue() const {
1155 float f=0;
1156 QueryFloatValue( &f );
1157 return f;
1158 }
U-Stream\Leeae25a442012-02-17 17:48:16 -08001159
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001160 /** QueryIntValue interprets the attribute as an integer, and returns the value
Benjamin Doherty3b9cf992016-09-23 18:42:23 -06001161 in the provided parameter. The function will return XML_SUCCESS on success,
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001162 and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
1163 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001164 XMLError QueryIntValue( int* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001165 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001166 XMLError QueryUnsignedValue( unsigned int* value ) const;
Lee Thomason51c12712016-06-04 20:18:49 -07001167 /// See QueryIntValue
1168 XMLError QueryInt64Value(int64_t* value) const;
1169 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001170 XMLError QueryBoolValue( bool* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001171 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001172 XMLError QueryDoubleValue( double* value ) const;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001173 /// See QueryIntValue
Lee Thomason2fa81722012-11-09 12:37:46 -08001174 XMLError QueryFloatValue( float* value ) const;
Lee Thomason50adb4c2012-02-13 15:07:09 -08001175
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001176 /// Set the attribute to a string value.
1177 void SetAttribute( const char* value );
1178 /// Set the attribute to value.
1179 void SetAttribute( int value );
1180 /// Set the attribute to value.
1181 void SetAttribute( unsigned value );
Lee Thomason51c12712016-06-04 20:18:49 -07001182 /// Set the attribute to value.
1183 void SetAttribute(int64_t value);
1184 /// Set the attribute to value.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001185 void SetAttribute( bool value );
1186 /// Set the attribute to value.
1187 void SetAttribute( double value );
1188 /// Set the attribute to value.
1189 void SetAttribute( float value );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001190
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001191private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001192 enum { BUF_SIZE = 200 };
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001193
Thomas Roß61892312013-05-12 14:07:38 +02001194 XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001195 virtual ~XMLAttribute() {}
Lee Thomason624d43f2012-10-12 10:58:48 -07001196
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001197 XMLAttribute( const XMLAttribute& ); // not supported
1198 void operator=( const XMLAttribute& ); // not supported
1199 void SetName( const char* name );
Lee Thomason50adb4c2012-02-13 15:07:09 -08001200
kezenator4f756162016-11-29 19:46:27 +10001201 char* ParseDeep( char* p, bool processEntities, int* curLineNumPtr );
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001202
Lee Thomason624d43f2012-10-12 10:58:48 -07001203 mutable StrPair _name;
1204 mutable StrPair _value;
kezenatorec694152016-11-26 17:21:43 +10001205 int _parseLineNum;
Lee Thomason624d43f2012-10-12 10:58:48 -07001206 XMLAttribute* _next;
1207 MemPool* _memPool;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001208};
1209
1210
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001211/** The element is a container class. It has a value, the element name,
1212 and can contain other elements, text, comments, and unknowns.
1213 Elements also contain an arbitrary number of attributes.
1214*/
PKEuS16ed47d2013-07-06 12:02:43 +02001215class TINYXML2_LIB XMLElement : public XMLNode
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001216{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001217 friend class XMLDocument;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001218public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001219 /// Get the name of an element (which is the Value() of the node.)
1220 const char* Name() const {
1221 return Value();
1222 }
1223 /// Set the name of the element.
1224 void SetName( const char* str, bool staticMem=false ) {
1225 SetValue( str, staticMem );
1226 }
Lee Thomason2c85a712012-01-31 08:24:24 -08001227
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001228 virtual XMLElement* ToElement() {
1229 return this;
1230 }
1231 virtual const XMLElement* ToElement() const {
1232 return this;
1233 }
1234 virtual bool Accept( XMLVisitor* visitor ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001235
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001236 /** Given an attribute name, Attribute() returns the value
1237 for the attribute of that name, or null if none
1238 exists. For example:
Lee Thomason92258152012-03-24 13:05:39 -07001239
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001240 @verbatim
1241 const char* value = ele->Attribute( "foo" );
1242 @endverbatim
Lee Thomason92258152012-03-24 13:05:39 -07001243
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001244 The 'value' parameter is normally null. However, if specified,
1245 the attribute will only be returned if the 'name' and 'value'
1246 match. This allow you to write code:
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001247
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001248 @verbatim
1249 if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
1250 @endverbatim
Lee Thomason8ba7f7d2012-03-24 13:04:04 -07001251
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001252 rather than:
1253 @verbatim
1254 if ( ele->Attribute( "foo" ) ) {
1255 if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
1256 }
1257 @endverbatim
1258 */
1259 const char* Attribute( const char* name, const char* value=0 ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001260
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001261 /** Given an attribute name, IntAttribute() returns the value
Lee Thomason13cbc9a2016-10-27 14:55:07 -07001262 of the attribute interpreted as an integer. The default
1263 value will be returned if the attribute isn't present,
1264 or if there is an error. (For a method with error
1265 checking, see QueryIntAttribute()).
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001266 */
Josh Wittnercf3dd092016-10-11 18:57:17 -07001267 int IntAttribute(const char* name, int defaultValue = 0) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001268 /// See IntAttribute()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001269 unsigned UnsignedAttribute(const char* name, unsigned defaultValue = 0) const;
Lee Thomason51c12712016-06-04 20:18:49 -07001270 /// See IntAttribute()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001271 int64_t Int64Attribute(const char* name, int64_t defaultValue = 0) const;
Lee Thomason51c12712016-06-04 20:18:49 -07001272 /// See IntAttribute()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001273 bool BoolAttribute(const char* name, bool defaultValue = false) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001274 /// See IntAttribute()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001275 double DoubleAttribute(const char* name, double defaultValue = 0) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001276 /// See IntAttribute()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001277 float FloatAttribute(const char* name, float defaultValue = 0) const;
U-Stream\Lee09a11c52012-02-17 08:31:16 -08001278
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001279 /** Given an attribute name, QueryIntAttribute() returns
Benjamin Doherty3b9cf992016-09-23 18:42:23 -06001280 XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001281 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1282 doesn't exist. If successful, the result of the conversion
1283 will be written to 'value'. If not successful, nothing will
1284 be written to 'value'. This allows you to provide default
1285 value:
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001286
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001287 @verbatim
1288 int value = 10;
1289 QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1290 @endverbatim
1291 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001292 XMLError QueryIntAttribute( const char* name, int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001293 const XMLAttribute* a = FindAttribute( name );
1294 if ( !a ) {
1295 return XML_NO_ATTRIBUTE;
1296 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001297 return a->QueryIntValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001298 }
Lee Thomason51c12712016-06-04 20:18:49 -07001299
1300 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001301 XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001302 const XMLAttribute* a = FindAttribute( name );
1303 if ( !a ) {
1304 return XML_NO_ATTRIBUTE;
1305 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001306 return a->QueryUnsignedValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001307 }
Lee Thomason51c12712016-06-04 20:18:49 -07001308
1309 /// See QueryIntAttribute()
1310 XMLError QueryInt64Attribute(const char* name, int64_t* value) const {
1311 const XMLAttribute* a = FindAttribute(name);
1312 if (!a) {
1313 return XML_NO_ATTRIBUTE;
1314 }
1315 return a->QueryInt64Value(value);
1316 }
1317
1318 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001319 XMLError QueryBoolAttribute( const char* name, bool* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001320 const XMLAttribute* a = FindAttribute( name );
1321 if ( !a ) {
1322 return XML_NO_ATTRIBUTE;
1323 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001324 return a->QueryBoolValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001325 }
1326 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001327 XMLError QueryDoubleAttribute( const char* name, double* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001328 const XMLAttribute* a = FindAttribute( name );
1329 if ( !a ) {
1330 return XML_NO_ATTRIBUTE;
1331 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001332 return a->QueryDoubleValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001333 }
1334 /// See QueryIntAttribute()
Lee Thomason2fa81722012-11-09 12:37:46 -08001335 XMLError QueryFloatAttribute( const char* name, float* value ) const {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001336 const XMLAttribute* a = FindAttribute( name );
1337 if ( !a ) {
1338 return XML_NO_ATTRIBUTE;
1339 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001340 return a->QueryFloatValue( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001341 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001342
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001343
1344 /** Given an attribute name, QueryAttribute() returns
Benjamin Doherty3b9cf992016-09-23 18:42:23 -06001345 XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001346 can't be performed, or XML_NO_ATTRIBUTE if the attribute
1347 doesn't exist. It is overloaded for the primitive types,
1348 and is a generally more convenient replacement of
1349 QueryIntAttribute() and related functions.
1350
1351 If successful, the result of the conversion
1352 will be written to 'value'. If not successful, nothing will
1353 be written to 'value'. This allows you to provide default
1354 value:
1355
1356 @verbatim
1357 int value = 10;
1358 QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
1359 @endverbatim
1360 */
1361 int QueryAttribute( const char* name, int* value ) const {
1362 return QueryIntAttribute( name, value );
1363 }
1364
1365 int QueryAttribute( const char* name, unsigned int* value ) const {
1366 return QueryUnsignedAttribute( name, value );
1367 }
1368
Lee Thomason51c12712016-06-04 20:18:49 -07001369 int QueryAttribute(const char* name, int64_t* value) const {
1370 return QueryInt64Attribute(name, value);
1371 }
1372
Lee Thomason (grinliz)5efaa5f2013-02-01 19:26:30 -08001373 int QueryAttribute( const char* name, bool* value ) const {
1374 return QueryBoolAttribute( name, value );
1375 }
1376
1377 int QueryAttribute( const char* name, double* value ) const {
1378 return QueryDoubleAttribute( name, value );
1379 }
1380
1381 int QueryAttribute( const char* name, float* value ) const {
1382 return QueryFloatAttribute( name, value );
1383 }
1384
1385 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001386 void SetAttribute( const char* name, const char* value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001387 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001388 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001389 }
1390 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001391 void SetAttribute( const char* name, int value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001392 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001393 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001394 }
1395 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001396 void SetAttribute( const char* name, unsigned value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001397 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001398 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001399 }
Lee Thomason51c12712016-06-04 20:18:49 -07001400
1401 /// Sets the named attribute to value.
1402 void SetAttribute(const char* name, int64_t value) {
1403 XMLAttribute* a = FindOrCreateAttribute(name);
1404 a->SetAttribute(value);
1405 }
1406
1407 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001408 void SetAttribute( const char* name, bool value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001409 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001410 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001411 }
1412 /// Sets the named attribute to value.
Lee Thomason624d43f2012-10-12 10:58:48 -07001413 void SetAttribute( const char* name, double value ) {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001414 XMLAttribute* a = FindOrCreateAttribute( name );
Lee Thomason624d43f2012-10-12 10:58:48 -07001415 a->SetAttribute( value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001416 }
Lee Thomasonc3708cc2014-01-14 12:30:03 -08001417 /// Sets the named attribute to value.
1418 void SetAttribute( const char* name, float value ) {
1419 XMLAttribute* a = FindOrCreateAttribute( name );
1420 a->SetAttribute( value );
1421 }
Lee Thomason50f97b22012-02-11 16:33:40 -08001422
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001423 /**
1424 Delete an attribute.
1425 */
1426 void DeleteAttribute( const char* name );
Lee Thomason751da522012-02-10 08:50:51 -08001427
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001428 /// Return the first attribute in the list.
1429 const XMLAttribute* FirstAttribute() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001430 return _rootAttribute;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001431 }
1432 /// Query a specific attribute in the list.
1433 const XMLAttribute* FindAttribute( const char* name ) const;
Lee Thomason751da522012-02-10 08:50:51 -08001434
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001435 /** Convenience function for easy access to the text inside an element. Although easy
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001436 and concise, GetText() is limited compared to getting the XMLText child
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001437 and accessing it directly.
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001438
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001439 If the first child of 'this' is a XMLText, the GetText()
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001440 returns the character string of the Text node, else null is returned.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001441
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001442 This is a convenient method for getting the text of simple contained text:
1443 @verbatim
1444 <foo>This is text</foo>
1445 const char* str = fooElement->GetText();
1446 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001447
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001448 'str' will be a pointer to "This is text".
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001449
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001450 Note that this function can be misleading. If the element foo was created from
1451 this XML:
1452 @verbatim
1453 <foo><b>This is text</b></foo>
1454 @endverbatim
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001455
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001456 then the value of str would be null. The first child node isn't a text node, it is
1457 another element. From this XML:
1458 @verbatim
1459 <foo>This is <b>text</b></foo>
1460 @endverbatim
1461 GetText() will return "This is ".
1462 */
1463 const char* GetText() const;
Lee Thomason751da522012-02-10 08:50:51 -08001464
Uli Kusterer85fff5e2014-01-21 01:35:30 +01001465 /** Convenience function for easy access to the text inside an element. Although easy
1466 and concise, SetText() is limited compared to creating an XMLText child
1467 and mutating it directly.
1468
1469 If the first child of 'this' is a XMLText, SetText() sets its value to
1470 the given string, otherwise it will create a first child that is an XMLText.
1471
1472 This is a convenient method for setting the text of simple contained text:
1473 @verbatim
1474 <foo>This is text</foo>
1475 fooElement->SetText( "Hullaballoo!" );
1476 <foo>Hullaballoo!</foo>
1477 @endverbatim
1478
1479 Note that this function can be misleading. If the element foo was created from
1480 this XML:
1481 @verbatim
1482 <foo><b>This is text</b></foo>
1483 @endverbatim
1484
1485 then it will not change "This is text", but rather prefix it with a text element:
1486 @verbatim
1487 <foo>Hullaballoo!<b>This is text</b></foo>
1488 @endverbatim
1489
1490 For this XML:
1491 @verbatim
1492 <foo />
1493 @endverbatim
1494 SetText() will generate
1495 @verbatim
1496 <foo>Hullaballoo!</foo>
1497 @endverbatim
1498 */
Lee Thomason5bb2d802014-01-24 10:42:57 -08001499 void SetText( const char* inText );
Dmitry-Me9e9c85b2015-10-19 18:04:46 +03001500 /// Convenience method for setting text inside an element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001501 void SetText( int value );
Dmitry-Me9e9c85b2015-10-19 18:04:46 +03001502 /// Convenience method for setting text inside an element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001503 void SetText( unsigned value );
Lee Thomason51c12712016-06-04 20:18:49 -07001504 /// Convenience method for setting text inside an element. See SetText() for important limitations.
1505 void SetText(int64_t value);
1506 /// Convenience method for setting text inside an element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001507 void SetText( bool value );
Dmitry-Me9e9c85b2015-10-19 18:04:46 +03001508 /// Convenience method for setting text inside an element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001509 void SetText( double value );
Dmitry-Me9e9c85b2015-10-19 18:04:46 +03001510 /// Convenience method for setting text inside an element. See SetText() for important limitations.
Lee Thomason5bb2d802014-01-24 10:42:57 -08001511 void SetText( float value );
Uli Kusterer8fe342a2014-01-21 01:12:47 +01001512
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001513 /**
1514 Convenience method to query the value of a child text node. This is probably best
1515 shown by example. Given you have a document is this form:
1516 @verbatim
1517 <point>
1518 <x>1</x>
1519 <y>1.4</y>
1520 </point>
1521 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001522
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001523 The QueryIntText() and similar functions provide a safe and easier way to get to the
1524 "value" of x and y.
Lee Thomason21be8822012-07-15 17:27:22 -07001525
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001526 @verbatim
1527 int x = 0;
1528 float y = 0; // types of x and y are contrived for example
1529 const XMLElement* xElement = pointElement->FirstChildElement( "x" );
1530 const XMLElement* yElement = pointElement->FirstChildElement( "y" );
1531 xElement->QueryIntText( &x );
1532 yElement->QueryFloatText( &y );
1533 @endverbatim
Lee Thomason21be8822012-07-15 17:27:22 -07001534
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001535 @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
1536 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 -07001537
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001538 */
MortenMacFly4ee49f12013-01-14 20:03:14 +01001539 XMLError QueryIntText( int* ival ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001540 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001541 XMLError QueryUnsignedText( unsigned* uval ) const;
Lee Thomason51c12712016-06-04 20:18:49 -07001542 /// See QueryIntText()
1543 XMLError QueryInt64Text(int64_t* uval) const;
1544 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001545 XMLError QueryBoolText( bool* bval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001546 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001547 XMLError QueryDoubleText( double* dval ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001548 /// See QueryIntText()
MortenMacFly4ee49f12013-01-14 20:03:14 +01001549 XMLError QueryFloatText( float* fval ) const;
Lee Thomason21be8822012-07-15 17:27:22 -07001550
Josh Wittnercf3dd092016-10-11 18:57:17 -07001551 int IntText(int defaultValue = 0) const;
1552
Josh Wittner3a621f52016-09-12 19:17:54 -07001553 /// See QueryIntText()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001554 unsigned UnsignedText(unsigned defaultValue = 0) const;
Josh Wittner3a621f52016-09-12 19:17:54 -07001555 /// See QueryIntText()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001556 int64_t Int64Text(int64_t defaultValue = 0) const;
Josh Wittner3a621f52016-09-12 19:17:54 -07001557 /// See QueryIntText()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001558 bool BoolText(bool defaultValue = false) const;
Josh Wittner3a621f52016-09-12 19:17:54 -07001559 /// See QueryIntText()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001560 double DoubleText(double defaultValue = 0) const;
Josh Wittner3a621f52016-09-12 19:17:54 -07001561 /// See QueryIntText()
Josh Wittnercf3dd092016-10-11 18:57:17 -07001562 float FloatText(float defaultValue = 0) const;
Josh Wittner3a621f52016-09-12 19:17:54 -07001563
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001564 // internal:
1565 enum {
1566 OPEN, // <foo>
1567 CLOSED, // <foo/>
1568 CLOSING // </foo>
1569 };
1570 int ClosingType() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001571 return _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001572 }
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001573 virtual XMLNode* ShallowClone( XMLDocument* document ) const;
1574 virtual bool ShallowEqual( const XMLNode* compare ) const;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001575
Dmitry-Me9b0f1772015-04-03 10:37:31 +03001576protected:
kezenator4f756162016-11-29 19:46:27 +10001577 char* ParseDeep( char* p, StrPair* endTag, int* curLineNumPtr );
Dmitry-Me9b0f1772015-04-03 10:37:31 +03001578
Lee Thomason50adb4c2012-02-13 15:07:09 -08001579private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001580 XMLElement( XMLDocument* doc );
1581 virtual ~XMLElement();
1582 XMLElement( const XMLElement& ); // not supported
1583 void operator=( const XMLElement& ); // not supported
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001584
Dmitry-Me1227d512014-12-05 13:41:45 +03001585 XMLAttribute* FindAttribute( const char* name ) {
1586 return const_cast<XMLAttribute*>(const_cast<const XMLElement*>(this)->FindAttribute( name ));
1587 }
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001588 XMLAttribute* FindOrCreateAttribute( const char* name );
1589 //void LinkAttribute( XMLAttribute* attrib );
kezenator4f756162016-11-29 19:46:27 +10001590 char* ParseAttributes( char* p, int* curLineNumPtr );
Dmitry-Mee3225b12014-09-03 11:03:11 +04001591 static void DeleteAttribute( XMLAttribute* attribute );
Dmitry-Mea60caa22016-11-22 18:28:08 +03001592 XMLAttribute* CreateAttribute();
Lee Thomason67d61312012-01-24 16:01:51 -08001593
Lee Thomason5bb2d802014-01-24 10:42:57 -08001594 enum { BUF_SIZE = 200 };
Lee Thomason624d43f2012-10-12 10:58:48 -07001595 int _closingType;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001596 // The attribute list is ordered; there is no 'lastAttribute'
1597 // because the list needs to be scanned for dupes before adding
1598 // a new attribute.
Lee Thomason624d43f2012-10-12 10:58:48 -07001599 XMLAttribute* _rootAttribute;
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001600};
1601
1602
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001603enum Whitespace {
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001604 PRESERVE_WHITESPACE,
1605 COLLAPSE_WHITESPACE
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001606};
Lee Thomason (grinliz)bc1bfb72012-08-20 22:00:38 -07001607
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001608
1609/** A Document binds together all the functionality.
Lee Thomason (grinliz)9c38d132012-02-24 21:50:50 -08001610 It can be saved, loaded, and printed to the screen.
1611 All Nodes are connected and allocated to a Document.
1612 If the Document is deleted, all its Nodes are also deleted.
1613*/
PKEuS16ed47d2013-07-06 12:02:43 +02001614class TINYXML2_LIB XMLDocument : public XMLNode
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001615{
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001616 friend class XMLElement;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001617public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001618 /// constructor
1619 XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
1620 ~XMLDocument();
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001621
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001622 virtual XMLDocument* ToDocument() {
Dmitry-Me66487eb2015-07-20 18:21:04 +03001623 TIXMLASSERT( this == _document );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001624 return this;
1625 }
1626 virtual const XMLDocument* ToDocument() const {
Dmitry-Me66487eb2015-07-20 18:21:04 +03001627 TIXMLASSERT( this == _document );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001628 return this;
1629 }
Lee Thomason56bdd022012-02-09 18:16:58 -08001630
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001631 /**
1632 Parse an XML file from a character string.
Benjamin Doherty3b9cf992016-09-23 18:42:23 -06001633 Returns XML_SUCCESS (0) on success, or
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001634 an errorID.
Lee Thomason (grinliz)e2bcb322012-09-17 17:58:25 -07001635
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001636 You may optionally pass in the 'nBytes', which is
1637 the number of bytes which will be parsed. If not
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001638 specified, TinyXML-2 will assume 'xml' points to a
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001639 null terminated string.
1640 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001641 XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001642
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001643 /**
1644 Load an XML file from disk.
Benjamin Doherty3b9cf992016-09-23 18:42:23 -06001645 Returns XML_SUCCESS (0) on success, or
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001646 an errorID.
1647 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001648 XMLError LoadFile( const char* filename );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001649
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001650 /**
1651 Load an XML file from disk. You are responsible
Lee Thomasoncd011bc2014-12-17 10:41:34 -08001652 for providing and closing the FILE*.
1653
1654 NOTE: The file should be opened as binary ("rb")
1655 not text in order for TinyXML-2 to correctly
1656 do newline normalization.
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001657
Benjamin Doherty3b9cf992016-09-23 18:42:23 -06001658 Returns XML_SUCCESS (0) on success, or
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001659 an errorID.
1660 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001661 XMLError LoadFile( FILE* );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001662
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001663 /**
1664 Save the XML file to disk.
Benjamin Doherty3b9cf992016-09-23 18:42:23 -06001665 Returns XML_SUCCESS (0) on success, or
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001666 an errorID.
1667 */
Lee Thomason2fa81722012-11-09 12:37:46 -08001668 XMLError SaveFile( const char* filename, bool compact = false );
Lee Thomasond11cd162012-04-12 08:35:36 -07001669
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001670 /**
1671 Save the XML file to disk. You are responsible
1672 for providing and closing the FILE*.
Ken Miller81da1fb2012-04-09 23:32:26 -05001673
Benjamin Doherty3b9cf992016-09-23 18:42:23 -06001674 Returns XML_SUCCESS (0) on success, or
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001675 an errorID.
1676 */
Jerome Martinez242c3ea2013-01-06 12:20:04 +01001677 XMLError SaveFile( FILE* fp, bool compact = false );
Lee Thomason (grinliz)68db57e2012-02-21 09:08:12 -08001678
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001679 bool ProcessEntities() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001680 return _processEntities;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001681 }
1682 Whitespace WhitespaceMode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001683 return _whitespace;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001684 }
Lee Thomason6f381b72012-03-02 12:59:39 -08001685
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001686 /**
1687 Returns true if this document has a leading Byte Order Mark of UTF8.
1688 */
1689 bool HasBOM() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001690 return _writeBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001691 }
1692 /** Sets whether to write the BOM when writing the file.
1693 */
1694 void SetBOM( bool useBOM ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001695 _writeBOM = useBOM;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001696 }
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001697
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001698 /** Return the root element of DOM. Equivalent to FirstChildElement().
1699 To get the first node, use FirstChild().
1700 */
1701 XMLElement* RootElement() {
1702 return FirstChildElement();
1703 }
1704 const XMLElement* RootElement() const {
1705 return FirstChildElement();
1706 }
Lee Thomason18d68bd2012-01-26 18:17:26 -08001707
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001708 /** Print the Document. If the Printer is not provided, it will
1709 print to stdout. If you provide Printer, this can print to a file:
1710 @verbatim
1711 XMLPrinter printer( fp );
1712 doc.Print( &printer );
1713 @endverbatim
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001714
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001715 Or you can use a printer to print to memory:
1716 @verbatim
1717 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001718 doc.Print( &printer );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001719 // printer.CStr() has a const char* to the XML
1720 @endverbatim
1721 */
PKEuS1c5f99e2013-07-06 11:28:39 +02001722 void Print( XMLPrinter* streamer=0 ) const;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001723 virtual bool Accept( XMLVisitor* visitor ) const;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08001724
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001725 /**
1726 Create a new Element associated with
1727 this Document. The memory for the Element
1728 is managed by the Document.
1729 */
1730 XMLElement* NewElement( const char* name );
1731 /**
1732 Create a new Comment associated with
1733 this Document. The memory for the Comment
1734 is managed by the Document.
1735 */
1736 XMLComment* NewComment( const char* comment );
1737 /**
1738 Create a new Text associated with
1739 this Document. The memory for the Text
1740 is managed by the Document.
1741 */
1742 XMLText* NewText( const char* text );
1743 /**
1744 Create a new Declaration associated with
1745 this Document. The memory for the object
1746 is managed by the Document.
Lee Thomasonf68c4382012-04-28 14:37:11 -07001747
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001748 If the 'text' param is null, the standard
1749 declaration is used.:
1750 @verbatim
1751 <?xml version="1.0" encoding="UTF-8"?>
1752 @endverbatim
1753 */
1754 XMLDeclaration* NewDeclaration( const char* text=0 );
1755 /**
1756 Create a new Unknown associated with
Andrew C. Martin0fd87462013-03-09 20:09:45 -07001757 this Document. The memory for the object
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001758 is managed by the Document.
1759 */
1760 XMLUnknown* NewUnknown( const char* text );
Lee Thomason2c85a712012-01-31 08:24:24 -08001761
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001762 /**
1763 Delete a node associated with this document.
1764 It will be unlinked from the DOM.
1765 */
Lee Thomasoncd011bc2014-12-17 10:41:34 -08001766 void DeleteNode( XMLNode* node );
U-Stream\Leeae25a442012-02-17 17:48:16 -08001767
kezenatorec694152016-11-26 17:21:43 +10001768 void SetError( XMLError error, const char* str1, const char* str2, int lineNum );
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001769
Dmitry-Me0d2cef02016-11-25 18:39:52 +03001770 void ClearError() {
kezenator2489afc2016-11-29 19:33:44 +10001771 SetError(XML_SUCCESS, 0, 0, 0);
Dmitry-Me0d2cef02016-11-25 18:39:52 +03001772 }
1773
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001774 /// Return true if there was an error parsing the document.
1775 bool Error() const {
Lee Thomason85536252016-06-04 19:10:53 -07001776 return _errorID != XML_SUCCESS;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001777 }
1778 /// Return the errorID.
Lee Thomason2fa81722012-11-09 12:37:46 -08001779 XMLError ErrorID() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07001780 return _errorID;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001781 }
Lee Thomason331596e2014-09-11 14:56:43 -07001782 const char* ErrorName() const;
Lee Thomasone90e9012016-12-24 07:34:39 -08001783 static const char* ErrorIDToName(XMLError errorID);
Lee Thomason331596e2014-09-11 14:56:43 -07001784
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001785 /// Return a possibly helpful diagnostic location or string.
1786 const char* GetErrorStr1() const {
Lee Thomason584af572016-09-05 14:14:16 -07001787 return _errorStr1.GetStr();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001788 }
1789 /// Return a possibly helpful secondary diagnostic location or string.
1790 const char* GetErrorStr2() const {
Lee Thomason584af572016-09-05 14:14:16 -07001791 return _errorStr2.GetStr();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001792 }
kezenatorec694152016-11-26 17:21:43 +10001793 /// Return the line where the error occured, or zero if unknown.
1794 int GetErrorLineNum() const
1795 {
1796 return _errorLineNum;
1797 }
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001798 /// If there is an error, print it to stdout.
1799 void PrintError() const;
Martinsh Shaitersa9d42b02013-01-30 11:14:27 +02001800
1801 /// Clear the document, resetting it to the initial state.
1802 void Clear();
Lee Thomason8a5dfee2012-01-18 17:43:40 -08001803
Lee Thomason7085f002017-06-01 18:09:43 -07001804 /**
Lee Thomasonb29f5562017-06-01 18:45:32 -07001805 Copies this document to a target document.
Lee Thomason7085f002017-06-01 18:09:43 -07001806 The target will be completely cleared before the copy.
Lee Thomasonb29f5562017-06-01 18:45:32 -07001807 If you want to copy a sub-tree, see XMLNode::DeepClone().
Lee Thomason7085f002017-06-01 18:09:43 -07001808
1809 NOTE: that the 'target' must be non-null and not
1810 the source document.
1811 */
1812 void DeepCopy(XMLDocument* target);
1813
1814 // internal
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001815 char* Identify( char* p, XMLNode** node );
Lee Thomason2c85a712012-01-31 08:24:24 -08001816
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001817 virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
1818 return 0;
1819 }
1820 virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
1821 return false;
1822 }
Lee Thomason7d00b9a2012-02-27 17:54:22 -08001823
Lee Thomason3f57d272012-01-11 15:30:03 -08001824private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001825 XMLDocument( const XMLDocument& ); // not supported
1826 void operator=( const XMLDocument& ); // not supported
Lee Thomason18d68bd2012-01-26 18:17:26 -08001827
Lee Thomasone90e9012016-12-24 07:34:39 -08001828 bool _writeBOM;
1829 bool _processEntities;
1830 XMLError _errorID;
1831 Whitespace _whitespace;
1832 mutable StrPair _errorStr1;
1833 mutable StrPair _errorStr2;
1834 int _errorLineNum;
1835 char* _charBuffer;
1836 int _parseCurLineNum;
Lee Thomasond1983222012-02-06 08:41:24 -08001837
Lee Thomason624d43f2012-10-12 10:58:48 -07001838 MemPoolT< sizeof(XMLElement) > _elementPool;
1839 MemPoolT< sizeof(XMLAttribute) > _attributePool;
1840 MemPoolT< sizeof(XMLText) > _textPool;
1841 MemPoolT< sizeof(XMLComment) > _commentPool;
Lee Thomason331596e2014-09-11 14:56:43 -07001842
1843 static const char* _errorNames[XML_ERROR_COUNT];
Dmitry-Me97476b72015-01-01 16:15:57 +03001844
1845 void Parse();
Lee Thomason5cae8972012-01-24 18:03:07 -08001846};
1847
Lee Thomason7c913cd2012-01-26 18:32:34 -08001848
Lee Thomason3ffdd392012-03-28 17:27:55 -07001849/**
1850 A XMLHandle is a class that wraps a node pointer with null checks; this is
Vasily Biryukov9a975b72013-05-11 21:41:42 +06001851 an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
Lee Thomason3ffdd392012-03-28 17:27:55 -07001852 DOM structure. It is a separate utility class.
1853
1854 Take an example:
1855 @verbatim
1856 <Document>
1857 <Element attributeA = "valueA">
1858 <Child attributeB = "value1" />
1859 <Child attributeB = "value2" />
1860 </Element>
Thomas Roß08bdf502012-05-12 14:21:23 +02001861 </Document>
Lee Thomason3ffdd392012-03-28 17:27:55 -07001862 @endverbatim
1863
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001864 Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
Lee Thomason3ffdd392012-03-28 17:27:55 -07001865 easy to write a *lot* of code that looks like:
1866
1867 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001868 XMLElement* root = document.FirstChildElement( "Document" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001869 if ( root )
1870 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001871 XMLElement* element = root->FirstChildElement( "Element" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001872 if ( element )
1873 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001874 XMLElement* child = element->FirstChildElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001875 if ( child )
1876 {
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001877 XMLElement* child2 = child->NextSiblingElement( "Child" );
Lee Thomason3ffdd392012-03-28 17:27:55 -07001878 if ( child2 )
1879 {
1880 // Finally do something useful.
1881 @endverbatim
1882
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001883 And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07001884 of such code. A XMLHandle checks for null pointers so it is perfectly safe
Lee Thomason3ffdd392012-03-28 17:27:55 -07001885 and correct to use:
1886
1887 @verbatim
Lee Thomasondb0bbb62012-04-04 15:47:04 -07001888 XMLHandle docHandle( &document );
Dmitry-Mea317bd62014-12-08 10:35:37 +03001889 XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
Lee Thomason3ffdd392012-03-28 17:27:55 -07001890 if ( child2 )
1891 {
1892 // do something useful
1893 @endverbatim
1894
1895 Which is MUCH more concise and useful.
1896
1897 It is also safe to copy handles - internally they are nothing more than node pointers.
1898 @verbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001899 XMLHandle handleCopy = handle;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001900 @endverbatim
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001901
1902 See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
Lee Thomason3ffdd392012-03-28 17:27:55 -07001903*/
PKEuS16ed47d2013-07-06 12:02:43 +02001904class TINYXML2_LIB XMLHandle
Lee Thomason3ffdd392012-03-28 17:27:55 -07001905{
1906public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001907 /// 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 -07001908 XMLHandle( XMLNode* node ) {
1909 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001910 }
1911 /// Create a handle from a node.
Lee Thomason624d43f2012-10-12 10:58:48 -07001912 XMLHandle( XMLNode& node ) {
1913 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001914 }
1915 /// Copy constructor
1916 XMLHandle( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001917 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001918 }
1919 /// Assignment
1920 XMLHandle& operator=( const XMLHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001921 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001922 return *this;
1923 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001924
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001925 /// Get the first child of this handle.
1926 XMLHandle FirstChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001927 return XMLHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001928 }
1929 /// Get the first child element of this handle.
Dmitry-Me886ad972015-07-22 11:00:51 +03001930 XMLHandle FirstChildElement( const char* name = 0 ) {
1931 return XMLHandle( _node ? _node->FirstChildElement( name ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001932 }
1933 /// Get the last child of this handle.
1934 XMLHandle LastChild() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001935 return XMLHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001936 }
1937 /// Get the last child element of this handle.
Dmitry-Me886ad972015-07-22 11:00:51 +03001938 XMLHandle LastChildElement( const char* name = 0 ) {
1939 return XMLHandle( _node ? _node->LastChildElement( name ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001940 }
1941 /// Get the previous sibling of this handle.
1942 XMLHandle PreviousSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001943 return XMLHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001944 }
1945 /// Get the previous sibling element of this handle.
Dmitry-Me886ad972015-07-22 11:00:51 +03001946 XMLHandle PreviousSiblingElement( const char* name = 0 ) {
1947 return XMLHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001948 }
1949 /// Get the next sibling of this handle.
1950 XMLHandle NextSibling() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001951 return XMLHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001952 }
1953 /// Get the next sibling element of this handle.
Dmitry-Me886ad972015-07-22 11:00:51 +03001954 XMLHandle NextSiblingElement( const char* name = 0 ) {
1955 return XMLHandle( _node ? _node->NextSiblingElement( name ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001956 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001957
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001958 /// Safe cast to XMLNode. This can return null.
1959 XMLNode* ToNode() {
Lee Thomason624d43f2012-10-12 10:58:48 -07001960 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001961 }
1962 /// Safe cast to XMLElement. This can return null.
1963 XMLElement* ToElement() {
Dmitry-Meebb16602016-11-16 17:22:45 +03001964 return ( _node ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001965 }
1966 /// Safe cast to XMLText. This can return null.
1967 XMLText* ToText() {
Dmitry-Meebb16602016-11-16 17:22:45 +03001968 return ( _node ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001969 }
1970 /// Safe cast to XMLUnknown. This can return null.
1971 XMLUnknown* ToUnknown() {
Dmitry-Meebb16602016-11-16 17:22:45 +03001972 return ( _node ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001973 }
1974 /// Safe cast to XMLDeclaration. This can return null.
1975 XMLDeclaration* ToDeclaration() {
Dmitry-Meebb16602016-11-16 17:22:45 +03001976 return ( _node ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001977 }
Lee Thomason3ffdd392012-03-28 17:27:55 -07001978
1979private:
Lee Thomason624d43f2012-10-12 10:58:48 -07001980 XMLNode* _node;
Lee Thomason3ffdd392012-03-28 17:27:55 -07001981};
1982
Lee Thomason (grinliz)2a1cd272012-02-24 17:37:53 -08001983
1984/**
Lee Thomason (grinliz)ae209f62012-04-04 22:00:07 -07001985 A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
1986 same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
Lee Thomason8b899812012-04-04 15:58:16 -07001987*/
PKEuS16ed47d2013-07-06 12:02:43 +02001988class TINYXML2_LIB XMLConstHandle
Lee Thomason8b899812012-04-04 15:58:16 -07001989{
1990public:
Lee Thomason624d43f2012-10-12 10:58:48 -07001991 XMLConstHandle( const XMLNode* node ) {
1992 _node = node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001993 }
Lee Thomason624d43f2012-10-12 10:58:48 -07001994 XMLConstHandle( const XMLNode& node ) {
1995 _node = &node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001996 }
1997 XMLConstHandle( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07001998 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07001999 }
Lee Thomason8b899812012-04-04 15:58:16 -07002000
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002001 XMLConstHandle& operator=( const XMLConstHandle& ref ) {
Lee Thomason624d43f2012-10-12 10:58:48 -07002002 _node = ref._node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002003 return *this;
2004 }
Lee Thomason8b899812012-04-04 15:58:16 -07002005
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002006 const XMLConstHandle FirstChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002007 return XMLConstHandle( _node ? _node->FirstChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002008 }
Dmitry-Me886ad972015-07-22 11:00:51 +03002009 const XMLConstHandle FirstChildElement( const char* name = 0 ) const {
2010 return XMLConstHandle( _node ? _node->FirstChildElement( name ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002011 }
2012 const XMLConstHandle LastChild() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002013 return XMLConstHandle( _node ? _node->LastChild() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002014 }
Dmitry-Me886ad972015-07-22 11:00:51 +03002015 const XMLConstHandle LastChildElement( const char* name = 0 ) const {
2016 return XMLConstHandle( _node ? _node->LastChildElement( name ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002017 }
2018 const XMLConstHandle PreviousSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002019 return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002020 }
Dmitry-Me886ad972015-07-22 11:00:51 +03002021 const XMLConstHandle PreviousSiblingElement( const char* name = 0 ) const {
2022 return XMLConstHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002023 }
2024 const XMLConstHandle NextSibling() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002025 return XMLConstHandle( _node ? _node->NextSibling() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002026 }
Dmitry-Me886ad972015-07-22 11:00:51 +03002027 const XMLConstHandle NextSiblingElement( const char* name = 0 ) const {
2028 return XMLConstHandle( _node ? _node->NextSiblingElement( name ) : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002029 }
Lee Thomason8b899812012-04-04 15:58:16 -07002030
2031
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002032 const XMLNode* ToNode() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002033 return _node;
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002034 }
2035 const XMLElement* ToElement() const {
Dmitry-Meebb16602016-11-16 17:22:45 +03002036 return ( _node ? _node->ToElement() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002037 }
2038 const XMLText* ToText() const {
Dmitry-Meebb16602016-11-16 17:22:45 +03002039 return ( _node ? _node->ToText() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002040 }
2041 const XMLUnknown* ToUnknown() const {
Dmitry-Meebb16602016-11-16 17:22:45 +03002042 return ( _node ? _node->ToUnknown() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002043 }
2044 const XMLDeclaration* ToDeclaration() const {
Dmitry-Meebb16602016-11-16 17:22:45 +03002045 return ( _node ? _node->ToDeclaration() : 0 );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002046 }
Lee Thomason (grinliz)bd0a8ac2012-02-20 20:14:33 -08002047
Lee Thomason5cae8972012-01-24 18:03:07 -08002048private:
Lee Thomason624d43f2012-10-12 10:58:48 -07002049 const XMLNode* _node;
Lee Thomason56bdd022012-02-09 18:16:58 -08002050};
Lee Thomason6f381b72012-03-02 12:59:39 -08002051
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002052
2053/**
2054 Printing functionality. The XMLPrinter gives you more
2055 options than the XMLDocument::Print() method.
2056
2057 It can:
2058 -# Print to memory.
Thomas Roß08bdf502012-05-12 14:21:23 +02002059 -# Print to a file you provide.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002060 -# Print XML without a XMLDocument.
2061
2062 Print to Memory
2063
2064 @verbatim
2065 XMLPrinter printer;
Vasily Biryukov9a975b72013-05-11 21:41:42 +06002066 doc.Print( &printer );
Thomas Roß08bdf502012-05-12 14:21:23 +02002067 SomeFunction( printer.CStr() );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002068 @endverbatim
2069
2070 Print to a File
Lee Thomason (grinliz)2f1f6242012-09-16 11:32:34 -07002071
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002072 You provide the file pointer.
2073 @verbatim
2074 XMLPrinter printer( fp );
2075 doc.Print( &printer );
2076 @endverbatim
2077
2078 Print without a XMLDocument
2079
2080 When loading, an XML parser is very useful. However, sometimes
2081 when saving, it just gets in the way. The code is often set up
2082 for streaming, and constructing the DOM is just overhead.
2083
2084 The Printer supports the streaming case. The following code
2085 prints out a trivially simple XML file without ever creating
2086 an XML document.
2087
2088 @verbatim
2089 XMLPrinter printer( fp );
2090 printer.OpenElement( "foo" );
2091 printer.PushAttribute( "foo", "bar" );
2092 printer.CloseElement();
2093 @endverbatim
2094*/
PKEuS16ed47d2013-07-06 12:02:43 +02002095class TINYXML2_LIB XMLPrinter : public XMLVisitor
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002096{
2097public:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002098 /** Construct the printer. If the FILE* is specified,
2099 this will print to the FILE. Else it will print
2100 to memory, and the result is available in CStr().
2101 If 'compact' is set to true, then output is created
2102 with only required whitespace and newlines.
2103 */
PKEuS1bfb9542013-08-04 13:51:17 +02002104 XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002105 virtual ~XMLPrinter() {}
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002106
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002107 /** If streaming, write the BOM and declaration. */
2108 void PushHeader( bool writeBOM, bool writeDeclaration );
2109 /** If streaming, start writing an element.
2110 The element must be closed with CloseElement()
2111 */
Lee Thomason256adb62014-04-06 14:41:46 -07002112 void OpenElement( const char* name, bool compactMode=false );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002113 /// If streaming, add an attribute to an open element.
2114 void PushAttribute( const char* name, const char* value );
2115 void PushAttribute( const char* name, int value );
2116 void PushAttribute( const char* name, unsigned value );
Lee Thomason51c12712016-06-04 20:18:49 -07002117 void PushAttribute(const char* name, int64_t value);
2118 void PushAttribute( const char* name, bool value );
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002119 void PushAttribute( const char* name, double value );
2120 /// If streaming, close the Element.
Lee Thomason256adb62014-04-06 14:41:46 -07002121 virtual void CloseElement( bool compactMode=false );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002122
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002123 /// Add a text node.
2124 void PushText( const char* text, bool cdata=false );
2125 /// Add a text node from an integer.
2126 void PushText( int value );
2127 /// Add a text node from an unsigned.
2128 void PushText( unsigned value );
Lee Thomason51c12712016-06-04 20:18:49 -07002129 /// Add a text node from an unsigned.
2130 void PushText(int64_t value);
2131 /// Add a text node from a bool.
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002132 void PushText( bool value );
2133 /// Add a text node from a float.
2134 void PushText( float value );
2135 /// Add a text node from a double.
2136 void PushText( double value );
Lee Thomason21be8822012-07-15 17:27:22 -07002137
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002138 /// Add a comment
2139 void PushComment( const char* comment );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002140
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002141 void PushDeclaration( const char* value );
2142 void PushUnknown( const char* value );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002143
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002144 virtual bool VisitEnter( const XMLDocument& /*doc*/ );
2145 virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
2146 return true;
2147 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002148
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002149 virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
2150 virtual bool VisitExit( const XMLElement& element );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002151
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002152 virtual bool Visit( const XMLText& text );
2153 virtual bool Visit( const XMLComment& comment );
2154 virtual bool Visit( const XMLDeclaration& declaration );
2155 virtual bool Visit( const XMLUnknown& unknown );
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002156
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002157 /**
2158 If in print to memory mode, return a pointer to
2159 the XML file in memory.
2160 */
2161 const char* CStr() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002162 return _buffer.Mem();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002163 }
2164 /**
2165 If in print to memory mode, return the size
2166 of the XML file in memory. (Note the size returned
2167 includes the terminating null.)
2168 */
2169 int CStrSize() const {
Lee Thomason624d43f2012-10-12 10:58:48 -07002170 return _buffer.Size();
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002171 }
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002172 /**
2173 If in print to memory mode, reset the buffer to the
2174 beginning.
2175 */
Lee Thomasonce0510b2013-11-26 21:29:37 -08002176 void ClearBuffer() {
2177 _buffer.Clear();
Reinhard Klambauer3bc3d4e2013-11-22 14:05:21 +01002178 _buffer.Push(0);
2179 }
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002180
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002181protected:
Alexander Maid740b642014-05-20 22:04:42 +02002182 virtual bool CompactMode( const XMLElement& ) { return _compactMode; }
Uli Kusterer5d1d27e2014-02-20 11:50:22 +01002183
Lee Thomasonc18eb232014-02-21 17:31:17 -08002184 /** Prints out the space before an element. You may override to change
2185 the space and tabs used. A PrintSpace() override should call Print().
2186 */
2187 virtual void PrintSpace( int depth );
2188 void Print( const char* format, ... );
2189
Dmitry-Mea092bc12014-12-23 17:57:05 +03002190 void SealElementIfJustOpened();
Dennis Jenkins59c75d32013-10-08 13:10:07 -05002191 bool _elementJustOpened;
2192 DynArray< const char*, 10 > _stack;
2193
2194private:
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002195 void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002196
Lee Thomason624d43f2012-10-12 10:58:48 -07002197 bool _firstElement;
Jerome Martinez242c3ea2013-01-06 12:20:04 +01002198 FILE* _fp;
Lee Thomason624d43f2012-10-12 10:58:48 -07002199 int _depth;
2200 int _textDepth;
2201 bool _processEntities;
Lee Thomasonc18eb232014-02-21 17:31:17 -08002202 bool _compactMode;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002203
Lee Thomasona9cf3f92012-10-11 16:56:51 -07002204 enum {
2205 ENTITY_RANGE = 64,
2206 BUF_SIZE = 200
2207 };
Lee Thomason624d43f2012-10-12 10:58:48 -07002208 bool _entityFlag[ENTITY_RANGE];
2209 bool _restrictedEntityFlag[ENTITY_RANGE];
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002210
Lee Thomason624d43f2012-10-12 10:58:48 -07002211 DynArray< char, 20 > _buffer;
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002212};
2213
2214
Guillermo A. Amaralb42ba362012-03-20 00:15:30 -07002215} // tinyxml2
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002216
PKEuS95060352013-07-26 10:42:44 +02002217#if defined(_MSC_VER)
2218# pragma warning(pop)
2219#endif
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002220
U-Lama\Leee13c3e62011-12-28 14:36:55 -08002221#endif // TINYXML2_INCLUDED