|
|
@@ -1,7 +1,7 @@
|
|
|
/**
|
|
|
- * pugixml parser - version 1.6
|
|
|
+ * pugixml parser - version 1.7
|
|
|
* --------------------------------------------------------
|
|
|
- * Copyright (C) 2006-2015, by Arseny Kapoulkine ([email protected])
|
|
|
+ * Copyright (C) 2006-2016, by Arseny Kapoulkine ([email protected])
|
|
|
* Report bugs and download new versions at http://pugixml.org/
|
|
|
*
|
|
|
* This library is distributed under the MIT License. See notice at the end
|
|
|
@@ -13,7 +13,7 @@
|
|
|
|
|
|
#ifndef PUGIXML_VERSION
|
|
|
// Define version macro; evaluates to major * 100 + minor so that it's safe to use in less-than comparisons
|
|
|
-# define PUGIXML_VERSION 160
|
|
|
+# define PUGIXML_VERSION 170
|
|
|
#endif
|
|
|
|
|
|
// Include user configuration file (this can define various configuration macros)
|
|
|
@@ -65,7 +65,7 @@
|
|
|
|
|
|
// If the platform is known to have long long support, enable long long functions
|
|
|
#ifndef PUGIXML_HAS_LONG_LONG
|
|
|
-# if defined(__cplusplus) && __cplusplus >= 201103
|
|
|
+# if __cplusplus >= 201103
|
|
|
# define PUGIXML_HAS_LONG_LONG
|
|
|
# elif defined(_MSC_VER) && _MSC_VER >= 1400
|
|
|
# define PUGIXML_HAS_LONG_LONG
|
|
|
@@ -133,13 +133,13 @@ namespace pugi
|
|
|
|
|
|
// This flag determines if EOL characters are normalized (converted to #xA) during parsing. This flag is on by default.
|
|
|
const unsigned int parse_eol = 0x0020;
|
|
|
-
|
|
|
+
|
|
|
// This flag determines if attribute values are normalized using CDATA normalization rules during parsing. This flag is on by default.
|
|
|
const unsigned int parse_wconv_attribute = 0x0040;
|
|
|
|
|
|
// This flag determines if attribute values are normalized using NMTOKENS normalization rules during parsing. This flag is off by default.
|
|
|
const unsigned int parse_wnorm_attribute = 0x0080;
|
|
|
-
|
|
|
+
|
|
|
// This flag determines if document declaration (node_declaration) is added to the DOM tree. This flag is off by default.
|
|
|
const unsigned int parse_declaration = 0x0100;
|
|
|
|
|
|
@@ -158,6 +158,11 @@ namespace pugi
|
|
|
// is a valid document. This flag is off by default.
|
|
|
const unsigned int parse_fragment = 0x1000;
|
|
|
|
|
|
+ // This flag determines if plain character data is be stored in the parent element's value. This significantly changes the structure of
|
|
|
+ // the document; this flag is only recommended for parsing documents with many PCDATA nodes in memory-constrained environments.
|
|
|
+ // This flag is off by default.
|
|
|
+ const unsigned int parse_embed_pcdata = 0x2000;
|
|
|
+
|
|
|
// The default parsing mode.
|
|
|
// Elements, PCDATA and CDATA sections are added to the DOM tree, character/reference entities are expanded,
|
|
|
// End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
|
|
|
@@ -184,16 +189,16 @@ namespace pugi
|
|
|
};
|
|
|
|
|
|
// Formatting flags
|
|
|
-
|
|
|
+
|
|
|
// Indent the nodes that are written to output stream with as many indentation strings as deep the node is in DOM tree. This flag is on by default.
|
|
|
const unsigned int format_indent = 0x01;
|
|
|
-
|
|
|
+
|
|
|
// Write encoding-specific BOM to the output stream. This flag is off by default.
|
|
|
const unsigned int format_write_bom = 0x02;
|
|
|
|
|
|
// Use raw output mode (no indentation and no line breaks are written). This flag is off by default.
|
|
|
const unsigned int format_raw = 0x04;
|
|
|
-
|
|
|
+
|
|
|
// Omit default XML declaration even if there is no declaration in the document. This flag is off by default.
|
|
|
const unsigned int format_no_declaration = 0x08;
|
|
|
|
|
|
@@ -225,7 +230,7 @@ namespace pugi
|
|
|
class xml_node;
|
|
|
|
|
|
class xml_text;
|
|
|
-
|
|
|
+
|
|
|
#ifndef PUGIXML_NO_XPATH
|
|
|
class xpath_node;
|
|
|
class xpath_node_set;
|
|
|
@@ -299,13 +304,13 @@ namespace pugi
|
|
|
|
|
|
private:
|
|
|
xml_attribute_struct* _attr;
|
|
|
-
|
|
|
+
|
|
|
typedef void (*unspecified_bool_type)(xml_attribute***);
|
|
|
|
|
|
public:
|
|
|
// Default constructor. Constructs an empty attribute.
|
|
|
xml_attribute();
|
|
|
-
|
|
|
+
|
|
|
// Constructs attribute from internal pointer
|
|
|
explicit xml_attribute(xml_attribute_struct* attr);
|
|
|
|
|
|
@@ -354,6 +359,8 @@ namespace pugi
|
|
|
// Set attribute value with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
|
|
|
bool set_value(int rhs);
|
|
|
bool set_value(unsigned int rhs);
|
|
|
+ bool set_value(long rhs);
|
|
|
+ bool set_value(unsigned long rhs);
|
|
|
bool set_value(double rhs);
|
|
|
bool set_value(float rhs);
|
|
|
bool set_value(bool rhs);
|
|
|
@@ -367,6 +374,8 @@ namespace pugi
|
|
|
xml_attribute& operator=(const char_t* rhs);
|
|
|
xml_attribute& operator=(int rhs);
|
|
|
xml_attribute& operator=(unsigned int rhs);
|
|
|
+ xml_attribute& operator=(long rhs);
|
|
|
+ xml_attribute& operator=(unsigned long rhs);
|
|
|
xml_attribute& operator=(double rhs);
|
|
|
xml_attribute& operator=(float rhs);
|
|
|
xml_attribute& operator=(bool rhs);
|
|
|
@@ -417,7 +426,7 @@ namespace pugi
|
|
|
|
|
|
// Borland C++ workaround
|
|
|
bool operator!() const;
|
|
|
-
|
|
|
+
|
|
|
// Comparison operators (compares wrapped node pointers)
|
|
|
bool operator==(const xml_node& r) const;
|
|
|
bool operator!=(const xml_node& r) const;
|
|
|
@@ -438,7 +447,7 @@ namespace pugi
|
|
|
// Get node value, or "" if node is empty or it has no value
|
|
|
// Note: For <node>text</node> node.value() does not return "text"! Use child_value() or text() methods to access text inside nodes.
|
|
|
const char_t* value() const;
|
|
|
-
|
|
|
+
|
|
|
// Get attribute list
|
|
|
xml_attribute first_attribute() const;
|
|
|
xml_attribute last_attribute() const;
|
|
|
@@ -450,7 +459,7 @@ namespace pugi
|
|
|
// Get next/previous sibling in the children list of the parent node
|
|
|
xml_node next_sibling() const;
|
|
|
xml_node previous_sibling() const;
|
|
|
-
|
|
|
+
|
|
|
// Get parent node
|
|
|
xml_node parent() const;
|
|
|
|
|
|
@@ -466,6 +475,9 @@ namespace pugi
|
|
|
xml_node next_sibling(const char_t* name) const;
|
|
|
xml_node previous_sibling(const char_t* name) const;
|
|
|
|
|
|
+ // Get attribute, starting the search from a hint (and updating hint so that searching for a sequence of attributes is fast)
|
|
|
+ xml_attribute attribute(const char_t* name, xml_attribute& hint) const;
|
|
|
+
|
|
|
// Get child value of current node; that is, value of the first child node of type PCDATA/CDATA
|
|
|
const char_t* child_value() const;
|
|
|
|
|
|
@@ -475,7 +487,7 @@ namespace pugi
|
|
|
// Set node name/value (returns false if node is empty, there is not enough memory, or node can not have name/value)
|
|
|
bool set_name(const char_t* rhs);
|
|
|
bool set_value(const char_t* rhs);
|
|
|
-
|
|
|
+
|
|
|
// Add attribute with specified name. Returns added attribute, or empty attribute on errors.
|
|
|
xml_attribute append_attribute(const char_t* name);
|
|
|
xml_attribute prepend_attribute(const char_t* name);
|
|
|
@@ -529,11 +541,11 @@ namespace pugi
|
|
|
template <typename Predicate> xml_attribute find_attribute(Predicate pred) const
|
|
|
{
|
|
|
if (!_root) return xml_attribute();
|
|
|
-
|
|
|
+
|
|
|
for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
|
|
|
if (pred(attrib))
|
|
|
return attrib;
|
|
|
-
|
|
|
+
|
|
|
return xml_attribute();
|
|
|
}
|
|
|
|
|
|
@@ -541,11 +553,11 @@ namespace pugi
|
|
|
template <typename Predicate> xml_node find_child(Predicate pred) const
|
|
|
{
|
|
|
if (!_root) return xml_node();
|
|
|
-
|
|
|
+
|
|
|
for (xml_node node = first_child(); node; node = node.next_sibling())
|
|
|
if (pred(node))
|
|
|
return node;
|
|
|
-
|
|
|
+
|
|
|
return xml_node();
|
|
|
}
|
|
|
|
|
|
@@ -555,7 +567,7 @@ namespace pugi
|
|
|
if (!_root) return xml_node();
|
|
|
|
|
|
xml_node cur = first_child();
|
|
|
-
|
|
|
+
|
|
|
while (cur._root && cur._root != _root)
|
|
|
{
|
|
|
if (pred(cur)) return cur;
|
|
|
@@ -587,7 +599,7 @@ namespace pugi
|
|
|
|
|
|
// Recursively traverse subtree with xml_tree_walker
|
|
|
bool traverse(xml_tree_walker& walker);
|
|
|
-
|
|
|
+
|
|
|
#ifndef PUGIXML_NO_XPATH
|
|
|
// Select single node by evaluating XPath query. Returns first node from the resulting node set.
|
|
|
xpath_node select_node(const char_t* query, xpath_variable_set* variables = 0) const;
|
|
|
@@ -602,7 +614,7 @@ namespace pugi
|
|
|
xpath_node select_single_node(const xpath_query& query) const;
|
|
|
|
|
|
#endif
|
|
|
-
|
|
|
+
|
|
|
// Print subtree using a writer object
|
|
|
void print(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;
|
|
|
|
|
|
@@ -698,6 +710,8 @@ namespace pugi
|
|
|
// Set text with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
|
|
|
bool set(int rhs);
|
|
|
bool set(unsigned int rhs);
|
|
|
+ bool set(long rhs);
|
|
|
+ bool set(unsigned long rhs);
|
|
|
bool set(double rhs);
|
|
|
bool set(float rhs);
|
|
|
bool set(bool rhs);
|
|
|
@@ -711,6 +725,8 @@ namespace pugi
|
|
|
xml_text& operator=(const char_t* rhs);
|
|
|
xml_text& operator=(int rhs);
|
|
|
xml_text& operator=(unsigned int rhs);
|
|
|
+ xml_text& operator=(long rhs);
|
|
|
+ xml_text& operator=(unsigned long rhs);
|
|
|
xml_text& operator=(double rhs);
|
|
|
xml_text& operator=(float rhs);
|
|
|
xml_text& operator=(bool rhs);
|
|
|
@@ -864,11 +880,11 @@ namespace pugi
|
|
|
|
|
|
private:
|
|
|
int _depth;
|
|
|
-
|
|
|
+
|
|
|
protected:
|
|
|
// Get current traversal depth
|
|
|
int depth() const;
|
|
|
-
|
|
|
+
|
|
|
public:
|
|
|
xml_tree_walker();
|
|
|
virtual ~xml_tree_walker();
|
|
|
@@ -939,10 +955,10 @@ namespace pugi
|
|
|
char_t* _buffer;
|
|
|
|
|
|
char _memory[192];
|
|
|
-
|
|
|
+
|
|
|
// Non-copyable semantics
|
|
|
xml_document(const xml_document&);
|
|
|
- const xml_document& operator=(const xml_document&);
|
|
|
+ xml_document& operator=(const xml_document&);
|
|
|
|
|
|
void create();
|
|
|
void destroy();
|
|
|
@@ -1043,12 +1059,12 @@ namespace pugi
|
|
|
xpath_value_type _type;
|
|
|
xpath_variable* _next;
|
|
|
|
|
|
- xpath_variable();
|
|
|
+ xpath_variable(xpath_value_type type);
|
|
|
|
|
|
// Non-copyable semantics
|
|
|
xpath_variable(const xpath_variable&);
|
|
|
xpath_variable& operator=(const xpath_variable&);
|
|
|
-
|
|
|
+
|
|
|
public:
|
|
|
// Get variable name
|
|
|
const char_t* name() const;
|
|
|
@@ -1075,17 +1091,29 @@ namespace pugi
|
|
|
private:
|
|
|
xpath_variable* _data[64];
|
|
|
|
|
|
- // Non-copyable semantics
|
|
|
- xpath_variable_set(const xpath_variable_set&);
|
|
|
- xpath_variable_set& operator=(const xpath_variable_set&);
|
|
|
+ void _assign(const xpath_variable_set& rhs);
|
|
|
+ void _swap(xpath_variable_set& rhs);
|
|
|
|
|
|
- xpath_variable* find(const char_t* name) const;
|
|
|
+ xpath_variable* _find(const char_t* name) const;
|
|
|
+
|
|
|
+ static bool _clone(xpath_variable* var, xpath_variable** out_result);
|
|
|
+ static void _destroy(xpath_variable* var);
|
|
|
|
|
|
public:
|
|
|
// Default constructor/destructor
|
|
|
xpath_variable_set();
|
|
|
~xpath_variable_set();
|
|
|
|
|
|
+ // Copy constructor/assignment operator
|
|
|
+ xpath_variable_set(const xpath_variable_set& rhs);
|
|
|
+ xpath_variable_set& operator=(const xpath_variable_set& rhs);
|
|
|
+
|
|
|
+ #if __cplusplus >= 201103
|
|
|
+ // Move semantics support
|
|
|
+ xpath_variable_set(xpath_variable_set&& rhs);
|
|
|
+ xpath_variable_set& operator=(xpath_variable_set&& rhs);
|
|
|
+ #endif
|
|
|
+
|
|
|
// Add a new variable or get the existing one, if the types match
|
|
|
xpath_variable* add(const char_t* name, xpath_value_type type);
|
|
|
|
|
|
@@ -1118,26 +1146,35 @@ namespace pugi
|
|
|
// If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on compilation errors.
|
|
|
explicit xpath_query(const char_t* query, xpath_variable_set* variables = 0);
|
|
|
|
|
|
+ // Constructor
|
|
|
+ xpath_query();
|
|
|
+
|
|
|
// Destructor
|
|
|
~xpath_query();
|
|
|
|
|
|
+ #if __cplusplus >= 201103
|
|
|
+ // Move semantics support
|
|
|
+ xpath_query(xpath_query&& rhs);
|
|
|
+ xpath_query& operator=(xpath_query&& rhs);
|
|
|
+ #endif
|
|
|
+
|
|
|
// Get query expression return type
|
|
|
xpath_value_type return_type() const;
|
|
|
-
|
|
|
+
|
|
|
// Evaluate expression as boolean value in the specified context; performs type conversion if necessary.
|
|
|
// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
|
|
|
bool evaluate_boolean(const xpath_node& n) const;
|
|
|
-
|
|
|
+
|
|
|
// Evaluate expression as double value in the specified context; performs type conversion if necessary.
|
|
|
// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
|
|
|
double evaluate_number(const xpath_node& n) const;
|
|
|
-
|
|
|
+
|
|
|
#ifndef PUGIXML_NO_STL
|
|
|
// Evaluate expression as string value in the specified context; performs type conversion if necessary.
|
|
|
// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
|
|
|
string_t evaluate_string(const xpath_node& n) const;
|
|
|
#endif
|
|
|
-
|
|
|
+
|
|
|
// Evaluate expression as string value in the specified context; performs type conversion if necessary.
|
|
|
// At most capacity characters are written to the destination buffer, full result size is returned (includes terminating zero).
|
|
|
// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
|
|
|
@@ -1164,7 +1201,7 @@ namespace pugi
|
|
|
// Borland C++ workaround
|
|
|
bool operator!() const;
|
|
|
};
|
|
|
-
|
|
|
+
|
|
|
#ifndef PUGIXML_NO_EXCEPTIONS
|
|
|
// XPath exception class
|
|
|
class PUGIXML_CLASS xpath_exception: public std::exception
|
|
|
@@ -1183,20 +1220,20 @@ namespace pugi
|
|
|
const xpath_parse_result& result() const;
|
|
|
};
|
|
|
#endif
|
|
|
-
|
|
|
+
|
|
|
// XPath node class (either xml_node or xml_attribute)
|
|
|
class PUGIXML_CLASS xpath_node
|
|
|
{
|
|
|
private:
|
|
|
xml_node _node;
|
|
|
xml_attribute _attribute;
|
|
|
-
|
|
|
+
|
|
|
typedef void (*unspecified_bool_type)(xpath_node***);
|
|
|
|
|
|
public:
|
|
|
// Default constructor; constructs empty XPath node
|
|
|
xpath_node();
|
|
|
-
|
|
|
+
|
|
|
// Construct XPath node from XML node/attribute
|
|
|
xpath_node(const xml_node& node);
|
|
|
xpath_node(const xml_attribute& attribute, const xml_node& parent);
|
|
|
@@ -1204,13 +1241,13 @@ namespace pugi
|
|
|
// Get node/attribute, if any
|
|
|
xml_node node() const;
|
|
|
xml_attribute attribute() const;
|
|
|
-
|
|
|
+
|
|
|
// Get parent of contained node/attribute
|
|
|
xml_node parent() const;
|
|
|
|
|
|
// Safe bool conversion operator
|
|
|
operator unspecified_bool_type() const;
|
|
|
-
|
|
|
+
|
|
|
// Borland C++ workaround
|
|
|
bool operator!() const;
|
|
|
|
|
|
@@ -1236,13 +1273,13 @@ namespace pugi
|
|
|
type_sorted, // Sorted by document order (ascending)
|
|
|
type_sorted_reverse // Sorted by document order (descending)
|
|
|
};
|
|
|
-
|
|
|
+
|
|
|
// Constant iterator type
|
|
|
typedef const xpath_node* const_iterator;
|
|
|
|
|
|
// We define non-constant iterator to be the same as constant iterator so that various generic algorithms (i.e. boost foreach) work
|
|
|
typedef const xpath_node* iterator;
|
|
|
-
|
|
|
+
|
|
|
// Default constructor. Constructs empty set.
|
|
|
xpath_node_set();
|
|
|
|
|
|
@@ -1251,42 +1288,49 @@ namespace pugi
|
|
|
|
|
|
// Destructor
|
|
|
~xpath_node_set();
|
|
|
-
|
|
|
+
|
|
|
// Copy constructor/assignment operator
|
|
|
xpath_node_set(const xpath_node_set& ns);
|
|
|
xpath_node_set& operator=(const xpath_node_set& ns);
|
|
|
|
|
|
+ #if __cplusplus >= 201103
|
|
|
+ // Move semantics support
|
|
|
+ xpath_node_set(xpath_node_set&& rhs);
|
|
|
+ xpath_node_set& operator=(xpath_node_set&& rhs);
|
|
|
+ #endif
|
|
|
+
|
|
|
// Get collection type
|
|
|
type_t type() const;
|
|
|
-
|
|
|
+
|
|
|
// Get collection size
|
|
|
size_t size() const;
|
|
|
|
|
|
// Indexing operator
|
|
|
const xpath_node& operator[](size_t index) const;
|
|
|
-
|
|
|
+
|
|
|
// Collection iterators
|
|
|
const_iterator begin() const;
|
|
|
const_iterator end() const;
|
|
|
|
|
|
// Sort the collection in ascending/descending order by document order
|
|
|
void sort(bool reverse = false);
|
|
|
-
|
|
|
+
|
|
|
// Get first node in the collection by document order
|
|
|
xpath_node first() const;
|
|
|
-
|
|
|
+
|
|
|
// Check if collection is empty
|
|
|
bool empty() const;
|
|
|
-
|
|
|
+
|
|
|
private:
|
|
|
type_t _type;
|
|
|
-
|
|
|
+
|
|
|
xpath_node _storage;
|
|
|
-
|
|
|
+
|
|
|
xpath_node* _begin;
|
|
|
xpath_node* _end;
|
|
|
|
|
|
void _assign(const_iterator begin, const_iterator end, type_t type);
|
|
|
+ void _move(xpath_node_set& rhs);
|
|
|
};
|
|
|
#endif
|
|
|
|
|
|
@@ -1294,25 +1338,23 @@ namespace pugi
|
|
|
// Convert wide string to UTF8
|
|
|
std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const wchar_t* str);
|
|
|
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);
|
|
|
-
|
|
|
+
|
|
|
// Convert UTF8 to wide string
|
|
|
std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const char* str);
|
|
|
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);
|
|
|
#endif
|
|
|
|
|
|
-
|
|
|
pugi::xml_attribute PUGIXML_FUNCTION find_next_attribute(const pugi::xml_node &node, pugi::xml_attribute& attr, const char *name);
|
|
|
|
|
|
-
|
|
|
// Memory allocation function interface; returns pointer to allocated memory or NULL on failure
|
|
|
typedef void* (*allocation_function)(size_t size);
|
|
|
-
|
|
|
+
|
|
|
// Memory deallocation function interface
|
|
|
typedef void (*deallocation_function)(void* ptr);
|
|
|
|
|
|
// Override default memory management functions. All subsequent allocations/deallocations will be performed via supplied functions.
|
|
|
void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
|
|
|
-
|
|
|
+
|
|
|
// Get current memory management functions
|
|
|
allocation_function PUGIXML_FUNCTION get_memory_allocation_function();
|
|
|
deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function();
|
|
|
@@ -1348,7 +1390,7 @@ namespace std
|
|
|
#endif
|
|
|
|
|
|
/**
|
|
|
- * Copyright (c) 2006-2015 Arseny Kapoulkine
|
|
|
+ * Copyright (c) 2006-2016 Arseny Kapoulkine
|
|
|
*
|
|
|
* Permission is hereby granted, free of charge, to any person
|
|
|
* obtaining a copy of this software and associated documentation
|
|
|
@@ -1361,7 +1403,7 @@ namespace std
|
|
|
*
|
|
|
* The above copyright notice and this permission notice shall be
|
|
|
* included in all copies or substantial portions of the Software.
|
|
|
- *
|
|
|
+ *
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
dmuratshin