Mercurial > embed
comparison pugixml/src/pugixml.hpp @ 8:22ae219278af
pugixml: import 1.7
author | David Demelier <markand@malikania.fr> |
---|---|
date | Tue, 01 Mar 2016 13:00:57 +0100 |
parents | |
children | 8a8de065f049 |
comparison
equal
deleted
inserted
replaced
7:5f50c00a3472 | 8:22ae219278af |
---|---|
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 | |
84 namespace 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 | |
96 namespace 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)) | |
1349 namespace 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) | |
1359 namespace 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 */ |