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