source: icGREP/icgrep-devel/icgrep/combine/pugixml/src/pugixml.hpp @ 5518

Last change on this file since 5518 was 5518, checked in by faldebey, 2 years ago

cleanup

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