/**

 * pugixml parser - version 1.15

 * --------------------------------------------------------

 * Report bugs and download new versions at https://pugixml.org/

 *

 * SPDX-FileCopyrightText: Copyright (C) 2006-2026, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)

 * SPDX-License-Identifier: MIT

 *

 * See LICENSE.md or notice at the end of this file.

 */

// Define version macro; evaluates to major * 1000 + minor * 10 + patch so that it's safe to use in less-than comparisons

// Note: pugixml used major * 100 + minor * 10 + patch format up until 1.9 (which had version identifier 190); starting from pugixml 1.10, the minor version number is two digits

#ifndef PUGIXML_VERSION

# define PUGIXML_VERSION 1150 // 1.15

#endif

// Include user configuration file (this can define various configuration macros)

#include "pugiconfig.hpp"

#ifndef HEADER_PUGIXML_HPP

#define HEADER_PUGIXML_HPP

// Include stddef.h for size_t and ptrdiff_t

#include <stddef.h>

// Include exception header for XPath

#if !defined(PUGIXML_NO_XPATH) && !defined(PUGIXML_NO_EXCEPTIONS)

# include <exception>

#endif

// Include STL headers

#ifndef PUGIXML_NO_STL

# include <iterator>

# include <iosfwd>

# include <string>

#endif

// Check if std::string_view is available

#if !defined(PUGIXML_HAS_STRING_VIEW) && !defined(PUGIXML_NO_STL)

# if __cplusplus >= 201703L

#   define PUGIXML_HAS_STRING_VIEW

# elif defined(_MSVC_LANG) && _MSVC_LANG >= 201703L

#   define PUGIXML_HAS_STRING_VIEW

# endif

#endif

// Include string_view if appropriate

#ifdef PUGIXML_HAS_STRING_VIEW

# include <string_view>

#endif

// Macro for deprecated features

#ifndef PUGIXML_DEPRECATED

# if defined(__GNUC__)

#   define PUGIXML_DEPRECATED __attribute__((deprecated))

# elif defined(_MSC_VER) && _MSC_VER >= 1300

#   define PUGIXML_DEPRECATED __declspec(deprecated)

# else

#   define PUGIXML_DEPRECATED

# endif

#endif

// If no API is defined, assume default

#ifndef PUGIXML_API

# define PUGIXML_API

#endif

// If no API for classes is defined, assume default

#ifndef PUGIXML_CLASS

# define PUGIXML_CLASS PUGIXML_API

#endif

// If no API for functions is defined, assume default

#ifndef PUGIXML_FUNCTION

# define PUGIXML_FUNCTION PUGIXML_API

#endif

// If the platform is known to have long long support, enable long long functions

#ifndef PUGIXML_HAS_LONG_LONG

# if __cplusplus >= 201103

#   define PUGIXML_HAS_LONG_LONG

# elif defined(_MSC_VER) && _MSC_VER >= 1400

#   define PUGIXML_HAS_LONG_LONG

# endif

#endif

// If the platform is known to have move semantics support, compile move ctor/operator implementation

#ifndef PUGIXML_HAS_MOVE

# if __cplusplus >= 201103

#   define PUGIXML_HAS_MOVE

# elif defined(_MSC_VER) && _MSC_VER >= 1600

#   define PUGIXML_HAS_MOVE

# endif

#endif

// If C++ is 2011 or higher, use 'noexcept' specifiers

#ifndef PUGIXML_NOEXCEPT

# if __cplusplus >= 201103

#   define PUGIXML_NOEXCEPT noexcept

# elif defined(_MSC_VER) && _MSC_VER >= 1900

#   define PUGIXML_NOEXCEPT noexcept

# else

#   define PUGIXML_NOEXCEPT throw()

# endif

#endif

// Some functions can not be noexcept in compact mode

#ifdef PUGIXML_COMPACT

# define PUGIXML_NOEXCEPT_IF_NOT_COMPACT

#else

# define PUGIXML_NOEXCEPT_IF_NOT_COMPACT PUGIXML_NOEXCEPT

#endif

// If C++ is 2011 or higher, add 'override' qualifiers

#ifndef PUGIXML_OVERRIDE

# if __cplusplus >= 201103

#   define PUGIXML_OVERRIDE override

# elif defined(_MSC_VER) && _MSC_VER >= 1700

#   define PUGIXML_OVERRIDE override

# else

#   define PUGIXML_OVERRIDE

# endif

#endif

// If C++ is 2011 or higher, use 'nullptr'

#ifndef PUGIXML_NULL

# if __cplusplus >= 201103

#   define PUGIXML_NULL nullptr

# elif defined(_MSC_VER) && _MSC_VER >= 1600

#   define PUGIXML_NULL nullptr

# else

#   define PUGIXML_NULL 0

# endif

#endif

// If C++ is 2017 or higher, add 'inline' variables

#ifndef PUGIXML_INLINE_VAR

# ifdef __cpp_inline_variables

#   define PUGIXML_INLINE_VAR inline

# else

#   define PUGIXML_INLINE_VAR

# endif

#endif

// Character interface macros

#ifdef PUGIXML_WCHAR_MODE

# define PUGIXML_TEXT(t) L ## t

# define PUGIXML_CHAR wchar_t

#else

# define PUGIXML_TEXT(t) t

# define PUGIXML_CHAR char

#endif

namespace pugi

{

  // Character type used for all internal storage and operations; depends on PUGIXML_WCHAR_MODE

  typedef PUGIXML_CHAR char_t;

#ifndef PUGIXML_NO_STL

  // String type used for operations that work with STL string; depends on PUGIXML_WCHAR_MODE

  typedef std::basic_string<PUGIXML_CHAR> string_t;

#endif

#ifdef PUGIXML_HAS_STRING_VIEW

  // String view type used for operations that can work with a length delimited string; depends on PUGIXML_WCHAR_MODE

  typedef std::basic_string_view<PUGIXML_CHAR> string_view_t;

#endif

}

// The PugiXML namespace

namespace pugi

{

  // Tree node types

  enum xml_node_type

  {

    node_null,      // Empty (null) node handle

    node_document,    // A document tree's absolute root

    node_element,   // Element tag, i.e. '<node/>'

    node_pcdata,    // Plain character data, i.e. 'text'

    node_cdata,     // Character data, i.e. '<![CDATA[text]]>'

    node_comment,   // Comment tag, i.e. '<!-- text -->'

    node_pi,      // Processing instruction, i.e. '<?name?>'

    node_declaration, // Document declaration, i.e. '<?xml version="1.0"?>'

    node_doctype    // Document type declaration, i.e. '<!DOCTYPE doc>'

  };

  // Parsing options

  // Minimal parsing mode (equivalent to turning all other flags off).

  // Only elements and PCDATA sections are added to the DOM tree, no text conversions are performed.

  PUGIXML_INLINE_VAR const unsigned int parse_minimal = 0x0000;

  // This flag determines if processing instructions (node_pi) are added to the DOM tree. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_pi = 0x0001;

  // This flag determines if comments (node_comment) are added to the DOM tree. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_comments = 0x0002;

  // This flag determines if CDATA sections (node_cdata) are added to the DOM tree. This flag is on by default.

  PUGIXML_INLINE_VAR const unsigned int parse_cdata = 0x0004;

  // This flag determines if plain character data (node_pcdata) that consist only of whitespace are added to the DOM tree.

  // This flag is off by default; turning it on usually results in slower parsing and more memory consumption.

  PUGIXML_INLINE_VAR const unsigned int parse_ws_pcdata = 0x0008;

  // This flag determines if character and entity references are expanded during parsing. This flag is on by default.

  PUGIXML_INLINE_VAR const unsigned int parse_escapes = 0x0010;

  // This flag determines if EOL characters are normalized (converted to #xA) during parsing. This flag is on by default.

  PUGIXML_INLINE_VAR const unsigned int parse_eol = 0x0020;

  // This flag determines if attribute values are normalized using CDATA normalization rules during parsing. This flag is on by default.

  PUGIXML_INLINE_VAR const unsigned int parse_wconv_attribute = 0x0040;

  // This flag determines if attribute values are normalized using NMTOKENS normalization rules during parsing. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_wnorm_attribute = 0x0080;

  // This flag determines if document declaration (node_declaration) is added to the DOM tree. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_declaration = 0x0100;

  // This flag determines if document type declaration (node_doctype) is added to the DOM tree. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_doctype = 0x0200;

  // This flag determines if plain character data (node_pcdata) that is the only child of the parent node and that consists only

  // of whitespace is added to the DOM tree.

  // This flag is off by default; turning it on may result in slower parsing and more memory consumption.

  PUGIXML_INLINE_VAR const unsigned int parse_ws_pcdata_single = 0x0400;

  // This flag determines if leading and trailing whitespace is to be removed from plain character data. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_trim_pcdata = 0x0800;

  // This flag determines if plain character data that does not have a parent node is added to the DOM tree, and if an empty document

  // is a valid document. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_fragment = 0x1000;

  // This flag determines if plain character data is be stored in the parent element's value. This significantly changes the structure of

  // the document; this flag is only recommended for parsing documents with many PCDATA nodes in memory-constrained environments.

  // This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_embed_pcdata = 0x2000;

  // This flag determines whether determines whether the the two pcdata should be merged or not, if no intermediatory data are parsed in the document.

  // This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int parse_merge_pcdata = 0x4000;

  // The default parsing mode.

  // Elements, PCDATA and CDATA sections are added to the DOM tree, character/reference entities are expanded,

  // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.

  PUGIXML_INLINE_VAR const unsigned int parse_default = parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol;

  // The full parsing mode.

  // Nodes of all types are added to the DOM tree, character/reference entities are expanded,

  // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.

  PUGIXML_INLINE_VAR const unsigned int parse_full = parse_default | parse_pi | parse_comments | parse_declaration | parse_doctype;

  // These flags determine the encoding of input data for XML document

  enum xml_encoding

  {

    encoding_auto,    // Auto-detect input encoding using BOM or < / <? detection; use UTF8 if BOM is not found

    encoding_utf8,    // UTF8 encoding

    encoding_utf16_le,  // Little-endian UTF16

    encoding_utf16_be,  // Big-endian UTF16

    encoding_utf16,   // UTF16 with native endianness

    encoding_utf32_le,  // Little-endian UTF32

    encoding_utf32_be,  // Big-endian UTF32

    encoding_utf32,   // UTF32 with native endianness

    encoding_wchar,   // The same encoding wchar_t has (either UTF16 or UTF32)

    encoding_latin1

  };

  // Formatting flags

  // Indent the nodes that are written to output stream with as many indentation strings as deep the node is in DOM tree. This flag is on by default.

  PUGIXML_INLINE_VAR const unsigned int format_indent = 0x01;

  // Write encoding-specific BOM to the output stream. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_write_bom = 0x02;

  // Use raw output mode (no indentation and no line breaks are written). This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_raw = 0x04;

  // Omit default XML declaration even if there is no declaration in the document. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_no_declaration = 0x08;

  // Don't escape attribute values and PCDATA contents. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_no_escapes = 0x10;

  // Open file using text mode in xml_document::save_file. This enables special character (i.e. new-line) conversions on some systems. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_save_file_text = 0x20;

  // Write every attribute on a new line with appropriate indentation. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_indent_attributes = 0x40;

  // Don't output empty element tags, instead writing an explicit start and end tag even if there are no children. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_no_empty_element_tags = 0x80;

  // Skip characters belonging to range [0; 32) instead of "&#xNN;" encoding. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_skip_control_chars = 0x100;

  // Use single quotes ' instead of double quotes " for enclosing attribute values. This flag is off by default.

  PUGIXML_INLINE_VAR const unsigned int format_attribute_single_quote = 0x200;

  // The default set of formatting flags.

  // Nodes are indented depending on their depth in DOM tree, a default declaration is output if document has none.

  PUGIXML_INLINE_VAR const unsigned int format_default = format_indent;

  PUGIXML_INLINE_VAR const int default_double_precision = 17;

  PUGIXML_INLINE_VAR const int default_float_precision = 9;

  // Forward declarations

  struct xml_attribute_struct;

  struct xml_node_struct;

  class xml_node_iterator;

  class xml_attribute_iterator;

  class xml_named_node_iterator;

  class xml_tree_walker;

  struct xml_parse_result;

  class xml_node;

  class xml_text;

  #ifndef PUGIXML_NO_XPATH

  class xpath_node;

  class xpath_node_set;

  class xpath_query;

  class xpath_variable_set;

  #endif

  // Range-based for loop support

  template <typename It> class xml_object_range

  {

  public:

    typedef It const_iterator;

    typedef It iterator;

    xml_object_range(It b, It e): _begin(b), _end(e)

    {

    }

Unexecuted instantiation: pugi::xml_object_range<pugi::xml_node_iterator>::xml_object_range(pugi::xml_node_iterator, pugi::xml_node_iterator)

Unexecuted instantiation: pugi::xml_object_range<pugi::xml_named_node_iterator>::xml_object_range(pugi::xml_named_node_iterator, pugi::xml_named_node_iterator)

Unexecuted instantiation: pugi::xml_object_range<pugi::xml_attribute_iterator>::xml_object_range(pugi::xml_attribute_iterator, pugi::xml_attribute_iterator)

    It begin() const { return _begin; }

    It end() const { return _end; }

    bool empty() const { return _begin == _end; }

  private:

    It _begin, _end;

  };

  // Writer interface for node printing (see xml_node::print)

  class PUGIXML_CLASS xml_writer

  {

  public:

    virtual ~xml_writer();

    // Write memory chunk into stream/file/whatever

    virtual void write(const void* data, size_t size) = 0;

  };

  // xml_writer implementation for FILE*

  class PUGIXML_CLASS xml_writer_file: public xml_writer

  {

  public:

    // Construct writer from a FILE* object; void* is used to avoid header dependencies on stdio

    xml_writer_file(void* file);

    virtual void write(const void* data, size_t size) PUGIXML_OVERRIDE;

  private:

    void* file;

  };

  #ifndef PUGIXML_NO_STL

  // xml_writer implementation for streams

  class PUGIXML_CLASS xml_writer_stream: public xml_writer

  {

  public:

    // Construct writer from an output stream object

    xml_writer_stream(std::basic_ostream<char>& stream);

    xml_writer_stream(std::basic_ostream<wchar_t>& stream);

    virtual void write(const void* data, size_t size) PUGIXML_OVERRIDE;

  private:

    std::basic_ostream<char>* narrow_stream;

    std::basic_ostream<wchar_t>* wide_stream;

  };

  #endif

  // A light-weight handle for manipulating attributes in DOM tree

  class PUGIXML_CLASS xml_attribute

  {

    friend class xml_attribute_iterator;

    friend class xml_node;

  private:

    xml_attribute_struct* _attr;

    typedef void (*unspecified_bool_type)(xml_attribute***);

  public:

    // Default constructor. Constructs an empty attribute.

    xml_attribute();

    // Constructs attribute from internal pointer

    explicit xml_attribute(xml_attribute_struct* attr);

    // Safe bool conversion operator

    operator unspecified_bool_type() const;

    // Borland C++ workaround

    bool operator!() const;

    // Comparison operators (compares wrapped attribute pointers)

    bool operator==(const xml_attribute& r) const;

    bool operator!=(const xml_attribute& r) const;

    bool operator<(const xml_attribute& r) const;

    bool operator>(const xml_attribute& r) const;

    bool operator<=(const xml_attribute& r) const;

    bool operator>=(const xml_attribute& r) const;

    // Check if attribute is empty (null)

    bool empty() const;

    // Get attribute name/value, or "" if attribute is empty

    const char_t* name() const;

    const char_t* value() const;

    // Get attribute value, or the default value if attribute is empty

    const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;

    // Get attribute value as a number, or the default value if conversion did not succeed or attribute is empty

    int as_int(int def = 0) const;

    unsigned int as_uint(unsigned int def = 0) const;

    double as_double(double def = 0) const;

    float as_float(float def = 0) const;

  #ifdef PUGIXML_HAS_LONG_LONG

    long long as_llong(long long def = 0) const;

    unsigned long long as_ullong(unsigned long long def = 0) const;

  #endif

    // Get attribute value as bool (returns true if first character is in '1tTyY' set), or the default value if attribute is empty

    bool as_bool(bool def = false) const;

    // Set attribute name/value (returns false if attribute is empty or there is not enough memory)

    bool set_name(const char_t* rhs);

    bool set_name(const char_t* rhs, size_t size);

  #ifdef PUGIXML_HAS_STRING_VIEW

    bool set_name(string_view_t rhs);

  #endif

    bool set_value(const char_t* rhs);

    bool set_value(const char_t* rhs, size_t size);

  #ifdef PUGIXML_HAS_STRING_VIEW

    bool set_value(string_view_t rhs);

  #endif

    // Set attribute value with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")

    bool set_value(int rhs);

    bool set_value(unsigned int rhs);

    bool set_value(long rhs);

    bool set_value(unsigned long rhs);

    bool set_value(double rhs);

    bool set_value(double rhs, int precision);

    bool set_value(float rhs);

    bool set_value(float rhs, int precision);

    bool set_value(bool rhs);

  #ifdef PUGIXML_HAS_LONG_LONG

    bool set_value(long long rhs);

    bool set_value(unsigned long long rhs);

  #endif

    // Set attribute value (equivalent to set_value without error checking)

    xml_attribute& operator=(const char_t* rhs);

    xml_attribute& operator=(int rhs);

    xml_attribute& operator=(unsigned int rhs);

    xml_attribute& operator=(long rhs);

    xml_attribute& operator=(unsigned long rhs);

    xml_attribute& operator=(double rhs);

    xml_attribute& operator=(float rhs);

    xml_attribute& operator=(bool rhs);

  #ifdef PUGIXML_HAS_STRING_VIEW

    xml_attribute& operator=(string_view_t rhs);

  #endif

  #ifdef PUGIXML_HAS_LONG_LONG

    xml_attribute& operator=(long long rhs);

    xml_attribute& operator=(unsigned long long rhs);

  #endif

    // Get next/previous attribute in the attribute list of the parent node

    xml_attribute next_attribute() const;

    xml_attribute previous_attribute() const;

    // Get hash value (unique for handles to the same object)

    size_t hash_value() const;

    // Get internal pointer

    xml_attribute_struct* internal_object() const;

  };

#ifdef __BORLANDC__

  // Borland C++ workaround

  bool PUGIXML_FUNCTION operator&&(const xml_attribute& lhs, bool rhs);

  bool PUGIXML_FUNCTION operator||(const xml_attribute& lhs, bool rhs);

#endif

  // A light-weight handle for manipulating nodes in DOM tree

  class PUGIXML_CLASS xml_node

  {

    friend class xml_attribute_iterator;

    friend class xml_node_iterator;

    friend class xml_named_node_iterator;

  protected:

    xml_node_struct* _root;

    typedef void (*unspecified_bool_type)(xml_node***);

  public:

    // Default constructor. Constructs an empty node.

    xml_node();

    // Constructs node from internal pointer

    explicit xml_node(xml_node_struct* p);

    // Safe bool conversion operator

    operator unspecified_bool_type() const;

    // Borland C++ workaround

    bool operator!() const;

    // Comparison operators (compares wrapped node pointers)

    bool operator==(const xml_node& r) const;

    bool operator!=(const xml_node& r) const;

    bool operator<(const xml_node& r) const;

    bool operator>(const xml_node& r) const;

    bool operator<=(const xml_node& r) const;

    bool operator>=(const xml_node& r) const;

    // Check if node is empty (null)

    bool empty() const;

    // Get node type

    xml_node_type type() const;

    // Get node name, or "" if node is empty or it has no name

    const char_t* name() const;

    // Get node value, or "" if node is empty or it has no value

    // Note: For <node>text</node> node.value() does not return "text"! Use child_value() or text() methods to access text inside nodes.

    const char_t* value() const;

    // Get attribute list

    xml_attribute first_attribute() const;

    xml_attribute last_attribute() const;

    // Get children list

    xml_node first_child() const;

    xml_node last_child() const;

    // Get next/previous sibling in the children list of the parent node

    xml_node next_sibling() const;

    xml_node previous_sibling() const;

    // Get parent node

    xml_node parent() const;

    // Get root of DOM tree this node belongs to

    xml_node root() const;

    // Get text object for the current node

    xml_text text() const;

    // Get child, attribute or next/previous sibling with the specified name

    xml_node child(const char_t* name) const;

    xml_attribute attribute(const char_t* name) const;

    xml_node next_sibling(const char_t* name) const;

    xml_node previous_sibling(const char_t* name) const;

  #ifdef PUGIXML_HAS_STRING_VIEW

    xml_node child(string_view_t name) const;

    xml_attribute attribute(string_view_t name) const;

    xml_node next_sibling(string_view_t name) const;

    xml_node previous_sibling(string_view_t name) const;

  #endif

    // Get attribute, starting the search from a hint (and updating hint so that searching for a sequence of attributes is fast)

    xml_attribute attribute(const char_t* name, xml_attribute& hint) const;

  #ifdef PUGIXML_HAS_STRING_VIEW

    xml_attribute attribute(string_view_t name, xml_attribute& hint) const;

  #endif

    // Get child value of current node; that is, value of the first child node of type PCDATA/CDATA

    const char_t* child_value() const;

    // Get child value of child with specified name. Equivalent to child(name).child_value().

    const char_t* child_value(const char_t* name) const;

    // Set node name/value (returns false if node is empty, there is not enough memory, or node can not have name/value)

    bool set_name(const char_t* rhs);

    bool set_name(const char_t* rhs, size_t size);

  #ifdef PUGIXML_HAS_STRING_VIEW

    bool set_name(string_view_t rhs);

  #endif

    bool set_value(const char_t* rhs);

    bool set_value(const char_t* rhs, size_t size);

  #ifdef PUGIXML_HAS_STRING_VIEW

    bool set_value(string_view_t rhs);

  #endif

    // Add attribute with specified name. Returns added attribute, or empty attribute on errors.

    xml_attribute append_attribute(const char_t* name);

    xml_attribute prepend_attribute(const char_t* name);

    xml_attribute insert_attribute_after(const char_t* name, const xml_attribute& attr);

    xml_attribute insert_attribute_before(const char_t* name, const xml_attribute& attr);

  #ifdef PUGIXML_HAS_STRING_VIEW

    xml_attribute append_attribute(string_view_t name);

    xml_attribute prepend_attribute(string_view_t name);

    xml_attribute insert_attribute_after(string_view_t name, const xml_attribute& attr);

    xml_attribute insert_attribute_before(string_view_t name, const xml_attribute& attr);

  #endif

    // Add a copy of the specified attribute. Returns added attribute, or empty attribute on errors.

    xml_attribute append_copy(const xml_attribute& proto);

    xml_attribute prepend_copy(const xml_attribute& proto);

    xml_attribute insert_copy_after(const xml_attribute& proto, const xml_attribute& attr);

    xml_attribute insert_copy_before(const xml_attribute& proto, const xml_attribute& attr);

    // Add child node with specified type. Returns added node, or empty node on errors.

    xml_node append_child(xml_node_type type = node_element);

    xml_node prepend_child(xml_node_type type = node_element);

    xml_node insert_child_after(xml_node_type type, const xml_node& node);

    xml_node insert_child_before(xml_node_type type, const xml_node& node);

    // Add child element with specified name. Returns added node, or empty node on errors.

    xml_node append_child(const char_t* name);

    xml_node prepend_child(const char_t* name);

    xml_node insert_child_after(const char_t* name, const xml_node& node);

    xml_node insert_child_before(const char_t* name, const xml_node& node);

  #ifdef PUGIXML_HAS_STRING_VIEW

    xml_node append_child(string_view_t name);

    xml_node prepend_child(string_view_t name);

    xml_node insert_child_after(string_view_t, const xml_node& node);

    xml_node insert_child_before(string_view_t name, const xml_node& node);

  #endif

    // Add a copy of the specified node as a child. Returns added node, or empty node on errors.

    xml_node append_copy(const xml_node& proto);

    xml_node prepend_copy(const xml_node& proto);

    xml_node insert_copy_after(const xml_node& proto, const xml_node& node);

    xml_node insert_copy_before(const xml_node& proto, const xml_node& node);

    // Move the specified node to become a child of this node. Returns moved node, or empty node on errors.

    xml_node append_move(const xml_node& moved);

    xml_node prepend_move(const xml_node& moved);

    xml_node insert_move_after(const xml_node& moved, const xml_node& node);

    xml_node insert_move_before(const xml_node& moved, const xml_node& node);

    // Remove specified attribute

    bool remove_attribute(const xml_attribute& a);

    bool remove_attribute(const char_t* name);

  #ifdef PUGIXML_HAS_STRING_VIEW

    bool remove_attribute(string_view_t name);

  #endif

    // Remove all attributes

    bool remove_attributes();

    // Remove specified child

    bool remove_child(const xml_node& n);

    bool remove_child(const char_t* name);

  #ifdef PUGIXML_HAS_STRING_VIEW

    bool remove_child(string_view_t name);

  #endif

    // Remove all children

    bool remove_children();

    // Parses buffer as an XML document fragment and appends all nodes as children of the current node.

    // Copies/converts the buffer, so it may be deleted or changed after the function returns.

    // Note: append_buffer allocates memory that has the lifetime of the owning document; removing the appended nodes does not immediately reclaim that memory.

    xml_parse_result append_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);

    // Find attribute using predicate. Returns first attribute for which predicate returned true.

    template <typename Predicate> xml_attribute find_attribute(Predicate pred) const

    {

      if (!_root) return xml_attribute();

      for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())

        if (pred(attrib))

          return attrib;

      return xml_attribute();

    }

    // Find child node using predicate. Returns first child for which predicate returned true.

    template <typename Predicate> xml_node find_child(Predicate pred) const

    {

      if (!_root) return xml_node();

      for (xml_node node = first_child(); node; node = node.next_sibling())

        if (pred(node))

          return node;

      return xml_node();

    }

    // Find node from subtree using predicate. Returns first node from subtree (depth-first), for which predicate returned true.

    template <typename Predicate> xml_node find_node(Predicate pred) const

    {

      if (!_root) return xml_node();

      xml_node cur = first_child();

      while (cur._root && cur._root != _root)

      {

        if (pred(cur)) return cur;

        if (cur.first_child()) cur = cur.first_child();

        else if (cur.next_sibling()) cur = cur.next_sibling();

        else

        {

          while (!cur.next_sibling() && cur._root != _root) cur = cur.parent();

          if (cur._root != _root) cur = cur.next_sibling();

        }

      }

      return xml_node();

    }

    // Find child node by attribute name/value

    xml_node find_child_by_attribute(const char_t* name, const char_t* attr_name, const char_t* attr_value) const;

    xml_node find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const;

  #ifndef PUGIXML_NO_STL

    // Get the absolute node path from root as a text string.

    string_t path(char_t delimiter = '/') const;

  #endif

    // Search for a node by path consisting of node names and . or .. elements.

    xml_node first_element_by_path(const char_t* path, char_t delimiter = '/') const;

    // Recursively traverse subtree with xml_tree_walker

    bool traverse(xml_tree_walker& walker);

  #ifndef PUGIXML_NO_XPATH

    // Select single node by evaluating XPath query. Returns first node from the resulting node set.

    xpath_node select_node(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;

    xpath_node select_node(const xpath_query& query) const;

    // Select node set by evaluating XPath query

    xpath_node_set select_nodes(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;

    xpath_node_set select_nodes(const xpath_query& query) const;

    // (deprecated: use select_node instead) Select single node by evaluating XPath query.

    PUGIXML_DEPRECATED xpath_node select_single_node(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;

    PUGIXML_DEPRECATED xpath_node select_single_node(const xpath_query& query) const;

  #endif

    // Print subtree using a writer object

    void print(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;

  #ifndef PUGIXML_NO_STL

    // Print subtree to stream

    void print(std::basic_ostream<char>& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;

    void print(std::basic_ostream<wchar_t>& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, unsigned int depth = 0) const;

  #endif

    // Child nodes iterators

    typedef xml_node_iterator iterator;

    iterator begin() const;

    iterator end() const;

    // Attribute iterators

    typedef xml_attribute_iterator attribute_iterator;

    attribute_iterator attributes_begin() const;

    attribute_iterator attributes_end() const;

    // Range-based for support

    xml_object_range<xml_node_iterator> children() const;

    xml_object_range<xml_attribute_iterator> attributes() const;

    // Range-based for support for all children with the specified name

    // Note: name pointer must have a longer lifetime than the returned object; be careful with passing temporaries!

    xml_object_range<xml_named_node_iterator> children(const char_t* name) const;

    // Get node offset in parsed file/string (in char_t units) for debugging purposes

    ptrdiff_t offset_debug() const;

    // Get hash value (unique for handles to the same object)

    size_t hash_value() const;

    // Get internal pointer

    xml_node_struct* internal_object() const;

  };

#ifdef __BORLANDC__

  // Borland C++ workaround

  bool PUGIXML_FUNCTION operator&&(const xml_node& lhs, bool rhs);

  bool PUGIXML_FUNCTION operator||(const xml_node& lhs, bool rhs);

#endif

  // A helper for working with text inside PCDATA nodes

  class PUGIXML_CLASS xml_text

  {

    friend class xml_node;

    xml_node_struct* _root;

    typedef void (*unspecified_bool_type)(xml_text***);

    explicit xml_text(xml_node_struct* root);

    xml_node_struct* _data_new();

    xml_node_struct* _data() const;

  public:

    // Default constructor. Constructs an empty object.

    xml_text();

    // Safe bool conversion operator

    operator unspecified_bool_type() const;

    // Borland C++ workaround

    bool operator!() const;

    // Check if text object is empty (null)

    bool empty() const;

    // Get text, or "" if object is empty

    const char_t* get() const;

    // Get text, or the default value if object is empty

    const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;

    // Get text as a number, or the default value if conversion did not succeed or object is empty

    int as_int(int def = 0) const;

    unsigned int as_uint(unsigned int def = 0) const;

    double as_double(double def = 0) const;

    float as_float(float def = 0) const;

  #ifdef PUGIXML_HAS_LONG_LONG

    long long as_llong(long long def = 0) const;

    unsigned long long as_ullong(unsigned long long def = 0) const;

  #endif

    // Get text as bool (returns true if first character is in '1tTyY' set), or the default value if object is empty

    bool as_bool(bool def = false) const;

    // Set text (returns false if object is empty or there is not enough memory)

    bool set(const char_t* rhs);

    bool set(const char_t* rhs, size_t size);

  #ifdef PUGIXML_HAS_STRING_VIEW

    bool set(string_view_t rhs);

  #endif

    // Set text with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")

    bool set(int rhs);

    bool set(unsigned int rhs);

    bool set(long rhs);

    bool set(unsigned long rhs);

    bool set(double rhs);

    bool set(double rhs, int precision);

    bool set(float rhs);

    bool set(float rhs, int precision);

    bool set(bool rhs);

  #ifdef PUGIXML_HAS_LONG_LONG

    bool set(long long rhs);

    bool set(unsigned long long rhs);

  #endif

    // Set text (equivalent to set without error checking)

    xml_text& operator=(const char_t* rhs);

    xml_text& operator=(int rhs);

    xml_text& operator=(unsigned int rhs);

    xml_text& operator=(long rhs);

    xml_text& operator=(unsigned long rhs);

    xml_text& operator=(double rhs);

    xml_text& operator=(float rhs);

    xml_text& operator=(bool rhs);

  #ifdef PUGIXML_HAS_STRING_VIEW

    xml_text& operator=(string_view_t rhs);

  #endif

  #ifdef PUGIXML_HAS_LONG_LONG

    xml_text& operator=(long long rhs);

    xml_text& operator=(unsigned long long rhs);

  #endif

    // Get the data node (node_pcdata or node_cdata) for this object

    xml_node data() const;

  };

#ifdef __BORLANDC__

  // Borland C++ workaround

  bool PUGIXML_FUNCTION operator&&(const xml_text& lhs, bool rhs);

  bool PUGIXML_FUNCTION operator||(const xml_text& lhs, bool rhs);

#endif

  // Child node iterator (a bidirectional iterator over a collection of xml_node)

  class PUGIXML_CLASS xml_node_iterator

  {

    friend class xml_node;

  private:

    mutable xml_node _wrap;

    xml_node _parent;

    xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent);

  public:

    // Iterator traits

    typedef ptrdiff_t difference_type;

    typedef xml_node value_type;

    typedef xml_node* pointer;

    typedef xml_node& reference;

  #ifndef PUGIXML_NO_STL

    typedef std::bidirectional_iterator_tag iterator_category;

  #endif

    // Default constructor

    xml_node_iterator();

    // Construct an iterator which points to the specified node

    xml_node_iterator(const xml_node& node);

    // Iterator operators

    bool operator==(const xml_node_iterator& rhs) const;

    bool operator!=(const xml_node_iterator& rhs) const;

    xml_node& operator*() const;

    xml_node* operator->() const;

    xml_node_iterator& operator++();

    xml_node_iterator operator++(int);

    xml_node_iterator& operator--();

    xml_node_iterator operator--(int);

  };

  // Attribute iterator (a bidirectional iterator over a collection of xml_attribute)

  class PUGIXML_CLASS xml_attribute_iterator

  {

    friend class xml_node;

  private:

    mutable xml_attribute _wrap;

    xml_node _parent;

    xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent);

  public:

    // Iterator traits

    typedef ptrdiff_t difference_type;

    typedef xml_attribute value_type;

    typedef xml_attribute* pointer;

    typedef xml_attribute& reference;

  #ifndef PUGIXML_NO_STL

    typedef std::bidirectional_iterator_tag iterator_category;

  #endif

    // Default constructor

    xml_attribute_iterator();

    // Construct an iterator which points to the specified attribute

    xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent);

    // Iterator operators

    bool operator==(const xml_attribute_iterator& rhs) const;

    bool operator!=(const xml_attribute_iterator& rhs) const;

    xml_attribute& operator*() const;

    xml_attribute* operator->() const;

    xml_attribute_iterator& operator++();

    xml_attribute_iterator operator++(int);

    xml_attribute_iterator& operator--();

    xml_attribute_iterator operator--(int);

  };

  // Named node range helper

  class PUGIXML_CLASS xml_named_node_iterator

  {

    friend class xml_node;

  public:

    // Iterator traits

    typedef ptrdiff_t difference_type;

    typedef xml_node value_type;

    typedef xml_node* pointer;

    typedef xml_node& reference;

  #ifndef PUGIXML_NO_STL

    typedef std::bidirectional_iterator_tag iterator_category;

  #endif

    // Default constructor

    xml_named_node_iterator();

    // Construct an iterator which points to the specified node

    // Note: name pointer is stored in the iterator and must have a longer lifetime than iterator itself

    xml_named_node_iterator(const xml_node& node, const char_t* name);

    // Iterator operators

    bool operator==(const xml_named_node_iterator& rhs) const;

    bool operator!=(const xml_named_node_iterator& rhs) const;

    xml_node& operator*() const;

    xml_node* operator->() const;

    xml_named_node_iterator& operator++();

    xml_named_node_iterator operator++(int);

    xml_named_node_iterator& operator--();

    xml_named_node_iterator operator--(int);

  private:

    mutable xml_node _wrap;

    xml_node _parent;

    const char_t* _name;

    xml_named_node_iterator(xml_node_struct* ref, xml_node_struct* parent, const char_t* name);

  };

  // Abstract tree walker class (see xml_node::traverse)

  class PUGIXML_CLASS xml_tree_walker

  {

    friend class xml_node;

  private:

    int _depth;

  protected:

    // Get current traversal depth

    int depth() const;

  public:

    xml_tree_walker();

    virtual ~xml_tree_walker();

    // Callback that is called when traversal begins

    virtual bool begin(xml_node& node);

    // Callback that is called for each node traversed

    virtual bool for_each(xml_node& node) = 0;

    // Callback that is called when traversal ends

    virtual bool end(xml_node& node);

  };

  // Parsing status, returned as part of xml_parse_result object

  enum xml_parse_status

  {

    status_ok = 0,        // No error

    status_file_not_found,    // File was not found during load_file()

    status_io_error,      // Error reading from file/stream

    status_out_of_memory,   // Could not allocate memory

    status_internal_error,    // Internal error occurred

    status_unrecognized_tag,  // Parser could not determine tag type

    status_bad_pi,        // Parsing error occurred while parsing document declaration/processing instruction

    status_bad_comment,     // Parsing error occurred while parsing comment

    status_bad_cdata,     // Parsing error occurred while parsing CDATA section

    status_bad_doctype,     // Parsing error occurred while parsing document type declaration

    status_bad_pcdata,      // Parsing error occurred while parsing PCDATA section

    status_bad_start_element, // Parsing error occurred while parsing start element tag

    status_bad_attribute,   // Parsing error occurred while parsing element attribute

    status_bad_end_element,   // Parsing error occurred while parsing end element tag

    status_end_element_mismatch,// There was a mismatch of start-end tags (closing tag had incorrect name, some tag was not closed or there was an excessive closing tag)

    status_append_invalid_root, // Unable to append nodes since root type is not node_element or node_document (exclusive to xml_node::append_buffer)

    status_no_document_element  // Parsing resulted in a document without element nodes

  };

  // Parsing result

  struct PUGIXML_CLASS xml_parse_result

  {

    // Parsing status (see xml_parse_status)

    xml_parse_status status;

    // Last parsed offset (in char_t units from start of input data)

    ptrdiff_t offset;

    // Source document encoding

    xml_encoding encoding;

    // Default constructor, initializes object to failed state

    xml_parse_result();

    // Cast to bool operator

    operator bool() const;

    // Get error description

    const char* description() const;

  };

  // Document class (DOM tree root)

  class PUGIXML_CLASS xml_document: public xml_node

  {

  private:

    char_t* _buffer;

    char _memory[192];

    // Non-copyable semantics

    xml_document(const xml_document&);

    xml_document& operator=(const xml_document&);

    void _create();

    void _destroy();

    void _move(xml_document& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;

  public:

    // Default constructor, makes empty document

    xml_document();

    // Destructor, invalidates all node/attribute handles to this document

    ~xml_document();