minori: dep/pugixml/src/pugixml.hpp annotate

annotate dep/pugixml/src/pugixml.hpp @ 252:a0eeb2cc7e6d

*: resolve make distcheck failures

author	Paper <paper@paper.us.eu.org>
date	Tue, 06 Feb 2024 02:24:49 -0500
parents	a45edd073f9e
children

rev	line source
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1 /**
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	2 * pugixml parser - version 1.14
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	3 * --------------------------------------------------------
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	4 * Copyright (C) 2006-2023, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	5 * Report bugs and download new versions at https://pugixml.org/
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	6 *
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	7 * This library is distributed under the MIT License. See notice at the end
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	8 * of this file.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	9 *
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	10 * This work is based on the pugxml parser, which is:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	11 * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	12 */
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	13
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	14 // Define version macro; evaluates to major * 1000 + minor * 10 + patch so that it's safe to use in less-than comparisons
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	15 // 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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	16 #ifndef PUGIXML_VERSION
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	17 # define PUGIXML_VERSION 1140 // 1.14
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	18 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	19
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	20 // Include user configuration file (this can define various configuration macros)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	21 #include "pugiconfig.hpp"
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	22
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	23 #ifndef HEADER_PUGIXML_HPP
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	24 #define HEADER_PUGIXML_HPP
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	25
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	26 // Include stddef.h for size_t and ptrdiff_t
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	27 #include <stddef.h>
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	28
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	29 // Include exception header for XPath
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	30 #if !defined(PUGIXML_NO_XPATH) && !defined(PUGIXML_NO_EXCEPTIONS)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	31 # include <exception>
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	32 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	33
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	34 // Include STL headers
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	35 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	36 # include <iterator>
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	37 # include <iosfwd>
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	38 # include <string>
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	39 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	40
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	41 // Macro for deprecated features
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	42 #ifndef PUGIXML_DEPRECATED
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	43 # if defined(__GNUC__)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	44 # define PUGIXML_DEPRECATED __attribute__((deprecated))
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	45 # elif defined(_MSC_VER) && _MSC_VER >= 1300
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	46 # define PUGIXML_DEPRECATED __declspec(deprecated)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	47 # else
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	48 # define PUGIXML_DEPRECATED
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	49 # endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	50 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	51
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	52 // If no API is defined, assume default
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	53 #ifndef PUGIXML_API
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	54 # define PUGIXML_API
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	55 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	56
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	57 // If no API for classes is defined, assume default
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	58 #ifndef PUGIXML_CLASS
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	59 # define PUGIXML_CLASS PUGIXML_API
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	60 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	61
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	62 // If no API for functions is defined, assume default
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	63 #ifndef PUGIXML_FUNCTION
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	64 # define PUGIXML_FUNCTION PUGIXML_API
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	65 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	66
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	67 // If the platform is known to have long long support, enable long long functions
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	68 #ifndef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	69 # if __cplusplus >= 201103
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	70 # define PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	71 # elif defined(_MSC_VER) && _MSC_VER >= 1400
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	72 # define PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	73 # endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	74 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	75
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	76 // If the platform is known to have move semantics support, compile move ctor/operator implementation
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	77 #ifndef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	78 # if __cplusplus >= 201103
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	79 # define PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	80 # elif defined(_MSC_VER) && _MSC_VER >= 1600
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	81 # define PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	82 # endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	83 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	84
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	85 // If C++ is 2011 or higher, add 'noexcept' specifiers
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	86 #ifndef PUGIXML_NOEXCEPT
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	87 # if __cplusplus >= 201103
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	88 # define PUGIXML_NOEXCEPT noexcept
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	89 # elif defined(_MSC_VER) && _MSC_VER >= 1900
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	90 # define PUGIXML_NOEXCEPT noexcept
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	91 # else
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	92 # define PUGIXML_NOEXCEPT
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	93 # endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	94 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	95
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	96 // Some functions can not be noexcept in compact mode
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	97 #ifdef PUGIXML_COMPACT
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	98 # define PUGIXML_NOEXCEPT_IF_NOT_COMPACT
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	99 #else
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	100 # define PUGIXML_NOEXCEPT_IF_NOT_COMPACT PUGIXML_NOEXCEPT
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	101 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	102
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	103 // If C++ is 2011 or higher, add 'override' qualifiers
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	104 #ifndef PUGIXML_OVERRIDE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	105 # if __cplusplus >= 201103
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	106 # define PUGIXML_OVERRIDE override
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	107 # elif defined(_MSC_VER) && _MSC_VER >= 1700
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	108 # define PUGIXML_OVERRIDE override
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	109 # else
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	110 # define PUGIXML_OVERRIDE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	111 # endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	112 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	113
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	114 // If C++ is 2011 or higher, use 'nullptr'
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	115 #ifndef PUGIXML_NULL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	116 # if __cplusplus >= 201103
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	117 # define PUGIXML_NULL nullptr
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	118 # elif defined(_MSC_VER) && _MSC_VER >= 1600
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	119 # define PUGIXML_NULL nullptr
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	120 # else
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	121 # define PUGIXML_NULL 0
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	122 # endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	123 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	124
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	125 // Character interface macros
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	126 #ifdef PUGIXML_WCHAR_MODE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	127 # define PUGIXML_TEXT(t) L ## t
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	128 # define PUGIXML_CHAR wchar_t
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	129 #else
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	130 # define PUGIXML_TEXT(t) t
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	131 # define PUGIXML_CHAR char
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	132 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	133
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	134 namespace pugi
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	135 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	136 // Character type used for all internal storage and operations; depends on PUGIXML_WCHAR_MODE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	137 typedef PUGIXML_CHAR char_t;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	138
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	139 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	140 // String type used for operations that work with STL string; depends on PUGIXML_WCHAR_MODE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	141 typedef std::basic_string<PUGIXML_CHAR, std::char_traits<PUGIXML_CHAR>, std::allocator<PUGIXML_CHAR> > string_t;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	142 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	143 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	144
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	145 // The PugiXML namespace
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	146 namespace pugi
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	147 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	148 // Tree node types
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	149 enum xml_node_type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	150 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	151 node_null, // Empty (null) node handle
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	152 node_document, // A document tree's absolute root
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	153 node_element, // Element tag, i.e. '<node/>'
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	154 node_pcdata, // Plain character data, i.e. 'text'
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	155 node_cdata, // Character data, i.e. '<![CDATA[text]]>'
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	156 node_comment, // Comment tag, i.e. '<!-- text -->'
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	157 node_pi, // Processing instruction, i.e. '<?name?>'
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	158 node_declaration, // Document declaration, i.e. '<?xml version="1.0"?>'
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	159 node_doctype // Document type declaration, i.e. '<!DOCTYPE doc>'
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	160 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	161
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	162 // Parsing options
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	163
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	164 // Minimal parsing mode (equivalent to turning all other flags off).
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	165 // Only elements and PCDATA sections are added to the DOM tree, no text conversions are performed.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	166 const unsigned int parse_minimal = 0x0000;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	167
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	168 // This flag determines if processing instructions (node_pi) are added to the DOM tree. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	169 const unsigned int parse_pi = 0x0001;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	170
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	171 // This flag determines if comments (node_comment) are added to the DOM tree. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	172 const unsigned int parse_comments = 0x0002;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	173
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	174 // This flag determines if CDATA sections (node_cdata) are added to the DOM tree. This flag is on by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	175 const unsigned int parse_cdata = 0x0004;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	176
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	177 // This flag determines if plain character data (node_pcdata) that consist only of whitespace are added to the DOM tree.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	178 // This flag is off by default; turning it on usually results in slower parsing and more memory consumption.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	179 const unsigned int parse_ws_pcdata = 0x0008;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	180
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	181 // This flag determines if character and entity references are expanded during parsing. This flag is on by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	182 const unsigned int parse_escapes = 0x0010;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	183
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	184 // This flag determines if EOL characters are normalized (converted to #xA) during parsing. This flag is on by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	185 const unsigned int parse_eol = 0x0020;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	186
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	187 // This flag determines if attribute values are normalized using CDATA normalization rules during parsing. This flag is on by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	188 const unsigned int parse_wconv_attribute = 0x0040;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	189
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	190 // This flag determines if attribute values are normalized using NMTOKENS normalization rules during parsing. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	191 const unsigned int parse_wnorm_attribute = 0x0080;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	192
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	193 // This flag determines if document declaration (node_declaration) is added to the DOM tree. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	194 const unsigned int parse_declaration = 0x0100;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	195
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	196 // This flag determines if document type declaration (node_doctype) is added to the DOM tree. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	197 const unsigned int parse_doctype = 0x0200;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	198
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	199 // This flag determines if plain character data (node_pcdata) that is the only child of the parent node and that consists only
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	200 // of whitespace is added to the DOM tree.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	201 // This flag is off by default; turning it on may result in slower parsing and more memory consumption.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	202 const unsigned int parse_ws_pcdata_single = 0x0400;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	203
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	204 // This flag determines if leading and trailing whitespace is to be removed from plain character data. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	205 const unsigned int parse_trim_pcdata = 0x0800;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	206
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	207 // 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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	208 // is a valid document. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	209 const unsigned int parse_fragment = 0x1000;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	210
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	211 // This flag determines if plain character data is be stored in the parent element's value. This significantly changes the structure of
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	212 // the document; this flag is only recommended for parsing documents with many PCDATA nodes in memory-constrained environments.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	213 // This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	214 const unsigned int parse_embed_pcdata = 0x2000;
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	215
a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	216 // This flag determines whether determines whether the the two pcdata should be merged or not, if no intermediatory data are parsed in the document.
a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	217 // This flag is off by default.
a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	218 const unsigned int parse_merge_pcdata = 0x4000;
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	219
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	220 // The default parsing mode.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	221 // Elements, PCDATA and CDATA sections are added to the DOM tree, character/reference entities are expanded,
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	222 // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	223 const unsigned int parse_default = parse_cdata \| parse_escapes \| parse_wconv_attribute \| parse_eol;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	224
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	225 // The full parsing mode.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	226 // Nodes of all types are added to the DOM tree, character/reference entities are expanded,
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	227 // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	228 const unsigned int parse_full = parse_default \| parse_pi \| parse_comments \| parse_declaration \| parse_doctype;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	229
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	230 // These flags determine the encoding of input data for XML document
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	231 enum xml_encoding
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	232 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	233 encoding_auto, // Auto-detect input encoding using BOM or < / <? detection; use UTF8 if BOM is not found
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	234 encoding_utf8, // UTF8 encoding
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	235 encoding_utf16_le, // Little-endian UTF16
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	236 encoding_utf16_be, // Big-endian UTF16
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	237 encoding_utf16, // UTF16 with native endianness
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	238 encoding_utf32_le, // Little-endian UTF32
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	239 encoding_utf32_be, // Big-endian UTF32
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	240 encoding_utf32, // UTF32 with native endianness
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	241 encoding_wchar, // The same encoding wchar_t has (either UTF16 or UTF32)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	242 encoding_latin1
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	243 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	244
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	245 // Formatting flags
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	246
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	247 // 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.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	248 const unsigned int format_indent = 0x01;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	249
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	250 // Write encoding-specific BOM to the output stream. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	251 const unsigned int format_write_bom = 0x02;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	252
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	253 // Use raw output mode (no indentation and no line breaks are written). This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	254 const unsigned int format_raw = 0x04;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	255
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	256 // Omit default XML declaration even if there is no declaration in the document. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	257 const unsigned int format_no_declaration = 0x08;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	258
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	259 // Don't escape attribute values and PCDATA contents. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	260 const unsigned int format_no_escapes = 0x10;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	261
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	262 // 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.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	263 const unsigned int format_save_file_text = 0x20;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	264
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	265 // Write every attribute on a new line with appropriate indentation. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	266 const unsigned int format_indent_attributes = 0x40;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	267
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	268 // 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.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	269 const unsigned int format_no_empty_element_tags = 0x80;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	270
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	271 // Skip characters belonging to range [0; 32) instead of "&#xNN;" encoding. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	272 const unsigned int format_skip_control_chars = 0x100;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	273
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	274 // Use single quotes ' instead of double quotes " for enclosing attribute values. This flag is off by default.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	275 const unsigned int format_attribute_single_quote = 0x200;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	276
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	277 // The default set of formatting flags.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	278 // Nodes are indented depending on their depth in DOM tree, a default declaration is output if document has none.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	279 const unsigned int format_default = format_indent;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	280
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	281 const int default_double_precision = 17;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	282 const int default_float_precision = 9;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	283
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	284 // Forward declarations
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	285 struct xml_attribute_struct;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	286 struct xml_node_struct;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	287
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	288 class xml_node_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	289 class xml_attribute_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	290 class xml_named_node_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	291
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	292 class xml_tree_walker;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	293
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	294 struct xml_parse_result;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	295
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	296 class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	297
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	298 class xml_text;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	299
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	300 #ifndef PUGIXML_NO_XPATH
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	301 class xpath_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	302 class xpath_node_set;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	303 class xpath_query;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	304 class xpath_variable_set;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	305 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	306
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	307 // Range-based for loop support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	308 template <typename It> class xml_object_range
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	309 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	310 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	311 typedef It const_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	312 typedef It iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	313
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	314 xml_object_range(It b, It e): _begin(b), _end(e)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	315 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	316 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	317
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	318 It begin() const { return _begin; }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	319 It end() const { return _end; }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	320
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	321 bool empty() const { return _begin == _end; }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	322
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	323 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	324 It _begin, _end;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	325 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	326
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	327 // Writer interface for node printing (see xml_node::print)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	328 class PUGIXML_CLASS xml_writer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	329 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	330 public:
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	331 virtual ~xml_writer();
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	332
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	333 // Write memory chunk into stream/file/whatever
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	334 virtual void write(const void* data, size_t size) = 0;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	335 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	336
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	337 // xml_writer implementation for FILE*
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	338 class PUGIXML_CLASS xml_writer_file: public xml_writer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	339 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	340 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	341 // Construct writer from a FILE* object; void* is used to avoid header dependencies on stdio
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	342 xml_writer_file(void* file);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	343
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	344 virtual void write(const void* data, size_t size) PUGIXML_OVERRIDE;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	345
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	346 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	347 void* file;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	348 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	349
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	350 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	351 // xml_writer implementation for streams
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	352 class PUGIXML_CLASS xml_writer_stream: public xml_writer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	353 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	354 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	355 // Construct writer from an output stream object
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	356 xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	357 xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	358
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	359 virtual void write(const void* data, size_t size) PUGIXML_OVERRIDE;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	360
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	361 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	362 std::basic_ostream<char, std::char_traits<char> >* narrow_stream;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	363 std::basic_ostream<wchar_t, std::char_traits<wchar_t> >* wide_stream;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	364 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	365 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	366
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	367 // A light-weight handle for manipulating attributes in DOM tree
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	368 class PUGIXML_CLASS xml_attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	369 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	370 friend class xml_attribute_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	371 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	372
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	373 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	374 xml_attribute_struct* _attr;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	375
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	376 typedef void (unspecified_bool_type)(xml_attribute**);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	377
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	378 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	379 // Default constructor. Constructs an empty attribute.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	380 xml_attribute();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	381
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	382 // Constructs attribute from internal pointer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	383 explicit xml_attribute(xml_attribute_struct* attr);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	384
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	385 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	386 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	387
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	388 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	389 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	390
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	391 // Comparison operators (compares wrapped attribute pointers)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	392 bool operator==(const xml_attribute& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	393 bool operator!=(const xml_attribute& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	394 bool operator<(const xml_attribute& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	395 bool operator>(const xml_attribute& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	396 bool operator<=(const xml_attribute& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	397 bool operator>=(const xml_attribute& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	398
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	399 // Check if attribute is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	400 bool empty() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	401
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	402 // Get attribute name/value, or "" if attribute is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	403 const char_t* name() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	404 const char_t* value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	405
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	406 // Get attribute value, or the default value if attribute is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	407 const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	408
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	409 // Get attribute value as a number, or the default value if conversion did not succeed or attribute is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	410 int as_int(int def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	411 unsigned int as_uint(unsigned int def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	412 double as_double(double def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	413 float as_float(float def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	414
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	415 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	416 long long as_llong(long long def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	417 unsigned long long as_ullong(unsigned long long def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	418 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	419
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	420 // Get attribute value as bool (returns true if first character is in '1tTyY' set), or the default value if attribute is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	421 bool as_bool(bool def = false) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	422
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	423 // Set attribute name/value (returns false if attribute is empty or there is not enough memory)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	424 bool set_name(const char_t* rhs);
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	425 bool set_name(const char_t* rhs, size_t size);
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	426 bool set_value(const char_t* rhs);
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	427 bool set_value(const char_t* rhs, size_t size);
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	428
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	429 // Set attribute value with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	430 bool set_value(int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	431 bool set_value(unsigned int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	432 bool set_value(long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	433 bool set_value(unsigned long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	434 bool set_value(double rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	435 bool set_value(double rhs, int precision);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	436 bool set_value(float rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	437 bool set_value(float rhs, int precision);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	438 bool set_value(bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	439
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	440 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	441 bool set_value(long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	442 bool set_value(unsigned long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	443 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	444
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	445 // Set attribute value (equivalent to set_value without error checking)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	446 xml_attribute& operator=(const char_t* rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	447 xml_attribute& operator=(int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	448 xml_attribute& operator=(unsigned int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	449 xml_attribute& operator=(long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	450 xml_attribute& operator=(unsigned long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	451 xml_attribute& operator=(double rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	452 xml_attribute& operator=(float rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	453 xml_attribute& operator=(bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	454
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	455 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	456 xml_attribute& operator=(long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	457 xml_attribute& operator=(unsigned long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	458 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	459
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	460 // Get next/previous attribute in the attribute list of the parent node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	461 xml_attribute next_attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	462 xml_attribute previous_attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	463
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	464 // Get hash value (unique for handles to the same object)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	465 size_t hash_value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	466
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	467 // Get internal pointer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	468 xml_attribute_struct* internal_object() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	469 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	470
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	471 #ifdef __BORLANDC__
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	472 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	473 bool PUGIXML_FUNCTION operator&&(const xml_attribute& lhs, bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	474 bool PUGIXML_FUNCTION operator\|\|(const xml_attribute& lhs, bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	475 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	476
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	477 // A light-weight handle for manipulating nodes in DOM tree
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	478 class PUGIXML_CLASS xml_node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	479 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	480 friend class xml_attribute_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	481 friend class xml_node_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	482 friend class xml_named_node_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	483
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	484 protected:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	485 xml_node_struct* _root;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	486
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	487 typedef void (unspecified_bool_type)(xml_node**);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	488
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	489 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	490 // Default constructor. Constructs an empty node.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	491 xml_node();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	492
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	493 // Constructs node from internal pointer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	494 explicit xml_node(xml_node_struct* p);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	495
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	496 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	497 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	498
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	499 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	500 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	501
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	502 // Comparison operators (compares wrapped node pointers)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	503 bool operator==(const xml_node& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	504 bool operator!=(const xml_node& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	505 bool operator<(const xml_node& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	506 bool operator>(const xml_node& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	507 bool operator<=(const xml_node& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	508 bool operator>=(const xml_node& r) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	509
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	510 // Check if node is empty.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	511 bool empty() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	512
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	513 // Get node type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	514 xml_node_type type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	515
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	516 // Get node name, or "" if node is empty or it has no name
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	517 const char_t* name() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	518
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	519 // Get node value, or "" if node is empty or it has no value
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	520 // Note: For <node>text</node> node.value() does not return "text"! Use child_value() or text() methods to access text inside nodes.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	521 const char_t* value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	522
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	523 // Get attribute list
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	524 xml_attribute first_attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	525 xml_attribute last_attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	526
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	527 // Get children list
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	528 xml_node first_child() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	529 xml_node last_child() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	530
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	531 // Get next/previous sibling in the children list of the parent node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	532 xml_node next_sibling() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	533 xml_node previous_sibling() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	534
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	535 // Get parent node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	536 xml_node parent() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	537
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	538 // Get root of DOM tree this node belongs to
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	539 xml_node root() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	540
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	541 // Get text object for the current node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	542 xml_text text() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	543
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	544 // Get child, attribute or next/previous sibling with the specified name
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	545 xml_node child(const char_t* name) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	546 xml_attribute attribute(const char_t* name) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	547 xml_node next_sibling(const char_t* name) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	548 xml_node previous_sibling(const char_t* name) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	549
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	550 // Get attribute, starting the search from a hint (and updating hint so that searching for a sequence of attributes is fast)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	551 xml_attribute attribute(const char_t* name, xml_attribute& hint) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	552
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	553 // Get child value of current node; that is, value of the first child node of type PCDATA/CDATA
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	554 const char_t* child_value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	555
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	556 // Get child value of child with specified name. Equivalent to child(name).child_value().
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	557 const char_t* child_value(const char_t* name) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	558
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	559 // Set node name/value (returns false if node is empty, there is not enough memory, or node can not have name/value)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	560 bool set_name(const char_t* rhs);
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	561 bool set_name(const char_t* rhs, size_t size);
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	562 bool set_value(const char_t* rhs);
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	563 bool set_value(const char_t* rhs, size_t size);
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	564
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	565 // Add attribute with specified name. Returns added attribute, or empty attribute on errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	566 xml_attribute append_attribute(const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	567 xml_attribute prepend_attribute(const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	568 xml_attribute insert_attribute_after(const char_t* name, const xml_attribute& attr);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	569 xml_attribute insert_attribute_before(const char_t* name, const xml_attribute& attr);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	570
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	571 // Add a copy of the specified attribute. Returns added attribute, or empty attribute on errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	572 xml_attribute append_copy(const xml_attribute& proto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	573 xml_attribute prepend_copy(const xml_attribute& proto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	574 xml_attribute insert_copy_after(const xml_attribute& proto, const xml_attribute& attr);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	575 xml_attribute insert_copy_before(const xml_attribute& proto, const xml_attribute& attr);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	576
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	577 // Add child node with specified type. Returns added node, or empty node on errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	578 xml_node append_child(xml_node_type type = node_element);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	579 xml_node prepend_child(xml_node_type type = node_element);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	580 xml_node insert_child_after(xml_node_type type, const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	581 xml_node insert_child_before(xml_node_type type, const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	582
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	583 // Add child element with specified name. Returns added node, or empty node on errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	584 xml_node append_child(const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	585 xml_node prepend_child(const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	586 xml_node insert_child_after(const char_t* name, const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	587 xml_node insert_child_before(const char_t* name, const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	588
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	589 // Add a copy of the specified node as a child. Returns added node, or empty node on errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	590 xml_node append_copy(const xml_node& proto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	591 xml_node prepend_copy(const xml_node& proto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	592 xml_node insert_copy_after(const xml_node& proto, const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	593 xml_node insert_copy_before(const xml_node& proto, const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	594
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	595 // Move the specified node to become a child of this node. Returns moved node, or empty node on errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	596 xml_node append_move(const xml_node& moved);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	597 xml_node prepend_move(const xml_node& moved);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	598 xml_node insert_move_after(const xml_node& moved, const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	599 xml_node insert_move_before(const xml_node& moved, const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	600
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	601 // Remove specified attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	602 bool remove_attribute(const xml_attribute& a);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	603 bool remove_attribute(const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	604
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	605 // Remove all attributes
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	606 bool remove_attributes();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	607
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	608 // Remove specified child
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	609 bool remove_child(const xml_node& n);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	610 bool remove_child(const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	611
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	612 // Remove all children
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	613 bool remove_children();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	614
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	615 // Parses buffer as an XML document fragment and appends all nodes as children of the current node.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	616 // Copies/converts the buffer, so it may be deleted or changed after the function returns.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	617 // Note: append_buffer allocates memory that has the lifetime of the owning document; removing the appended nodes does not immediately reclaim that memory.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	618 xml_parse_result append_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	619
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	620 // Find attribute using predicate. Returns first attribute for which predicate returned true.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	621 template <typename Predicate> xml_attribute find_attribute(Predicate pred) const
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	622 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	623 if (!_root) return xml_attribute();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	624
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	625 for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	626 if (pred(attrib))
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	627 return attrib;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	628
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	629 return xml_attribute();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	630 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	631
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	632 // Find child node using predicate. Returns first child for which predicate returned true.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	633 template <typename Predicate> xml_node find_child(Predicate pred) const
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	634 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	635 if (!_root) return xml_node();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	636
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	637 for (xml_node node = first_child(); node; node = node.next_sibling())
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	638 if (pred(node))
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	639 return node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	640
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	641 return xml_node();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	642 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	643
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	644 // Find node from subtree using predicate. Returns first node from subtree (depth-first), for which predicate returned true.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	645 template <typename Predicate> xml_node find_node(Predicate pred) const
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	646 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	647 if (!_root) return xml_node();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	648
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	649 xml_node cur = first_child();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	650
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	651 while (cur._root && cur._root != _root)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	652 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	653 if (pred(cur)) return cur;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	654
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	655 if (cur.first_child()) cur = cur.first_child();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	656 else if (cur.next_sibling()) cur = cur.next_sibling();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	657 else
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	658 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	659 while (!cur.next_sibling() && cur._root != _root) cur = cur.parent();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	660
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	661 if (cur._root != _root) cur = cur.next_sibling();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	662 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	663 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	664
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	665 return xml_node();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	666 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	667
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	668 // Find child node by attribute name/value
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	669 xml_node find_child_by_attribute(const char_t* name, const char_t* attr_name, const char_t* attr_value) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	670 xml_node find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	671
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	672 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	673 // Get the absolute node path from root as a text string.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	674 string_t path(char_t delimiter = '/') const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	675 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	676
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	677 // Search for a node by path consisting of node names and . or .. elements.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	678 xml_node first_element_by_path(const char_t* path, char_t delimiter = '/') const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	679
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	680 // Recursively traverse subtree with xml_tree_walker
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	681 bool traverse(xml_tree_walker& walker);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	682
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	683 #ifndef PUGIXML_NO_XPATH
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	684 // Select single node by evaluating XPath query. Returns first node from the resulting node set.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	685 xpath_node select_node(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	686 xpath_node select_node(const xpath_query& query) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	687
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	688 // Select node set by evaluating XPath query
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	689 xpath_node_set select_nodes(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	690 xpath_node_set select_nodes(const xpath_query& query) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	691
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	692 // (deprecated: use select_node instead) Select single node by evaluating XPath query.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	693 PUGIXML_DEPRECATED xpath_node select_single_node(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	694 PUGIXML_DEPRECATED xpath_node select_single_node(const xpath_query& query) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	695
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	696 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	697
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	698 // Print subtree using a writer object
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	699 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;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	700
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	701 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	702 // Print subtree to stream
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	703 void print(std::basic_ostream<char, std::char_traits<char> >& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	704 void print(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, unsigned int depth = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	705 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	706
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	707 // Child nodes iterators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	708 typedef xml_node_iterator iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	709
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	710 iterator begin() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	711 iterator end() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	712
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	713 // Attribute iterators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	714 typedef xml_attribute_iterator attribute_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	715
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	716 attribute_iterator attributes_begin() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	717 attribute_iterator attributes_end() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	718
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	719 // Range-based for support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	720 xml_object_range<xml_node_iterator> children() const;
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	721 xml_object_range<xml_attribute_iterator> attributes() const;
a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	722
a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	723 // Range-based for support for all children with the specified name
a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	724 // Note: name pointer must have a longer lifetime than the returned object; be careful with passing temporaries!
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	725 xml_object_range<xml_named_node_iterator> children(const char_t* name) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	726
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	727 // Get node offset in parsed file/string (in char_t units) for debugging purposes
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	728 ptrdiff_t offset_debug() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	729
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	730 // Get hash value (unique for handles to the same object)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	731 size_t hash_value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	732
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	733 // Get internal pointer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	734 xml_node_struct* internal_object() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	735 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	736
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	737 #ifdef __BORLANDC__
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	738 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	739 bool PUGIXML_FUNCTION operator&&(const xml_node& lhs, bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	740 bool PUGIXML_FUNCTION operator\|\|(const xml_node& lhs, bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	741 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	742
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	743 // A helper for working with text inside PCDATA nodes
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	744 class PUGIXML_CLASS xml_text
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	745 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	746 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	747
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	748 xml_node_struct* _root;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	749
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	750 typedef void (unspecified_bool_type)(xml_text**);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	751
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	752 explicit xml_text(xml_node_struct* root);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	753
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	754 xml_node_struct* _data_new();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	755 xml_node_struct* _data() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	756
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	757 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	758 // Default constructor. Constructs an empty object.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	759 xml_text();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	760
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	761 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	762 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	763
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	764 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	765 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	766
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	767 // Check if text object is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	768 bool empty() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	769
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	770 // Get text, or "" if object is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	771 const char_t* get() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	772
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	773 // Get text, or the default value if object is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	774 const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	775
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	776 // Get text as a number, or the default value if conversion did not succeed or object is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	777 int as_int(int def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	778 unsigned int as_uint(unsigned int def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	779 double as_double(double def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	780 float as_float(float def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	781
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	782 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	783 long long as_llong(long long def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	784 unsigned long long as_ullong(unsigned long long def = 0) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	785 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	786
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	787 // Get text as bool (returns true if first character is in '1tTyY' set), or the default value if object is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	788 bool as_bool(bool def = false) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	789
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	790 // Set text (returns false if object is empty or there is not enough memory)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	791 bool set(const char_t* rhs);
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	792 bool set(const char_t* rhs, size_t size);
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	793
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	794 // Set text with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	795 bool set(int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	796 bool set(unsigned int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	797 bool set(long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	798 bool set(unsigned long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	799 bool set(double rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	800 bool set(double rhs, int precision);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	801 bool set(float rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	802 bool set(float rhs, int precision);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	803 bool set(bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	804
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	805 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	806 bool set(long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	807 bool set(unsigned long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	808 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	809
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	810 // Set text (equivalent to set without error checking)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	811 xml_text& operator=(const char_t* rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	812 xml_text& operator=(int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	813 xml_text& operator=(unsigned int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	814 xml_text& operator=(long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	815 xml_text& operator=(unsigned long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	816 xml_text& operator=(double rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	817 xml_text& operator=(float rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	818 xml_text& operator=(bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	819
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	820 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	821 xml_text& operator=(long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	822 xml_text& operator=(unsigned long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	823 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	824
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	825 // Get the data node (node_pcdata or node_cdata) for this object
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	826 xml_node data() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	827 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	828
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	829 #ifdef __BORLANDC__
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	830 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	831 bool PUGIXML_FUNCTION operator&&(const xml_text& lhs, bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	832 bool PUGIXML_FUNCTION operator\|\|(const xml_text& lhs, bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	833 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	834
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	835 // Child node iterator (a bidirectional iterator over a collection of xml_node)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	836 class PUGIXML_CLASS xml_node_iterator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	837 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	838 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	839
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	840 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	841 mutable xml_node _wrap;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	842 xml_node _parent;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	843
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	844 xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	845
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	846 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	847 // Iterator traits
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	848 typedef ptrdiff_t difference_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	849 typedef xml_node value_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	850 typedef xml_node* pointer;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	851 typedef xml_node& reference;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	852
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	853 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	854 typedef std::bidirectional_iterator_tag iterator_category;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	855 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	856
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	857 // Default constructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	858 xml_node_iterator();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	859
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	860 // Construct an iterator which points to the specified node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	861 xml_node_iterator(const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	862
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	863 // Iterator operators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	864 bool operator==(const xml_node_iterator& rhs) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	865 bool operator!=(const xml_node_iterator& rhs) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	866
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	867 xml_node& operator*() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	868 xml_node* operator->() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	869
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	870 xml_node_iterator& operator++();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	871 xml_node_iterator operator++(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	872
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	873 xml_node_iterator& operator--();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	874 xml_node_iterator operator--(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	875 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	876
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	877 // Attribute iterator (a bidirectional iterator over a collection of xml_attribute)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	878 class PUGIXML_CLASS xml_attribute_iterator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	879 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	880 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	881
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	882 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	883 mutable xml_attribute _wrap;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	884 xml_node _parent;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	885
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	886 xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	887
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	888 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	889 // Iterator traits
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	890 typedef ptrdiff_t difference_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	891 typedef xml_attribute value_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	892 typedef xml_attribute* pointer;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	893 typedef xml_attribute& reference;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	894
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	895 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	896 typedef std::bidirectional_iterator_tag iterator_category;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	897 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	898
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	899 // Default constructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	900 xml_attribute_iterator();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	901
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	902 // Construct an iterator which points to the specified attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	903 xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	904
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	905 // Iterator operators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	906 bool operator==(const xml_attribute_iterator& rhs) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	907 bool operator!=(const xml_attribute_iterator& rhs) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	908
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	909 xml_attribute& operator*() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	910 xml_attribute* operator->() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	911
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	912 xml_attribute_iterator& operator++();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	913 xml_attribute_iterator operator++(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	914
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	915 xml_attribute_iterator& operator--();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	916 xml_attribute_iterator operator--(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	917 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	918
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	919 // Named node range helper
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	920 class PUGIXML_CLASS xml_named_node_iterator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	921 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	922 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	923
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	924 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	925 // Iterator traits
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	926 typedef ptrdiff_t difference_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	927 typedef xml_node value_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	928 typedef xml_node* pointer;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	929 typedef xml_node& reference;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	930
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	931 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	932 typedef std::bidirectional_iterator_tag iterator_category;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	933 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	934
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	935 // Default constructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	936 xml_named_node_iterator();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	937
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	938 // Construct an iterator which points to the specified node
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	939 // Note: name pointer is stored in the iterator and must have a longer lifetime than iterator itself
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	940 xml_named_node_iterator(const xml_node& node, const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	941
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	942 // Iterator operators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	943 bool operator==(const xml_named_node_iterator& rhs) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	944 bool operator!=(const xml_named_node_iterator& rhs) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	945
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	946 xml_node& operator*() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	947 xml_node* operator->() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	948
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	949 xml_named_node_iterator& operator++();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	950 xml_named_node_iterator operator++(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	951
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	952 xml_named_node_iterator& operator--();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	953 xml_named_node_iterator operator--(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	954
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	955 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	956 mutable xml_node _wrap;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	957 xml_node _parent;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	958 const char_t* _name;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	959
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	960 xml_named_node_iterator(xml_node_struct* ref, xml_node_struct* parent, const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	961 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	962
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	963 // Abstract tree walker class (see xml_node::traverse)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	964 class PUGIXML_CLASS xml_tree_walker
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	965 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	966 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	967
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	968 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	969 int _depth;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	970
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	971 protected:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	972 // Get current traversal depth
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	973 int depth() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	974
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	975 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	976 xml_tree_walker();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	977 virtual ~xml_tree_walker();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	978
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	979 // Callback that is called when traversal begins
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	980 virtual bool begin(xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	981
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	982 // Callback that is called for each node traversed
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	983 virtual bool for_each(xml_node& node) = 0;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	984
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	985 // Callback that is called when traversal ends
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	986 virtual bool end(xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	987 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	988
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	989 // Parsing status, returned as part of xml_parse_result object
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	990 enum xml_parse_status
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	991 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	992 status_ok = 0, // No error
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	993
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	994 status_file_not_found, // File was not found during load_file()
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	995 status_io_error, // Error reading from file/stream
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	996 status_out_of_memory, // Could not allocate memory
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	997 status_internal_error, // Internal error occurred
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	998
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	999 status_unrecognized_tag, // Parser could not determine tag type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1000
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1001 status_bad_pi, // Parsing error occurred while parsing document declaration/processing instruction
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1002 status_bad_comment, // Parsing error occurred while parsing comment
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1003 status_bad_cdata, // Parsing error occurred while parsing CDATA section
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1004 status_bad_doctype, // Parsing error occurred while parsing document type declaration
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1005 status_bad_pcdata, // Parsing error occurred while parsing PCDATA section
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1006 status_bad_start_element, // Parsing error occurred while parsing start element tag
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1007 status_bad_attribute, // Parsing error occurred while parsing element attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1008 status_bad_end_element, // Parsing error occurred while parsing end element tag
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1009 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)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1010
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1011 status_append_invalid_root, // Unable to append nodes since root type is not node_element or node_document (exclusive to xml_node::append_buffer)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1012
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1013 status_no_document_element // Parsing resulted in a document without element nodes
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1014 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1015
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1016 // Parsing result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1017 struct PUGIXML_CLASS xml_parse_result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1018 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1019 // Parsing status (see xml_parse_status)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1020 xml_parse_status status;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1021
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1022 // Last parsed offset (in char_t units from start of input data)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1023 ptrdiff_t offset;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1024
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1025 // Source document encoding
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1026 xml_encoding encoding;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1027
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1028 // Default constructor, initializes object to failed state
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1029 xml_parse_result();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1030
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1031 // Cast to bool operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1032 operator bool() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1033
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1034 // Get error description
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1035 const char* description() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1036 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1037
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1038 // Document class (DOM tree root)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1039 class PUGIXML_CLASS xml_document: public xml_node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1040 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1041 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1042 char_t* _buffer;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1043
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1044 char _memory[192];
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1045
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1046 // Non-copyable semantics
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1047 xml_document(const xml_document&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1048 xml_document& operator=(const xml_document&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1049
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1050 void _create();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1051 void _destroy();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1052 void _move(xml_document& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1053
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1054 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1055 // Default constructor, makes empty document
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1056 xml_document();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1057
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1058 // Destructor, invalidates all node/attribute handles to this document
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1059 ~xml_document();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1060
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1061 #ifdef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1062 // Move semantics support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1063 xml_document(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1064 xml_document& operator=(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1065 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1066
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1067 // Removes all nodes, leaving the empty document
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1068 void reset();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1069
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1070 // Removes all nodes, then copies the entire contents of the specified document
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1071 void reset(const xml_document& proto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1072
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1073 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1074 // Load document from stream.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1075 xml_parse_result load(std::basic_istream<char, std::char_traits<char> >& stream, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1076 xml_parse_result load(std::basic_istream<wchar_t, std::char_traits<wchar_t> >& stream, unsigned int options = parse_default);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1077 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1078
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1079 // (deprecated: use load_string instead) Load document from zero-terminated string. No encoding conversions are applied.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1080 PUGIXML_DEPRECATED xml_parse_result load(const char_t* contents, unsigned int options = parse_default);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1081
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1082 // Load document from zero-terminated string. No encoding conversions are applied.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1083 xml_parse_result load_string(const char_t* contents, unsigned int options = parse_default);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1084
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1085 // Load document from file
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1086 xml_parse_result load_file(const char* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1087 xml_parse_result load_file(const wchar_t* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1088
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1089 // Load document from buffer. Copies/converts the buffer, so it may be deleted or changed after the function returns.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1090 xml_parse_result load_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1091
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1092 // Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1093 // You should ensure that buffer data will persist throughout the document's lifetime, and free the buffer memory manually once document is destroyed.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1094 xml_parse_result load_buffer_inplace(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1095
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1096 // Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1097 // You should allocate the buffer with pugixml allocation function; document will free the buffer when it is no longer needed (you can't use it anymore).
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1098 xml_parse_result load_buffer_inplace_own(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1099
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1100 // Save XML document to writer (semantics is slightly different from xml_node::print, see documentation for details).
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1101 void save(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1102
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1103 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1104 // Save XML document to stream (semantics is slightly different from xml_node::print, see documentation for details).
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1105 void save(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1106 void save(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1107 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1108
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1109 // Save XML to file
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1110 bool save_file(const char* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1111 bool save_file(const wchar_t* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1112
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1113 // Get document element
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1114 xml_node document_element() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1115 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1116
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1117 #ifndef PUGIXML_NO_XPATH
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1118 // XPath query return type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1119 enum xpath_value_type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1120 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1121 xpath_type_none, // Unknown type (query failed to compile)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1122 xpath_type_node_set, // Node set (xpath_node_set)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1123 xpath_type_number, // Number
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1124 xpath_type_string, // String
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1125 xpath_type_boolean // Boolean
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1126 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1127
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1128 // XPath parsing result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1129 struct PUGIXML_CLASS xpath_parse_result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1130 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1131 // Error message (0 if no error)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1132 const char* error;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1133
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1134 // Last parsed offset (in char_t units from string start)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1135 ptrdiff_t offset;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1136
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1137 // Default constructor, initializes object to failed state
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1138 xpath_parse_result();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1139
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1140 // Cast to bool operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1141 operator bool() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1142
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1143 // Get error description
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1144 const char* description() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1145 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1146
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1147 // A single XPath variable
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1148 class PUGIXML_CLASS xpath_variable
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1149 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1150 friend class xpath_variable_set;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1151
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1152 protected:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1153 xpath_value_type _type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1154 xpath_variable* _next;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1155
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1156 xpath_variable(xpath_value_type type);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1157
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1158 // Non-copyable semantics
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1159 xpath_variable(const xpath_variable&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1160 xpath_variable& operator=(const xpath_variable&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1161
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1162 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1163 // Get variable name
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1164 const char_t* name() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1165
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1166 // Get variable type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1167 xpath_value_type type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1168
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1169 // Get variable value; no type conversion is performed, default value (false, NaN, empty string, empty node set) is returned on type mismatch error
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1170 bool get_boolean() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1171 double get_number() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1172 const char_t* get_string() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1173 const xpath_node_set& get_node_set() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1174
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1175 // Set variable value; no type conversion is performed, false is returned on type mismatch error
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1176 bool set(bool value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1177 bool set(double value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1178 bool set(const char_t* value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1179 bool set(const xpath_node_set& value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1180 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1181
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1182 // A set of XPath variables
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1183 class PUGIXML_CLASS xpath_variable_set
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1184 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1185 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1186 xpath_variable* _data[64];
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1187
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1188 void _assign(const xpath_variable_set& rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1189 void _swap(xpath_variable_set& rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1190
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1191 xpath_variable* _find(const char_t* name) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1192
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1193 static bool _clone(xpath_variable* var, xpath_variable** out_result);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1194 static void _destroy(xpath_variable* var);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1195
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1196 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1197 // Default constructor/destructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1198 xpath_variable_set();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1199 ~xpath_variable_set();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1200
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1201 // Copy constructor/assignment operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1202 xpath_variable_set(const xpath_variable_set& rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1203 xpath_variable_set& operator=(const xpath_variable_set& rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1204
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1205 #ifdef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1206 // Move semantics support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1207 xpath_variable_set(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1208 xpath_variable_set& operator=(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1209 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1210
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1211 // Add a new variable or get the existing one, if the types match
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1212 xpath_variable* add(const char_t* name, xpath_value_type type);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1213
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1214 // Set value of an existing variable; no type conversion is performed, false is returned if there is no such variable or if types mismatch
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1215 bool set(const char_t* name, bool value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1216 bool set(const char_t* name, double value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1217 bool set(const char_t* name, const char_t* value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1218 bool set(const char_t* name, const xpath_node_set& value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1219
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1220 // Get existing variable by name
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1221 xpath_variable* get(const char_t* name);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1222 const xpath_variable* get(const char_t* name) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1223 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1224
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1225 // A compiled XPath query object
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1226 class PUGIXML_CLASS xpath_query
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1227 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1228 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1229 void* _impl;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1230 xpath_parse_result _result;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1231
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1232 typedef void (unspecified_bool_type)(xpath_query**);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1233
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1234 // Non-copyable semantics
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1235 xpath_query(const xpath_query&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1236 xpath_query& operator=(const xpath_query&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1237
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1238 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1239 // Construct a compiled object from XPath expression.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1240 // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on compilation errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1241 explicit xpath_query(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1242
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1243 // Constructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1244 xpath_query();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1245
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1246 // Destructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1247 ~xpath_query();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1248
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1249 #ifdef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1250 // Move semantics support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1251 xpath_query(xpath_query&& rhs) PUGIXML_NOEXCEPT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1252 xpath_query& operator=(xpath_query&& rhs) PUGIXML_NOEXCEPT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1253 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1254
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1255 // Get query expression return type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1256 xpath_value_type return_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1257
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1258 // Evaluate expression as boolean value in the specified context; performs type conversion if necessary.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1259 // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1260 bool evaluate_boolean(const xpath_node& n) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1261
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1262 // Evaluate expression as double value in the specified context; performs type conversion if necessary.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1263 // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1264 double evaluate_number(const xpath_node& n) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1265
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1266 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1267 // Evaluate expression as string value in the specified context; performs type conversion if necessary.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1268 // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1269 string_t evaluate_string(const xpath_node& n) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1270 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1271
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1272 // Evaluate expression as string value in the specified context; performs type conversion if necessary.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1273 // At most capacity characters are written to the destination buffer, full result size is returned (includes terminating zero).
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1274 // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1275 // If PUGIXML_NO_EXCEPTIONS is defined, returns empty set instead.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1276 size_t evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1277
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1278 // Evaluate expression as node set in the specified context.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1279 // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1280 // If PUGIXML_NO_EXCEPTIONS is defined, returns empty node set instead.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1281 xpath_node_set evaluate_node_set(const xpath_node& n) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1282
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1283 // Evaluate expression as node set in the specified context.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1284 // Return first node in document order, or empty node if node set is empty.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1285 // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1286 // If PUGIXML_NO_EXCEPTIONS is defined, returns empty node instead.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1287 xpath_node evaluate_node(const xpath_node& n) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1288
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1289 // Get parsing result (used to get compilation errors in PUGIXML_NO_EXCEPTIONS mode)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1290 const xpath_parse_result& result() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1291
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1292 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1293 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1294
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1295 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1296 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1297 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1298
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1299 #ifndef PUGIXML_NO_EXCEPTIONS
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1300 #if defined(_MSC_VER)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1301 // C4275 can be ignored in Visual C++ if you are deriving
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1302 // from a type in the Standard C++ Library
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1303 #pragma warning(push)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1304 #pragma warning(disable: 4275)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1305 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1306 // XPath exception class
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1307 class PUGIXML_CLASS xpath_exception: public std::exception
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1308 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1309 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1310 xpath_parse_result _result;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1311
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1312 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1313 // Construct exception from parse result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1314 explicit xpath_exception(const xpath_parse_result& result);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1315
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1316 // Get error message
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1317 virtual const char* what() const throw() PUGIXML_OVERRIDE;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1318
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1319 // Get parse result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1320 const xpath_parse_result& result() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1321 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1322 #if defined(_MSC_VER)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1323 #pragma warning(pop)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1324 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1325 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1326
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1327 // XPath node class (either xml_node or xml_attribute)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1328 class PUGIXML_CLASS xpath_node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1329 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1330 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1331 xml_node _node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1332 xml_attribute _attribute;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1333
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1334 typedef void (unspecified_bool_type)(xpath_node**);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1335
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1336 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1337 // Default constructor; constructs empty XPath node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1338 xpath_node();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1339
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1340 // Construct XPath node from XML node/attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1341 xpath_node(const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1342 xpath_node(const xml_attribute& attribute, const xml_node& parent);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1343
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1344 // Get node/attribute, if any
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1345 xml_node node() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1346 xml_attribute attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1347
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1348 // Get parent of contained node/attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1349 xml_node parent() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1350
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1351 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1352 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1353
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1354 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1355 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1356
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1357 // Comparison operators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1358 bool operator==(const xpath_node& n) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1359 bool operator!=(const xpath_node& n) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1360 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1361
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1362 #ifdef __BORLANDC__
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1363 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1364 bool PUGIXML_FUNCTION operator&&(const xpath_node& lhs, bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1365 bool PUGIXML_FUNCTION operator\|\|(const xpath_node& lhs, bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1366 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1367
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1368 // A fixed-size collection of XPath nodes
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1369 class PUGIXML_CLASS xpath_node_set
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1370 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1371 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1372 // Collection type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1373 enum type_t
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1374 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1375 type_unsorted, // Not ordered
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1376 type_sorted, // Sorted by document order (ascending)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1377 type_sorted_reverse // Sorted by document order (descending)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1378 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1379
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1380 // Constant iterator type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1381 typedef const xpath_node* const_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1382
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1383 // We define non-constant iterator to be the same as constant iterator so that various generic algorithms (i.e. boost foreach) work
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1384 typedef const xpath_node* iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1385
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1386 // Default constructor. Constructs empty set.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1387 xpath_node_set();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1388
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1389 // Constructs a set from iterator range; data is not checked for duplicates and is not sorted according to provided type, so be careful
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1390 xpath_node_set(const_iterator begin, const_iterator end, type_t type = type_unsorted);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1391
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1392 // Destructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1393 ~xpath_node_set();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1394
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1395 // Copy constructor/assignment operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1396 xpath_node_set(const xpath_node_set& ns);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1397 xpath_node_set& operator=(const xpath_node_set& ns);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1398
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1399 #ifdef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1400 // Move semantics support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1401 xpath_node_set(xpath_node_set&& rhs) PUGIXML_NOEXCEPT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1402 xpath_node_set& operator=(xpath_node_set&& rhs) PUGIXML_NOEXCEPT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1403 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1404
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1405 // Get collection type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1406 type_t type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1407
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1408 // Get collection size
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1409 size_t size() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1410
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1411 // Indexing operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1412 const xpath_node& operator[](size_t index) const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1413
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1414 // Collection iterators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1415 const_iterator begin() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1416 const_iterator end() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1417
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1418 // Sort the collection in ascending/descending order by document order
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1419 void sort(bool reverse = false);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1420
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1421 // Get first node in the collection by document order
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1422 xpath_node first() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1423
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1424 // Check if collection is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1425 bool empty() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1426
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1427 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1428 type_t _type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1429
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1430 xpath_node _storage[1];
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1431
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1432 xpath_node* _begin;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1433 xpath_node* _end;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1434
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1435 void _assign(const_iterator begin, const_iterator end, type_t type);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1436 void _move(xpath_node_set& rhs) PUGIXML_NOEXCEPT;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1437 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1438 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1439
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1440 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1441 // Convert wide string to UTF8
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1442 std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const wchar_t* str);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1443 std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >& str);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1444
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1445 // Convert UTF8 to wide string
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1446 std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const char* str);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1447 std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >& str);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1448 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1449
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1450 // Memory allocation function interface; returns pointer to allocated memory or NULL on failure
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1451 typedef void* (*allocation_function)(size_t size);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1452
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1453 // Memory deallocation function interface
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1454 typedef void (deallocation_function)(void ptr);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1455
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1456 // Override default memory management functions. All subsequent allocations/deallocations will be performed via supplied functions.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1457 void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1458
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1459 // Get current memory management functions
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1460 allocation_function PUGIXML_FUNCTION get_memory_allocation_function();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1461 deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1462 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1463
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1464 #if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) \|\| defined(__ICC))
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1465 namespace std
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1466 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1467 // Workarounds for (non-standard) iterator category detection for older versions (MSVC7/IC8 and earlier)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1468 std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_node_iterator&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1469 std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_attribute_iterator&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1470 std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_named_node_iterator&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1471 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1472 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1473
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1474 #if !defined(PUGIXML_NO_STL) && defined(__SUNPRO_CC)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1475 namespace std
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1476 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1477 // Workarounds for (non-standard) iterator category detection
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1478 std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_node_iterator&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1479 std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_attribute_iterator&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1480 std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_named_node_iterator&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1481 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1482 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1483
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1484 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1485
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1486 // Make sure implementation is included in header-only mode
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1487 // Use macro expansion in #include to work around QMake (QTBUG-11923)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1488 #if defined(PUGIXML_HEADER_ONLY) && !defined(PUGIXML_SOURCE)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1489 # define PUGIXML_SOURCE "pugixml.cpp"
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1490 # include PUGIXML_SOURCE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1491 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1492
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1493 /**
123 a45edd073f9e deps/pugixml: update to v1.14.0 Paper <mrpapersonic@gmail.com> parents: 55 diff changeset	1494 * Copyright (c) 2006-2023 Arseny Kapoulkine
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1495 *
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1496 * Permission is hereby granted, free of charge, to any person
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1497 * obtaining a copy of this software and associated documentation
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1498 * files (the "Software"), to deal in the Software without
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1499 * restriction, including without limitation the rights to use,
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1500 * copy, modify, merge, publish, distribute, sublicense, and/or sell
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1501 * copies of the Software, and to permit persons to whom the
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1502 * Software is furnished to do so, subject to the following
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1503 * conditions:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1504 *
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1505 * The above copyright notice and this permission notice shall be
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1506 * included in all copies or substantial portions of the Software.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1507 *
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1508 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1509 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1510 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1511 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1512 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1513 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1514 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1515 * OTHER DEALINGS IN THE SOFTWARE.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1516 */

Mercurial > minori

annotate dep/pugixml/src/pugixml.hpp @ 252:a0eeb2cc7e6d