source: filezilla/trunk/fuentes/src/pugixml/pugixml.hpp @ 3185

Last change on this file since 3185 was 3185, checked in by jrpelegrina, 2 years ago

Update new version: 3.15.02

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