source: Vago/Libs/pugixml/pugixml.hpp@ 1080

Last change on this file since 1080 was 1060, checked in by s10k, 8 years ago

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