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

Last change on this file since 130 was 130, checked in by jrpelegrina, 4 years ago

First release to xenial

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