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

annotate dep/pugixml/src/pugixml.hpp @ 118:39521c47c7a3

*: another huge megacommit, SORRY The torrents page works a lot better now Added the edit option to the anime list right click menu Vectorized currently playing files Available player and extensions are now loaded at runtime from files in (dotpath)/players.json and (dotpath)/extensions.json These paths are not permanent and will likely be moved to (dotpath)/recognition ... ... ...

author	Paper <mrpapersonic@gmail.com>
date	Tue, 07 Nov 2023 23:40:54 -0500
parents	d10b6c6b432e
children	a45edd073f9e

rev	line source
55 d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1 /**
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	2 * pugixml parser - version 1.13
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	3 * --------------------------------------------------------
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	4 * Copyright (C) 2006-2022, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	17 # define PUGIXML_VERSION 1130 // 1.13
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;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	215
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	216 // The default parsing mode.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	217 // 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	218 // 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	219 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	220
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	221 // The full parsing mode.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	222 // 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	223 // 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	224 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	225
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	226 // 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	227 enum xml_encoding
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	228 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	229 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	230 encoding_utf8, // UTF8 encoding
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	231 encoding_utf16_le, // Little-endian UTF16
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	232 encoding_utf16_be, // Big-endian UTF16
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	233 encoding_utf16, // UTF16 with native endianness
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	234 encoding_utf32_le, // Little-endian UTF32
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	235 encoding_utf32_be, // Big-endian UTF32
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	236 encoding_utf32, // UTF32 with native endianness
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	237 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	238 encoding_latin1
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	239 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	240
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	241 // Formatting flags
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	242
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	243 // 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	244 const unsigned int format_indent = 0x01;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	245
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	246 // 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	247 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	248
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	249 // 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	250 const unsigned int format_raw = 0x04;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	251
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	252 // 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	253 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	254
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	255 // 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	256 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	257
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	258 // 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	259 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	260
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	261 // 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	262 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	263
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	264 // 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	265 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	266
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	267 // 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	268 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	269
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	270 // 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	271 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	272
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	273 // The default set of formatting flags.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	274 // 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	275 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	276
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	277 const int default_double_precision = 17;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	278 const int default_float_precision = 9;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	279
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	280 // Forward declarations
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	281 struct xml_attribute_struct;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	282 struct xml_node_struct;
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 class xml_node_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	285 class xml_attribute_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	286 class xml_named_node_iterator;
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_tree_walker;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	289
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	290 struct xml_parse_result;
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_node;
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 class xml_text;
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 #ifndef PUGIXML_NO_XPATH
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	297 class xpath_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	298 class xpath_node_set;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	299 class xpath_query;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	300 class xpath_variable_set;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	301 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	302
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	303 // Range-based for loop support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	304 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	305 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	306 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	307 typedef It const_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	308 typedef It iterator;
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 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	311 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	312 }
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 It begin() const { return _begin; }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	315 It end() const { return _end; }
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 bool empty() const { return _begin == _end; }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	318
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	319 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	320 It _begin, _end;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	321 };
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 // 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	324 class PUGIXML_CLASS xml_writer
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 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	327 virtual ~xml_writer() {}
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	328
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	329 // 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	330 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	331 };
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 // xml_writer implementation for FILE*
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	334 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	335 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	336 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	337 // 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	338 xml_writer_file(void* file);
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 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	341
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	342 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	343 void* file;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	344 };
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 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	347 // xml_writer implementation for streams
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	348 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	349 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	350 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	351 // 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	352 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	353 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	354
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	355 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	356
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	357 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	358 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	359 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	360 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	361 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	362
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	363 // 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	364 class PUGIXML_CLASS xml_attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	365 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	366 friend class xml_attribute_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	367 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	368
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	369 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	370 xml_attribute_struct* _attr;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	371
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	372 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	373
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	374 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	375 // Default constructor. Constructs an empty attribute.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	376 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 // Constructs attribute from internal pointer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	379 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	380
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	381 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	382 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	383
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	384 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	385 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	386
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	387 // Comparison operators (compares wrapped attribute pointers)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	388 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	389 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	390 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	391 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	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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	395 // Check if attribute is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	396 bool empty() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	397
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	398 // 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	399 const char_t* name() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	400 const char_t* value() 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 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	403 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	404
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	405 // 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	406 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	407 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	408 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	409 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	410
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	411 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	412 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	413 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	414 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	415
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	416 // 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	417 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	418
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	419 // 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	420 bool set_name(const char_t* rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	421 bool set_value(const char_t* rhs, size_t sz);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	422 bool set_value(const char_t* rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	423
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	424 // 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	425 bool set_value(int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	426 bool set_value(unsigned int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	427 bool set_value(long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	428 bool set_value(unsigned long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	429 bool set_value(double rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	430 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	431 bool set_value(float rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	432 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	433 bool set_value(bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	434
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	435 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	436 bool set_value(long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	437 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	438 #endif
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 // 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	441 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	442 xml_attribute& operator=(int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	443 xml_attribute& operator=(unsigned int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	444 xml_attribute& operator=(long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	445 xml_attribute& operator=(unsigned long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	446 xml_attribute& operator=(double rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	447 xml_attribute& operator=(float rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	448 xml_attribute& operator=(bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	449
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	450 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	451 xml_attribute& operator=(long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	452 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	453 #endif
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 // 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	456 xml_attribute next_attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	457 xml_attribute previous_attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	458
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	459 // 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	460 size_t hash_value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	461
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	462 // Get internal pointer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	463 xml_attribute_struct* internal_object() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	464 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	465
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	466 #ifdef __BORLANDC__
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	467 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	468 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	469 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	470 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	471
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	472 // 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	473 class PUGIXML_CLASS xml_node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	474 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	475 friend class xml_attribute_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	476 friend class xml_node_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	477 friend class xml_named_node_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	478
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	479 protected:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	480 xml_node_struct* _root;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	481
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	482 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	483
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	484 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	485 // Default constructor. Constructs an empty node.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	486 xml_node();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	487
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	488 // Constructs node from internal pointer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	489 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	490
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	491 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	492 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	493
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	494 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	495 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	496
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	497 // Comparison operators (compares wrapped node pointers)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	498 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	499 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	500 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	501 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	502 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	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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	505 // Check if node is empty.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	506 bool empty() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	507
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	508 // Get node type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	509 xml_node_type type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	510
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	511 // 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	512 const char_t* name() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	513
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	514 // 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	515 // 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	516 const char_t* value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	517
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	518 // Get attribute list
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	519 xml_attribute first_attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	520 xml_attribute last_attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	521
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	522 // Get children list
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	523 xml_node first_child() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	524 xml_node last_child() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	525
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	526 // 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	527 xml_node next_sibling() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	528 xml_node previous_sibling() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	529
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	530 // Get parent node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	531 xml_node parent() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	532
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	533 // 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	534 xml_node root() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	535
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	536 // 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	537 xml_text text() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	538
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	539 // 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	540 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	541 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	542 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	543 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	544
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	545 // 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	546 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	547
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	548 // 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	549 const char_t* child_value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	550
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	551 // 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	552 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	553
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	554 // 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	555 bool set_name(const char_t* rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	556 bool set_value(const char_t* rhs, size_t sz);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	557 bool set_value(const char_t* rhs);
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 // 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	560 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	561 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	562 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	563 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	564
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	565 // 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	566 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	567 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	568 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	569 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	570
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	571 // 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	572 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	573 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	574 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	575 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	576
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	577 // 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	578 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	579 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	580 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	581 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	582
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	583 // 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	584 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	585 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	586 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	587 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	588
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	589 // 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	590 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	591 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	592 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	593 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	594
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	595 // Remove specified attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	596 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	597 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	598
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	599 // Remove all attributes
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	600 bool remove_attributes();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	601
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	602 // Remove specified child
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	603 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	604 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	605
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	606 // Remove all children
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	607 bool remove_children();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	608
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	609 // 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	610 // 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	611 // 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	612 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	613
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	614 // 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	615 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	616 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	617 if (!_root) return xml_attribute();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	618
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	619 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	620 if (pred(attrib))
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	621 return attrib;
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 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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	626 // 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	627 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	628 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	629 if (!_root) return xml_node();
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 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	632 if (pred(node))
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	633 return node;
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 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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	638 // 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	639 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	640 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	641 if (!_root) 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 xml_node cur = first_child();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	644
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	645 while (cur._root && cur._root != _root)
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 (pred(cur)) return cur;
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 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	650 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	651 else
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 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	654
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	655 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	656 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	657 }
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 return xml_node();
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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	662 // 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	663 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	664 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	665
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	666 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	667 // 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	668 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	669 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	670
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	671 // 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	672 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	673
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	674 // 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	675 bool traverse(xml_tree_walker& walker);
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 #ifndef PUGIXML_NO_XPATH
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	678 // 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	679 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	680 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	681
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	682 // 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	683 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	684 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	685
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	686 // (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	687 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	688 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	689
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	690 #endif
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 // Print subtree using a writer object
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	693 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	694
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	695 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	696 // Print subtree to stream
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	697 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	698 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	699 #endif
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 // Child nodes iterators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	702 typedef xml_node_iterator iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	703
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	704 iterator begin() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	705 iterator end() const;
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 // Attribute iterators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	708 typedef xml_attribute_iterator attribute_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 attribute_iterator attributes_begin() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	711 attribute_iterator attributes_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 // Range-based for support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	714 xml_object_range<xml_node_iterator> children() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	715 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	716 xml_object_range<xml_attribute_iterator> attributes() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	717
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	718 // 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	719 ptrdiff_t offset_debug() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	720
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	721 // 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	722 size_t hash_value() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	723
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	724 // Get internal pointer
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	725 xml_node_struct* internal_object() 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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	728 #ifdef __BORLANDC__
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	729 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	730 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	731 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	732 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	733
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	734 // 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	735 class PUGIXML_CLASS xml_text
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 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	738
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	739 xml_node_struct* _root;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	740
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	741 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	742
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	743 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	744
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	745 xml_node_struct* _data_new();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	746 xml_node_struct* _data() const;
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 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	749 // Default constructor. Constructs an empty object.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	750 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 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	753 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	754
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	755 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	756 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	757
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	758 // Check if text object is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	759 bool empty() const;
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 // 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	762 const char_t* get() 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 // 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	765 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	766
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	767 // 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	768 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	769 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	770 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	771 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	772
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	773 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	774 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	775 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	776 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	777
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	778 // 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	779 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	780
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	781 // 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	782 bool set(const char_t* rhs, size_t sz);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	783 bool set(const char_t* rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	784
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	785 // 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	786 bool set(int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	787 bool set(unsigned int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	788 bool set(long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	789 bool set(unsigned long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	790 bool set(double rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	791 bool set(double rhs, int precision);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	792 bool set(float rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	793 bool set(float rhs, int precision);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	794 bool set(bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	795
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	796 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	797 bool set(long 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 long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	799 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	800
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	801 // 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	802 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	803 xml_text& operator=(int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	804 xml_text& operator=(unsigned int rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	805 xml_text& operator=(long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	806 xml_text& operator=(unsigned long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	807 xml_text& operator=(double rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	808 xml_text& operator=(float rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	809 xml_text& operator=(bool rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	810
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	811 #ifdef PUGIXML_HAS_LONG_LONG
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	812 xml_text& operator=(long long rhs);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	813 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	814 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	815
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	816 // 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	817 xml_node data() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	818 };
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 __BORLANDC__
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	821 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	822 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	823 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	824 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	825
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	826 // 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	827 class PUGIXML_CLASS xml_node_iterator
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 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	830
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	831 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	832 mutable xml_node _wrap;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	833 xml_node _parent;
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 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	836
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	837 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	838 // Iterator traits
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	839 typedef ptrdiff_t difference_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	840 typedef xml_node value_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	841 typedef xml_node* pointer;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	842 typedef xml_node& reference;
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 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	845 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	846 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	847
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	848 // Default constructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	849 xml_node_iterator();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	850
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	851 // 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	852 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	853
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	854 // Iterator operators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	855 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	856 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	857
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	858 xml_node& operator*() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	859 xml_node* operator->() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	860
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	861 xml_node_iterator& operator++();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	862 xml_node_iterator operator++(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	863
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	864 xml_node_iterator& operator--();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	865 xml_node_iterator operator--(int);
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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	868 // 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	869 class PUGIXML_CLASS xml_attribute_iterator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	870 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	871 friend class xml_node;
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 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	874 mutable xml_attribute _wrap;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	875 xml_node _parent;
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 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	878
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	879 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	880 // Iterator traits
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	881 typedef ptrdiff_t difference_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	882 typedef xml_attribute value_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	883 typedef xml_attribute* pointer;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	884 typedef xml_attribute& reference;
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 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	887 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	888 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	889
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	890 // Default constructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	891 xml_attribute_iterator();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	892
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	893 // 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	894 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	895
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	896 // Iterator operators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	897 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	898 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	899
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	900 xml_attribute& operator*() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	901 xml_attribute* operator->() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	902
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	903 xml_attribute_iterator& operator++();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	904 xml_attribute_iterator operator++(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	905
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	906 xml_attribute_iterator& operator--();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	907 xml_attribute_iterator operator--(int);
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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	910 // Named node range helper
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	911 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	912 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	913 friend class xml_node;
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 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	916 // Iterator traits
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	917 typedef ptrdiff_t difference_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	918 typedef xml_node value_type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	919 typedef xml_node* pointer;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	920 typedef xml_node& reference;
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 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	923 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	924 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	925
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	926 // Default constructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	927 xml_named_node_iterator();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	928
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	929 // 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	930 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	931
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	932 // Iterator operators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	933 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	934 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	935
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	936 xml_node& operator*() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	937 xml_node* operator->() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	938
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	939 xml_named_node_iterator& operator++();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	940 xml_named_node_iterator operator++(int);
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 xml_named_node_iterator& operator--();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	943 xml_named_node_iterator operator--(int);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	944
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	945 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	946 mutable xml_node _wrap;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	947 xml_node _parent;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	948 const char_t* _name;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	949
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	950 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	951 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	952
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	953 // 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	954 class PUGIXML_CLASS xml_tree_walker
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	955 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	956 friend class xml_node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	957
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	958 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	959 int _depth;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	960
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	961 protected:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	962 // Get current traversal depth
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	963 int depth() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	964
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	965 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	966 xml_tree_walker();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	967 virtual ~xml_tree_walker();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	968
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	969 // 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	970 virtual bool begin(xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	971
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	972 // 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	973 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	974
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	975 // 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	976 virtual bool end(xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	977 };
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 // 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	980 enum xml_parse_status
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 status_ok = 0, // No error
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	983
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	984 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	985 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	986 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	987 status_internal_error, // Internal error occurred
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 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	990
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	991 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	992 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	993 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	994 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	995 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	996 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	997 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	998 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	999 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	1000
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1001 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	1002
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1003 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	1004 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1005
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1006 // Parsing result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1007 struct PUGIXML_CLASS xml_parse_result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1008 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1009 // Parsing status (see xml_parse_status)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1010 xml_parse_status status;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1011
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1012 // 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	1013 ptrdiff_t offset;
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 // Source document encoding
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1016 xml_encoding encoding;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1017
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1018 // 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	1019 xml_parse_result();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1020
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1021 // Cast to bool operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1022 operator bool() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1023
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1024 // Get error description
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1025 const char* description() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1026 };
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 // Document class (DOM tree root)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1029 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	1030 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1031 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1032 char_t* _buffer;
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 char _memory[192];
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1035
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1036 // Non-copyable semantics
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1037 xml_document(const xml_document&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1038 xml_document& operator=(const xml_document&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1039
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1040 void _create();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1041 void _destroy();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1042 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	1043
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1044 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1045 // Default constructor, makes empty document
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1046 xml_document();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1047
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1048 // 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	1049 ~xml_document();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1050
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1051 #ifdef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1052 // Move semantics support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1053 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	1054 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	1055 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1056
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1057 // 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	1058 void reset();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1059
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1060 // 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	1061 void reset(const xml_document& proto);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1062
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1063 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1064 // Load document from stream.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1065 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	1066 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	1067 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1068
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1069 // (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	1070 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	1071
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1072 // 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	1073 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	1074
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1075 // Load document from file
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1076 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	1077 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	1078
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1079 // 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	1080 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	1081
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1082 // 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	1083 // 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	1084 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	1085
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1086 // 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	1087 // 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	1088 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	1089
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1090 // 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	1091 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	1092
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1093 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1094 // 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	1095 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	1096 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	1097 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1098
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1099 // Save XML to file
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1100 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	1101 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	1102
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1103 // Get document element
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1104 xml_node document_element() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1105 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1106
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1107 #ifndef PUGIXML_NO_XPATH
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1108 // XPath query return type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1109 enum xpath_value_type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1110 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1111 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	1112 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	1113 xpath_type_number, // Number
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1114 xpath_type_string, // String
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1115 xpath_type_boolean // Boolean
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
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1118 // XPath parsing result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1119 struct PUGIXML_CLASS xpath_parse_result
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 // Error message (0 if no error)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1122 const char* error;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1123
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1124 // 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	1125 ptrdiff_t offset;
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 // 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	1128 xpath_parse_result();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1129
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1130 // Cast to bool operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1131 operator bool() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1132
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1133 // Get error description
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1134 const char* description() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1135 };
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 // A single XPath variable
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1138 class PUGIXML_CLASS xpath_variable
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 friend class xpath_variable_set;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1141
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1142 protected:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1143 xpath_value_type _type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1144 xpath_variable* _next;
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 xpath_variable(xpath_value_type type);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1147
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1148 // Non-copyable semantics
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1149 xpath_variable(const xpath_variable&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1150 xpath_variable& operator=(const xpath_variable&);
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 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1153 // Get variable name
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1154 const char_t* name() const;
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 // Get variable type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1157 xpath_value_type type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1158
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1159 // 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	1160 bool get_boolean() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1161 double get_number() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1162 const char_t* get_string() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1163 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	1164
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1165 // 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	1166 bool set(bool value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1167 bool set(double value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1168 bool set(const char_t* value);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1169 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	1170 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1171
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1172 // A set of XPath variables
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1173 class PUGIXML_CLASS xpath_variable_set
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 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1176 xpath_variable* _data[64];
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1177
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1178 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	1179 void _swap(xpath_variable_set& rhs);
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 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	1182
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1183 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	1184 static void _destroy(xpath_variable* var);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1185
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1186 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1187 // Default constructor/destructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1188 xpath_variable_set();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1189 ~xpath_variable_set();
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 // Copy constructor/assignment operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1192 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	1193 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	1194
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1195 #ifdef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1196 // Move semantics support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1197 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	1198 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	1199 #endif
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 // 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	1202 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	1203
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1204 // 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	1205 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	1206 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	1207 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	1208 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	1209
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1210 // Get existing variable by name
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1211 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	1212 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	1213 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1214
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1215 // A compiled XPath query object
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1216 class PUGIXML_CLASS xpath_query
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1217 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1218 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1219 void* _impl;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1220 xpath_parse_result _result;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1221
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1222 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	1223
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1224 // Non-copyable semantics
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1225 xpath_query(const xpath_query&);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1226 xpath_query& operator=(const 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 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1229 // 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	1230 // 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	1231 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	1232
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1233 // Constructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1234 xpath_query();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1235
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1236 // Destructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1237 ~xpath_query();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1238
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1239 #ifdef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1240 // Move semantics support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1241 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	1242 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	1243 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1244
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1245 // Get query expression return type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1246 xpath_value_type return_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1247
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1248 // 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	1249 // 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	1250 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	1251
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1252 // 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	1253 // 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	1254 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	1255
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1256 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1257 // 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	1258 // 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	1259 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	1260 #endif
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 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	1263 // 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	1264 // 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	1265 // 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	1266 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	1267
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1268 // 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	1269 // 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	1270 // 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	1271 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	1272
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1273 // 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	1274 // 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	1275 // 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	1276 // 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	1277 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	1278
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1279 // 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	1280 const xpath_parse_result& result() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1281
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1282 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1283 operator unspecified_bool_type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1284
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1285 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1286 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1287 };
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 #ifndef PUGIXML_NO_EXCEPTIONS
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1290 #if defined(_MSC_VER)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1291 // 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	1292 // 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	1293 #pragma warning(push)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1294 #pragma warning(disable: 4275)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1295 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1296 // XPath exception class
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1297 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	1298 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1299 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1300 xpath_parse_result _result;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1301
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1302 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1303 // Construct exception from parse result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1304 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	1305
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1306 // Get error message
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1307 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	1308
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1309 // Get parse result
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1310 const xpath_parse_result& result() const;
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 #if defined(_MSC_VER)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1313 #pragma warning(pop)
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1314 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1315 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1316
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1317 // 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	1318 class PUGIXML_CLASS xpath_node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1319 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1320 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1321 xml_node _node;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1322 xml_attribute _attribute;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1323
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1324 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	1325
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1326 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1327 // Default constructor; constructs empty XPath node
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1328 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 // 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	1331 xpath_node(const xml_node& node);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1332 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	1333
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1334 // Get node/attribute, if any
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1335 xml_node node() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1336 xml_attribute attribute() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1337
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1338 // Get parent of contained node/attribute
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1339 xml_node parent() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1340
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1341 // Safe bool conversion operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1342 operator unspecified_bool_type() const;
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 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1345 bool operator!() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1346
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1347 // Comparison operators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1348 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	1349 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	1350 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1351
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1352 #ifdef __BORLANDC__
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1353 // Borland C++ workaround
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1354 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	1355 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	1356 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1357
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1358 // 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	1359 class PUGIXML_CLASS xpath_node_set
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 public:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1362 // Collection type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1363 enum type_t
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1364 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1365 type_unsorted, // Not ordered
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1366 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	1367 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	1368 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1369
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1370 // Constant iterator type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1371 typedef const xpath_node* const_iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1372
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1373 // 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	1374 typedef const xpath_node* iterator;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1375
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1376 // Default constructor. Constructs empty set.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1377 xpath_node_set();
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 // 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	1380 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	1381
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1382 // Destructor
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1383 ~xpath_node_set();
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1384
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1385 // Copy constructor/assignment operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1386 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	1387 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	1388
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1389 #ifdef PUGIXML_HAS_MOVE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1390 // Move semantics support
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1391 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	1392 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	1393 #endif
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 // Get collection type
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1396 type_t type() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1397
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1398 // Get collection size
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1399 size_t size() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1400
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1401 // Indexing operator
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1402 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	1403
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1404 // Collection iterators
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1405 const_iterator begin() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1406 const_iterator end() 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 // 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	1409 void sort(bool reverse = false);
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 // 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	1412 xpath_node first() 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 // Check if collection is empty
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1415 bool empty() const;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1416
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1417 private:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1418 type_t _type;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1419
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1420 xpath_node _storage[1];
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1421
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1422 xpath_node* _begin;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1423 xpath_node* _end;
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1424
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1425 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	1426 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	1427 };
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1428 #endif
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 #ifndef PUGIXML_NO_STL
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1431 // Convert wide string to UTF8
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1432 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	1433 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	1434
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1435 // Convert UTF8 to wide string
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1436 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	1437 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	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 // 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	1441 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	1442
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1443 // Memory deallocation function interface
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1444 typedef void (deallocation_function)(void ptr);
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1445
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1446 // 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	1447 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	1448
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1449 // Get current memory management functions
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1450 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	1451 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	1452 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1453
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1454 #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	1455 namespace std
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1456 {
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1457 // 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	1458 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	1459 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	1460 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	1461 }
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1462 #endif
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(__SUNPRO_CC)
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
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 __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	1469 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	1470 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	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 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1475
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1476 // 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	1477 // 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	1478 #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	1479 # define PUGIXML_SOURCE "pugixml.cpp"
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1480 # include PUGIXML_SOURCE
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1481 #endif
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1482
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 * Copyright (c) 2006-2022 Arseny Kapoulkine
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 * 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	1487 * 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	1488 * 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	1489 * 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	1490 * 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	1491 * 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	1492 * 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	1493 * conditions:
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1494 *
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1495 * 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	1496 * 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	1497 *
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1498 * 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	1499 * 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	1500 * 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	1501 * 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	1502 * 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	1503 * 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	1504 * 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	1505 * OTHER DEALINGS IN THE SOFTWARE.
d10b6c6b432e add xml lib, we will need to use it eventually Paper <mrpapersonic@gmail.com> parents: diff changeset	1506 */

Mercurial > minori

annotate dep/pugixml/src/pugixml.hpp @ 118:39521c47c7a3