blame: source/code/Libs/include/cereal/external/rapidxml/rapidxml.hpp

#ifndef RAPIDXML_HPP_INCLUDED

#define RAPIDXML_HPP_INCLUDED

// Copyright (C) 2006, 2009 Marcin Kalicinski

// Version 1.13

// Revision $DateTime: 2009/05/13 01:46:17 $

// If standard library is disabled, user must provide implementations of required functions and typedefs

#if !defined(RAPIDXML_NO_STDLIB)

    #include <cstdlib>      // For std::size_t

    #include <cassert>      // For assert

    #include <new>          // For placement new

#endif

// On MSVC, disable "conditional expression is constant" warning (level 4).

// This warning is almost impossible to avoid with certain types of templated code

#ifdef _MSC_VER

    #pragma warning(push)

    #pragma warning(disable:4127)   // Conditional expression is constant

    #pragma warning(disable:4100)   // unreferenced formal parameter

#endif

///////////////////////////////////////////////////////////////////////////

// RAPIDXML_PARSE_ERROR

#if defined(RAPIDXML_NO_EXCEPTIONS)

#define RAPIDXML_PARSE_ERROR(what, where) { parse_error_handler(what, where); assert(0); }

namespace rapidxml

{

    //! When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS,

    //! this function is called to notify user about the error.

    //! It must be defined by the user.

    //! <br><br>

    //! This function cannot return. If it does, the results are undefined.

    //! <br><br>

    //! A very simple definition might look like that:

    //! <pre>

    //! void %rapidxml::%parse_error_handler(const char *what, void *where)

    //! {

    //!     std::cout << "Parse error: " << what << "\n";

    //!     std::abort();

    //! }

    //! </pre>

    //! \param what Human readable description of the error.

    //! \param where Pointer to character data where error was detected.

    void parse_error_handler(const char *what, void *where);

}

#else

#include <exception>    // For std::exception

#define RAPIDXML_PARSE_ERROR(what, where) throw parse_error(what, where)

namespace rapidxml

{

    //! Parse error exception.

    //! This exception is thrown by the parser when an error occurs.

    //! Use what() function to get human-readable error message.

    //! Use where() function to get a pointer to position within source text where error was detected.

    //! <br><br>

    //! If throwing exceptions by the parser is undesirable,

    //! it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before rapidxml.hpp is included.

    //! This will cause the parser to call rapidxml::parse_error_handler() function instead of throwing an exception.

    //! This function must be defined by the user.

    //! <br><br>

    //! This class derives from <code>std::exception</code> class.

    class parse_error: public std::exception

    {

    public:

        //! Constructs parse error

        parse_error(const char *what_, void *where_)

            : m_what(what_)

            , m_where(where_)

        {

        }

        //! Gets human readable description of error.

        //! \return Pointer to null terminated description of the error.

        virtual const char *what() const throw()

        {

            return m_what;

        }

        //! Gets pointer to character data where error happened.

        //! Ch should be the same as char type of xml_document that produced the error.

        //! \return Pointer to location within the parsed string where error occured.

        template<class Ch>

        Ch *where() const

        {

            return reinterpret_cast<Ch *>(m_where);

        }

    private:

        const char *m_what;

        void *m_where;

    };

}

#endif

///////////////////////////////////////////////////////////////////////////

// Pool sizes

#ifndef RAPIDXML_STATIC_POOL_SIZE

    // Size of static memory block of memory_pool.

    // Define RAPIDXML_STATIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.

    // No dynamic memory allocations are performed by memory_pool until static memory is exhausted.

    #define RAPIDXML_STATIC_POOL_SIZE (64 * 1024)

#endif

#ifndef RAPIDXML_DYNAMIC_POOL_SIZE

    // Size of dynamic memory block of memory_pool.

    // Define RAPIDXML_DYNAMIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.

    // After the static block is exhausted, dynamic blocks with approximately this size are allocated by memory_pool.

    #define RAPIDXML_DYNAMIC_POOL_SIZE (64 * 1024)

#endif

#ifndef RAPIDXML_ALIGNMENT

    // Memory allocation alignment.

    // Define RAPIDXML_ALIGNMENT before including rapidxml.hpp if you want to override the default value, which is the size of pointer.

    // All memory allocations for nodes, attributes and strings will be aligned to this value.

    // This must be a power of 2 and at least 1, otherwise memory_pool will not work.

    #define RAPIDXML_ALIGNMENT sizeof(void *)

#endif

namespace rapidxml

{

    // Forward declarations

    template<class Ch> class xml_node;

    template<class Ch> class xml_attribute;

    template<class Ch> class xml_document;

    //! Enumeration listing all node types produced by the parser.

    //! Use xml_node::type() function to query node type.

    enum node_type

    {

        node_document,      //!< A document node. Name and value are empty.

        node_element,       //!< An element node. Name contains element name. Value contains text of first data node.

        node_data,          //!< A data node. Name is empty. Value contains data text.

        node_cdata,         //!< A CDATA node. Name is empty. Value contains data text.

        node_comment,       //!< A comment node. Name is empty. Value contains comment text.

        node_declaration,   //!< A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.

        node_doctype,       //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE text.

        node_pi             //!< A PI node. Name contains target. Value contains instructions.

    };

    ///////////////////////////////////////////////////////////////////////

    // Parsing flags

    //! Parse flag instructing the parser to not create data nodes.

    //! Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_no_data_nodes = 0x1;

    //! Parse flag instructing the parser to not use text of first data node as a value of parent element.

    //! Can be combined with other flags by use of | operator.

    //! Note that child data nodes of element node take precendence over its value when printing.

    //! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.

    //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_no_element_values = 0x2;

    //! Parse flag instructing the parser to not place zero terminators after strings in the source text.

    //! By default zero terminators are placed, modifying source text.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_no_string_terminators = 0x4;

    //! Parse flag instructing the parser to not translate entities in the source text.

    //! By default entities are translated, modifying source text.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_no_entity_translation = 0x8;

    //! Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters.

    //! By default, UTF-8 handling is enabled.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_no_utf8 = 0x10;

    //! Parse flag instructing the parser to create XML declaration node.

    //! By default, declaration node is not created.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_declaration_node = 0x20;

    //! Parse flag instructing the parser to create comments nodes.

    //! By default, comment nodes are not created.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_comment_nodes = 0x40;

    //! Parse flag instructing the parser to create DOCTYPE node.

    //! By default, doctype node is not created.

    //! Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_doctype_node = 0x80;

    //! Parse flag instructing the parser to create PI nodes.

    //! By default, PI nodes are not created.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_pi_nodes = 0x100;

    //! Parse flag instructing the parser to validate closing tag names.

    //! If not set, name inside closing tag is irrelevant to the parser.

    //! By default, closing tags are not validated.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_validate_closing_tags = 0x200;

    //! Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes.

    //! By default, whitespace is not trimmed.

    //! This flag does not cause the parser to modify source text.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_trim_whitespace = 0x400;

    //! Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character.

    //! Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag.

    //! By default, whitespace is not normalized.

    //! If this flag is specified, source text will be modified.

    //! Can be combined with other flags by use of | operator.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_normalize_whitespace = 0x800;

    // Compound flags

    //! Parse flags which represent default behaviour of the parser.

    //! This is always equal to 0, so that all other flags can be simply ored together.

    //! Normally there is no need to inconveniently disable flags by anding with their negated (~) values.

    //! This also means that meaning of each flag is a <i>negation</i> of the default setting.

    //! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is <i>enabled</i> by default,

    //! and using the flag will disable it.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_default = 0;

    //! A combination of parse flags that forbids any modifications of the source text.

    //! This also results in faster parsing. However, note that the following will occur:

    //! <ul>

    //! <li>names and values of nodes will not be zero terminated, you have to use xml_base::name_size() and xml_base::value_size() functions to determine where name and value ends</li>

    //! <li>entities will not be translated</li>

    //! <li>whitespace will not be normalized</li>

    //! </ul>

    //! See xml_document::parse() function.

    const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation;

    //! A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_fastest = parse_non_destructive | parse_no_data_nodes;

    //! A combination of parse flags resulting in largest amount of data being extracted.

    //! This usually results in slowest parsing.

    //! <br><br>

    //! See xml_document::parse() function.

    const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;

    ///////////////////////////////////////////////////////////////////////

    // Internals

    //! \cond internal

    namespace internal

    {

        // Struct that contains lookup tables for the parser

        // It must be a template to allow correct linking (because it has static data members, which are defined in a header file).

        template<int Dummy>

        struct lookup_tables

        {

            static const unsigned char lookup_whitespace[256];              // Whitespace table

            static const unsigned char lookup_node_name[256];               // Node name table

            static const unsigned char lookup_text[256];                    // Text table

            static const unsigned char lookup_text_pure_no_ws[256];         // Text table

            static const unsigned char lookup_text_pure_with_ws[256];       // Text table

            static const unsigned char lookup_attribute_name[256];          // Attribute name table

            static const unsigned char lookup_attribute_data_1[256];        // Attribute data table with single quote

            static const unsigned char lookup_attribute_data_1_pure[256];   // Attribute data table with single quote

            static const unsigned char lookup_attribute_data_2[256];        // Attribute data table with double quotes

            static const unsigned char lookup_attribute_data_2_pure[256];   // Attribute data table with double quotes

            static const unsigned char lookup_digits[256];                  // Digits

            static const unsigned char lookup_upcase[256];                  // To uppercase conversion table for ASCII characters

        };

        // Find length of the string

        template<class Ch>

        inline std::size_t measure(const Ch *p)

        {

            const Ch *tmp = p;

            while (*tmp)

                ++tmp;

            return tmp - p;

        }

        // Compare strings for equality

        template<class Ch>

        inline bool compare(const Ch *p1, std::size_t size1, const Ch *p2, std::size_t size2, bool case_sensitive)

        {

            if (size1 != size2)

                return false;

            if (case_sensitive)

            {

                for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)

                    if (*p1 != *p2)

                        return false;

            }

            else

            {

                for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)

                    if (lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p1)] != lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p2)])

                        return false;

            }

            return true;

        }

        template<class Ch>

        inline bool preserve_space(xml_node<Ch>* node)

        {

            const Ch preserve_value[] = { Ch('p'), Ch('r'), Ch('e'), Ch('s'), Ch('e'), Ch('r'), Ch('v'), Ch('e') };

            const xml_attribute<Ch>* space = node->first_attribute("xml:space");

            return space && internal::compare(space->value(), space->value_size(), preserve_value, sizeof(preserve_value) / sizeof(Ch), true);

        }

    }

    //! \endcond

    ///////////////////////////////////////////////////////////////////////

    // Memory pool

    //! This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation.

    //! In most cases, you will not need to use this class directly.

    //! However, if you need to create nodes manually or modify names/values of nodes,

    //! you are encouraged to use memory_pool of relevant xml_document to allocate the memory.

    //! Not only is this faster than allocating them by using <code>new</code> operator,

    //! but also their lifetime will be tied to the lifetime of document,

    //! possibly simplyfing memory management.

    //! <br><br>

    //! Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool.

    //! You can also call allocate_string() function to allocate strings.

    //! Such strings can then be used as names or values of nodes without worrying about their lifetime.

    //! Note that there is no <code>free()</code> function -- all allocations are freed at once when clear() function is called,

    //! or when the pool is destroyed.

    //! <br><br>

    //! It is also possible to create a standalone memory_pool, and use it

    //! to allocate nodes, whose lifetime will not be tied to any document.

    //! <br><br>

    //! Pool maintains <code>RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory.

    //! Until static memory is exhausted, no dynamic memory allocations are done.

    //! When static memory is exhausted, pool allocates additional blocks of memory of size <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> each,

    //! by using global <code>new[]</code> and <code>delete[]</code> operators.

    //! This behaviour can be changed by setting custom allocation routines.

    //! Use set_allocator() function to set them.

    //! <br><br>

    //! Allocations for nodes, attributes and strings are aligned at <code>RAPIDXML_ALIGNMENT</code> bytes.

    //! This value defaults to the size of pointer on target architecture.

    //! <br><br>

    //! To obtain absolutely top performance from the parser,

    //! it is important that all nodes are allocated from a single, contiguous block of memory.

    //! Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably.

    //! If required, you can tweak <code>RAPIDXML_STATIC_POOL_SIZE</code>, <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>RAPIDXML_ALIGNMENT</code>

    //! to obtain best wasted memory to performance compromise.

    //! To do it, define their values before rapidxml.hpp file is included.

    //! \param Ch Character type of created nodes.

    template<class Ch = char>

    class memory_pool

    {

    public:

        //! \cond internal

        typedef void *(alloc_func)(std::size_t);       // Type of user-defined function used to allocate memory

        typedef void (free_func)(void *);              // Type of user-defined function used to free memory

        //! \endcond

        //! Constructs empty pool with default allocator functions.

        memory_pool()

            : m_alloc_func(0)

            , m_free_func(0)

        {

            init();

        }

        //! Destroys pool and frees all the memory.

        //! This causes memory occupied by nodes allocated by the pool to be freed.

        //! Nodes allocated from the pool are no longer valid.

        ~memory_pool()

        {

            clear();

        }

        //! Allocates a new node from the pool, and optionally assigns name and value to it.

        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.

        //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function

        //! will call rapidxml::parse_error_handler() function.

        //! \param type Type of node to create.

        //! \param name Name to assign to the node, or 0 to assign no name.

        //! \param value Value to assign to the node, or 0 to assign no value.

        //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.

        //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.

        //! \return Pointer to allocated node. This pointer will never be NULL.

        xml_node<Ch> *allocate_node(node_type type,

                                    const Ch *name = 0, const Ch *value = 0,

                                    std::size_t name_size = 0, std::size_t value_size = 0)

        {

            void *memory = allocate_aligned(sizeof(xml_node<Ch>));

            xml_node<Ch> *node = new(memory) xml_node<Ch>(type);

            if (name)

            {

                if (name_size > 0)

                    node->name(name, name_size);

                else

                    node->name(name);

            }

            if (value)

            {

                if (value_size > 0)

                    node->value(value, value_size);

                else

                    node->value(value);

            }

            return node;

        }

        //! Allocates a new attribute from the pool, and optionally assigns name and value to it.

        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.

        //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function

        //! will call rapidxml::parse_error_handler() function.

        //! \param name Name to assign to the attribute, or 0 to assign no name.

        //! \param value Value to assign to the attribute, or 0 to assign no value.

        //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.

        //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.

        //! \return Pointer to allocated attribute. This pointer will never be NULL.

        xml_attribute<Ch> *allocate_attribute(const Ch *name = 0, const Ch *value = 0,

                                              std::size_t name_size = 0, std::size_t value_size = 0)

        {

            void *memory = allocate_aligned(sizeof(xml_attribute<Ch>));

            xml_attribute<Ch> *attribute = new(memory) xml_attribute<Ch>;

            if (name)

            {

                if (name_size > 0)

                    attribute->name(name, name_size);

                else

                    attribute->name(name);

            }

            if (value)

            {

                if (value_size > 0)

                    attribute->value(value, value_size);

                else

                    attribute->value(value);

            }

            return attribute;

        }

        //! Allocates a char array of given size from the pool, and optionally copies a given string to it.

        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.

        //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function

        //! will call rapidxml::parse_error_handler() function.

        //! \param source String to initialize the allocated memory with, or 0 to not initialize it.

        //! \param size Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.

        //! \return Pointer to allocated char array. This pointer will never be NULL.

        Ch *allocate_string(const Ch *source = 0, std::size_t size = 0)

        {

            assert(source || size);     // Either source or size (or both) must be specified

            if (size == 0)

                size = internal::measure(source) + 1;

            Ch *result = static_cast<Ch *>(allocate_aligned(size * sizeof(Ch)));

            if (source)

                for (std::size_t i = 0; i < size; ++i)

                    result[i] = source[i];

            return result;

        }

        //! Clones an xml_node and its hierarchy of child nodes and attributes.

        //! Nodes and attributes are allocated from this memory pool.

        //! Names and values are not cloned, they are shared between the clone and the source.

        //! Result node can be optionally specified as a second parameter,

        //! in which case its contents will be replaced with cloned source node.

        //! This is useful when you want to clone entire document.

        //! \param source Node to clone.

        //! \param result Node to put results in, or 0 to automatically allocate result node

        //! \return Pointer to cloned node. This pointer will never be NULL.

        xml_node<Ch> *clone_node(const xml_node<Ch> *source, xml_node<Ch> *result = 0)

        {

            // Prepare result node

            if (result)

            {

                result->remove_all_attributes();

                result->remove_all_nodes();

                result->type(source->type());

            }

            else

                result = allocate_node(source->type());

            // Clone name and value

            result->name(source->name(), source->name_size());

            result->value(source->value(), source->value_size());

            // Clone child nodes and attributes

            for (xml_node<Ch> *child = source->first_node(); child; child = child->next_sibling())

                result->append_node(clone_node(child));

            for (xml_attribute<Ch> *attr = source->first_attribute(); attr; attr = attr->next_attribute())

                result->append_attribute(allocate_attribute(attr->name(), attr->value(), attr->name_size(), attr->value_size()));

            return result;

        }

        //! Clears the pool.

        //! This causes memory occupied by nodes allocated by the pool to be freed.

        //! Any nodes or strings allocated from the pool will no longer be valid.

        void clear()

        {

            while (m_begin != m_static_memory)

            {

                char *previous_begin = reinterpret_cast<header *>(align(m_begin))->previous_begin;

                if (m_free_func)

                    m_free_func(m_begin);

                else

                    delete[] m_begin;

                m_begin = previous_begin;

            }

            init();

        }

        //! Sets or resets the user-defined memory allocation functions for the pool.

        //! This can only be called when no memory is allocated from the pool yet, otherwise results are undefined.

        //! Allocation function must not return invalid pointer on failure. It should either throw,

        //! stop the program, or use <code>longjmp()</code> function to pass control to other place of program.

        //! If it returns invalid pointer, results are undefined.

        //! <br><br>

        //! User defined allocation functions must have the following forms:

        //! <br><code>

        //! <br>void *allocate(std::size_t size);

        //! <br>void free(void *pointer);

        //! </code><br>

        //! \param af Allocation function, or 0 to restore default function

        //! \param ff Free function, or 0 to restore default function

        void set_allocator(alloc_func *af, free_func *ff)

        {

            assert(m_begin == m_static_memory && m_ptr == align(m_begin));    // Verify that no memory is allocated yet

            m_alloc_func = af;

            m_free_func = ff;

        }

    private:

        struct header

        {

            char *previous_begin;

        };

        void init()

        {

            m_begin = m_static_memory;

            m_ptr = align(m_begin);

            m_end = m_static_memory + sizeof(m_static_memory);

        }

        char *align(char *ptr)

        {

            std::size_t alignment = ((RAPIDXML_ALIGNMENT - (std::size_t(ptr) & (RAPIDXML_ALIGNMENT - 1))) & (RAPIDXML_ALIGNMENT - 1));

            return ptr + alignment;

        }

        char *allocate_raw(std::size_t size)

        {

            // Allocate

            void *memory;

            if (m_alloc_func)   // Allocate memory using either user-specified allocation function or global operator new[]

            {

                memory = m_alloc_func(size);

                assert(memory); // Allocator is not allowed to return 0, on failure it must either throw, stop the program or use longjmp

            }

            else

            {

                memory = new char[size];

#ifdef RAPIDXML_NO_EXCEPTIONS

                if (!memory)            // If exceptions are disabled, verify memory allocation, because new will not be able to throw bad_alloc

                    RAPIDXML_PARSE_ERROR("out of memory", 0);

#endif

            }

            return static_cast<char *>(memory);

        }

        void *allocate_aligned(std::size_t size)

        {

            // Calculate aligned pointer

            char *result = align(m_ptr);

            // If not enough memory left in current pool, allocate a new pool

            if (result + size > m_end)

            {

                // Calculate required pool size (may be bigger than RAPIDXML_DYNAMIC_POOL_SIZE)

                std::size_t pool_size = RAPIDXML_DYNAMIC_POOL_SIZE;

                if (pool_size < size)

                    pool_size = size;

                // Allocate

                std::size_t alloc_size = sizeof(header) + (2 * RAPIDXML_ALIGNMENT - 2) + pool_size;     // 2 alignments required in worst case: one for header, one for actual allocation

                char *raw_memory = allocate_raw(alloc_size);

                // Setup new pool in allocated memory

                char *pool = align(raw_memory);

                header *new_header = reinterpret_cast<header *>(pool);

                new_header->previous_begin = m_begin;

                m_begin = raw_memory;

                m_ptr = pool + sizeof(header);

                m_end = raw_memory + alloc_size;

                // Calculate aligned pointer again using new pool

                result = align(m_ptr);

            }

            // Update pool and return aligned pointer

            m_ptr = result + size;

            return result;

        }

        char *m_begin;                                      // Start of raw memory making up current pool

        char *m_ptr;                                        // First free byte in current pool

        char *m_end;                                        // One past last available byte in current pool

        char m_static_memory[RAPIDXML_STATIC_POOL_SIZE];    // Static raw memory

        alloc_func *m_alloc_func;                           // Allocator function, or 0 if default is to be used

        free_func *m_free_func;                             // Free function, or 0 if default is to be used

    };

    ///////////////////////////////////////////////////////////////////////////

    // XML base

    //! Base class for xml_node and xml_attribute implementing common functions:

    //! name(), name_size(), value(), value_size() and parent().

    //! \param Ch Character type to use

    template<class Ch = char>

    class xml_base

    {

    public:

        ///////////////////////////////////////////////////////////////////////////

        // Construction & destruction

        // Construct a base with empty name, value and parent

        xml_base()

            : m_name(0)

            , m_value(0)

            , m_parent(0)

        {

        }

        ///////////////////////////////////////////////////////////////////////////

        // Node data access

        //! Gets name of the node.

        //! Interpretation of name depends on type of node.

        //! Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.

        //! <br><br>

        //! Use name_size() function to determine length of the name.

        //! \return Name of node, or empty string if node has no name.

        Ch *name() const

        {

            return m_name ? m_name : nullstr();

        }

        //! Gets size of node name, not including terminator character.

        //! This function works correctly irrespective of whether name is or is not zero terminated.

        //! \return Size of node name, in characters.

        std::size_t name_size() const

        {

            return m_name ? m_name_size : 0;

        }

        //! Gets value of node.

        //! Interpretation of value depends on type of node.

        //! Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.

        //! <br><br>

        //! Use value_size() function to determine length of the value.

        //! \return Value of node, or empty string if node has no value.

        Ch *value() const

        {

            return m_value ? m_value : nullstr();

        }

        //! Gets size of node value, not including terminator character.

        //! This function works correctly irrespective of whether value is or is not zero terminated.

        //! \return Size of node value, in characters.

        std::size_t value_size() const

        {

            return m_value ? m_value_size : 0;

        }

        ///////////////////////////////////////////////////////////////////////////

        // Node modification

        //! Sets name of node to a non zero-terminated string.

        //! See \ref ownership_of_strings.

        //! <br><br>

        //! Note that node does not own its name or value, it only stores a pointer to it.

        //! It will not delete or otherwise free the pointer on destruction.

        //! It is reponsibility of the user to properly manage lifetime of the string.

        //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -

        //! on destruction of the document the string will be automatically freed.

        //! <br><br>

        //! Size of name must be specified separately, because name does not have to be zero terminated.

        //! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).

        //! \param name Name of node to set. Does not have to be zero terminated.

        //! \param size Size of name, in characters. This does not include zero terminator, if one is present.

        void name(const Ch *name_, std::size_t size)

        {

            m_name = const_cast<Ch *>(name_);

            m_name_size = size;

        }

        //! Sets name of node to a zero-terminated string.

        //! See also \ref ownership_of_strings and xml_node::name(const Ch *, std::size_t).

        //! \param name Name of node to set. Must be zero terminated.

        void name(const Ch *name_)

        {

            this->name(name_, internal::measure(name_));

        }

        //! Sets value of node to a non zero-terminated string.

        //! See \ref ownership_of_strings.

        //! <br><br>

        //! Note that node does not own its name or value, it only stores a pointer to it.

        //! It will not delete or otherwise free the pointer on destruction.

        //! It is reponsibility of the user to properly manage lifetime of the string.

        //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -

        //! on destruction of the document the string will be automatically freed.

        //! <br><br>

        //! Size of value must be specified separately, because it does not have to be zero terminated.

        //! Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).

        //! <br><br>

        //! If an element has a child node of type node_data, it will take precedence over element value when printing.

        //! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.

        //! \param value value of node to set. Does not have to be zero terminated.

        //! \param size Size of value, in characters. This does not include zero terminator, if one is present.

        void value(const Ch *value_, std::size_t size)

        {

            m_value = const_cast<Ch *>(value_);

            m_value_size = size;

        }

        //! Sets value of node to a zero-terminated string.

        //! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::size_t).

        //! \param value Vame of node to set. Must be zero terminated.

        void value(const Ch *value_)

        {

            this->value(value_, internal::measure(value_));

        }

        ///////////////////////////////////////////////////////////////////////////

        // Related nodes access

        //! Gets node parent.

        //! \return Pointer to parent node, or 0 if there is no parent.

        xml_node<Ch> *parent() const

        {

            return m_parent;

        }

    protected:

        // Return empty string

        static Ch *nullstr()

        {

            static Ch zero = Ch('\0');

            return &zero;

        }

        Ch *m_name;                         // Name of node, or 0 if no name

        Ch *m_value;                        // Value of node, or 0 if no value

        std::size_t m_name_size;            // Length of node name, or undefined of no name

        std::size_t m_value_size;           // Length of node value, or undefined if no value

        xml_node<Ch> *m_parent;             // Pointer to parent node, or 0 if none

    };

    //! Class representing attribute node of XML document.

    //! Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base).

    //! Note that after parse, both name and value of attribute will point to interior of source text used for parsing.

    //! Thus, this text must persist in memory for the lifetime of attribute.

    //! \param Ch Character type to use.

    template<class Ch = char>

    class xml_attribute: public xml_base<Ch>

    {

        friend class xml_node<Ch>;

    public:

        ///////////////////////////////////////////////////////////////////////////

        // Construction & destruction

        //! Constructs an empty attribute with the specified type.

        //! Consider using memory_pool of appropriate xml_document if allocating attributes manually.

        xml_attribute()

        {

        }

        ///////////////////////////////////////////////////////////////////////////

        // Related nodes access

        //! Gets document of which attribute is a child.

        //! \return Pointer to document that contains this attribute, or 0 if there is no parent document.

        xml_document<Ch> *document() const

        {

            if (xml_node<Ch> *node = this->parent())

            {

                while (node->parent())

                    node = node->parent();

                return node->type() == node_document ? static_cast<xml_document<Ch> *>(node) : 0;

            }

            else

                return 0;

        }

        //! Gets previous attribute, optionally matching attribute name.

        //! \param name Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero

        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string

        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

        //! \return Pointer to found attribute, or 0 if not found.

        xml_attribute<Ch> *previous_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const

        {

            if (name)

            {

                if (name_size == 0)

                    name_size = internal::measure(name);

                for (xml_attribute<Ch> *attribute = m_prev_attribute; attribute; attribute = attribute->m_prev_attribute)

                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))

                        return attribute;

                return 0;

            }

            else

                return this->m_parent ? m_prev_attribute : 0;

        }

        //! Gets next attribute, optionally matching attribute name.

        //! \param name Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero

        //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string

        //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

        //! \return Pointer to found attribute, or 0 if not found.

        xml_attribute<Ch> *next_attribute(const Ch *name_ = 0, std::size_t name_size_ = 0, bool case_sensitive = true) const

        {

            if (name_)

            {

                if (name_size_ == 0)

                    name_size_ = internal::measure(name_);

                for (xml_attribute<Ch> *attribute = m_next_attribute; attribute; attribute = attribute->m_next_attribute)

                    if (internal::compare(attribute->name(), attribute->name_size(), name_, name_size_, case_sensitive))

                        return attribute;

                return 0;

            }

            else

                return this->m_parent ? m_next_attribute : 0;

        }

    private:

        xml_attribute<Ch> *m_prev_attribute;        // Pointer to previous sibling of attribute, or 0 if none; only valid if parent is non-zero

        xml_attribute<Ch> *m_next_attribute;        // Pointer to next sibling of attribute, or 0 if none; only valid if parent is non-zero

    };

    ///////////////////////////////////////////////////////////////////////////

    // XML node