PugiXML.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLUtils/src/ICLUtils/PugiXML.h                        **
** Module : ICLUtils                                               **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

    /************************************************************************
    * pugixml parser - version 1.0
    * --------------------------------------------------------
    * Copyright (C) 2006-2010, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
    * Report bugs and download new versions at http://pugixml.org/
    *
    * This library (PugiXML) is distributed under the MIT License. 
    * See notice at the end
    * of this file.
    *
    * This work is based on the pugxml parser, which is:
    * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
    *
    * The ICL developers applied only minor changes to this files
    *************************************************************************/

#pragma once

//#include "pugiconfig.hpp" we use everything here

#ifndef PUGIXML_NO_STL
namespace std
{
  struct bidirectional_iterator_tag;

#ifdef __SUNPRO_CC
  // Sun C++ compiler has a bug which forces template argument names in forward declarations to be the same as in actual definitions
  template <class _T> class allocator;
  template <class _charT> struct char_traits;
  template <class _charT, class _Traits> class basic_istream;
  template <class _charT, class _Traits> class basic_ostream;
  template <class _charT, class _Traits, class _Allocator> class basic_string;
#else
  // Borland C++ compiler has a bug which forces template argument names in forward declarations to be the same as in actual definitions
  template <class _Ty> class allocator;
  template <class _Ty> struct char_traits;
  template <class _Elem, class _Traits> class basic_istream;
  template <class _Elem, class _Traits> class basic_ostream;
  template <class _Elem, class _Traits, class _Ax> class basic_string;
#endif

  // Digital Mars compiler has a bug which requires a forward declaration for explicit instantiation (otherwise type selection is messed up later, producing link errors)
  // Also note that we have to declare char_traits as a class here, since it's defined that way
#ifdef __DMC__
  template <> class char_traits<char>;
#endif
}
#endif

// Macro for deprecated features
#ifndef PUGIXML_DEPRECATED
#       if defined(__GNUC__)
#               define PUGIXML_DEPRECATED __attribute__((deprecated))
#       elif defined(_MSC_VER) && _MSC_VER >= 1300
#               define PUGIXML_DEPRECATED __declspec(deprecated)
#       else
#               define PUGIXML_DEPRECATED
#       endif
#endif

// Include exception header for XPath
#if !defined(PUGIXML_NO_XPATH) && !defined(PUGIXML_NO_EXCEPTIONS)
#       include <exception>
#endif

// If no API is defined, assume default
#ifndef PUGIXML_API
#   define PUGIXML_API
#endif

// If no API for classes is defined, assume default
#ifndef PUGIXML_CLASS
#   define PUGIXML_CLASS PUGIXML_API
#endif

// If no API for functions is defined, assume default
#ifndef PUGIXML_FUNCTION
#   define PUGIXML_FUNCTION PUGIXML_API
#endif

#include <stddef.h>

// Character interface macros
#ifdef PUGIXML_WCHAR_MODE
#       define PUGIXML_TEXT(t) L ## t
#       define PUGIXML_CHAR wchar_t
#else
#       define PUGIXML_TEXT(t) t
#       define PUGIXML_CHAR char
#endif


namespace pugi{
  typedef PUGIXML_CHAR char_t;

#ifndef PUGIXML_NO_STL

  typedef std::basic_string<PUGIXML_CHAR, std::char_traits<PUGIXML_CHAR>, std::allocator<PUGIXML_CHAR> > string_t;
#endif


  enum xml_node_type{
    node_null,          
    node_document,      
    node_element,       
    node_pcdata,        
    node_cdata,         
    node_comment,       
    node_pi,            
    node_declaration,   
    node_doctype        
  };
  
  

  const unsigned int parse_minimal = 0x0000;
  

  const unsigned int parse_pi = 0x0001;
  

  const unsigned int parse_comments = 0x0002;
  

  const unsigned int parse_cdata = 0x0004;
  

  const unsigned int parse_ws_pcdata = 0x0008;
  

  const unsigned int parse_escapes = 0x0010;
  

  const unsigned int parse_eol = 0x0020;
        
  // This flag determines if attribute values are normalized using CDATA normalization rules during parsing. 
  const unsigned int parse_wconv_attribute = 0x0040;
  

  const unsigned int parse_wnorm_attribute = 0x0080;
  

  const unsigned int parse_declaration = 0x0100;
  

  const unsigned int parse_doctype = 0x0200;
  

  const unsigned int parse_default = parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol;

  // The full parsing mode.
  const unsigned int parse_full = parse_default | parse_pi | parse_comments | parse_declaration | parse_doctype;

  enum xml_encoding{
    encoding_auto,      
    encoding_utf8,      
    encoding_utf16_le,  
    encoding_utf16_be,  
    encoding_utf16,     
    encoding_utf32_le,  
    encoding_utf32_be,  
    encoding_utf32,     
    encoding_wchar      
  };
  
  

  const unsigned int format_indent = 0x01;
  

  const unsigned int format_write_bom = 0x02;
  

  const unsigned int format_raw = 0x04;
  

  const unsigned int format_no_declaration = 0x08;
    

  const unsigned int format_default = format_indent;
  
  // Forward declarations
  struct xml_attribute_struct;
  struct xml_node_struct;
  
  class xml_node_iterator;
  class xml_attribute_iterator;
  
  class xml_tree_walker;
  
  class xml_node;
  
#ifndef PUGIXML_NO_XPATH
  class xpath_node;
  class xpath_node_set;
  class xpath_query;
  class xpath_variable_set;
#endif
  

  class PUGIXML_CLASS xml_writer{
    public:
    virtual ~xml_writer() {}
    
    // Write memory chunk into stream/file/whatever
    virtual void write(const void* data, size_t size) = 0;
  };
    
    
  class PUGIXML_CLASS xml_writer_file: public xml_writer{
    public:
    xml_writer_file(void* file);    
    virtual void write(const void* data, size_t size);
    
    private:
    void* file;
  };
  
  
#ifndef PUGIXML_NO_STL

  class PUGIXML_CLASS xml_writer_stream: public xml_writer{
    public:
    xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream);
    xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream);
    
    virtual void write(const void* data, size_t size);
    
    private:
    std::basic_ostream<char, std::char_traits<char> >* narrow_stream;
    std::basic_ostream<wchar_t, std::char_traits<wchar_t> >* wide_stream;
  };
#endif
        
  class PUGIXML_CLASS xml_attribute{
    friend class xml_attribute_iterator;
    friend class xml_node;
    
    private:
    xml_attribute_struct* _attr;
    
    typedef xml_attribute_struct* xml_attribute::*unspecified_bool_type;
    
    public:
    xml_attribute();
    
    explicit xml_attribute(xml_attribute_struct* attr);
    
    operator unspecified_bool_type() const;
    
    bool operator!() const;
    
    bool operator==(const xml_attribute& r) const;
    bool operator!=(const xml_attribute& r) const;
    bool operator<(const xml_attribute& r) const;
    bool operator>(const xml_attribute& r) const;
    bool operator<=(const xml_attribute& r) const;
    bool operator>=(const xml_attribute& r) const;
      
    bool empty() const;
      
    const char_t* name() const;
    const char_t* value() const;
      
    int as_int() const;
    unsigned int as_uint() const;
    double as_double() const;
    float as_float() const;
      
    bool as_bool() const;
      
    bool set_name(const char_t* rhs);
    bool set_value(const char_t* rhs);
      
    bool set_value(int rhs);
    bool set_value(unsigned int rhs);
    bool set_value(double rhs);
    bool set_value(bool rhs);
      
    xml_attribute& operator=(const char_t* rhs);
    xml_attribute& operator=(int rhs);
    xml_attribute& operator=(unsigned int rhs);
    xml_attribute& operator=(double rhs);
    xml_attribute& operator=(bool rhs);
      
    xml_attribute next_attribute() const;
    xml_attribute previous_attribute() const;
      
    size_t hash_value() const;
      
    xml_attribute_struct* internal_object() const;
  };
    
    
          
#ifdef __BORLANDC__

  bool PUGIXML_FUNCTION operator&&(const xml_attribute& lhs, bool rhs);
  bool PUGIXML_FUNCTION operator||(const xml_attribute& lhs, bool rhs);
#endif


  class PUGIXML_CLASS xml_node{
    friend class xml_attribute_iterator;
    friend class xml_node_iterator;
      
    protected:
    xml_node_struct* _root;
      
    typedef xml_node_struct* xml_node::*unspecified_bool_type;
      
    public:
    xml_node();
      
    explicit xml_node(xml_node_struct* p);
      
    operator unspecified_bool_type() const;
      
    bool operator!() const;
      
    bool operator==(const xml_node& r) const;
    bool operator!=(const xml_node& r) const;
    bool operator<(const xml_node& r) const;
    bool operator>(const xml_node& r) const;
    bool operator<=(const xml_node& r) const;
    bool operator>=(const xml_node& r) const;
      
    bool empty() const;
      
    xml_node_type type() const;
      
    const char_t* name() const;
    const char_t* value() const;
      
    xml_attribute first_attribute() const;
    xml_attribute last_attribute() const;
      
    xml_node first_child() const;
    xml_node last_child() const;
      
    xml_node next_sibling() const;
    xml_node previous_sibling() const;
      
    xml_node parent() const;
      
    xml_node root() const;
      
    xml_node child(const char_t* name) const;
    xml_attribute attribute(const char_t* name) const;
    xml_node next_sibling(const char_t* name) const;
    xml_node previous_sibling(const char_t* name) const;

    const char_t* child_value() const;
      
    const char_t* child_value(const char_t* name) const;
      
    bool set_name(const char_t* rhs);
    bool set_value(const char_t* rhs);
      
    xml_attribute append_attribute(const char_t* name);
    xml_attribute prepend_attribute(const char_t* name);
    xml_attribute insert_attribute_after(const char_t* name, const xml_attribute& attr);
    xml_attribute insert_attribute_before(const char_t* name, const xml_attribute& attr);
      
    xml_attribute append_copy(const xml_attribute& proto);
    xml_attribute prepend_copy(const xml_attribute& proto);
    xml_attribute insert_copy_after(const xml_attribute& proto, const xml_attribute& attr);
    xml_attribute insert_copy_before(const xml_attribute& proto, const xml_attribute& attr);
      
    xml_node append_child(xml_node_type type = node_element);
    xml_node prepend_child(xml_node_type type = node_element);
    xml_node insert_child_after(xml_node_type type, const xml_node& node);
    xml_node insert_child_before(xml_node_type type, const xml_node& node);
      
    xml_node append_child(const char_t* name);
    xml_node prepend_child(const char_t* name);
    xml_node insert_child_after(const char_t* name, const xml_node& node);
    xml_node insert_child_before(const char_t* name, const xml_node& node);
      
    xml_node append_copy(const xml_node& proto);
    xml_node prepend_copy(const xml_node& proto);
    xml_node insert_copy_after(const xml_node& proto, const xml_node& node);
    xml_node insert_copy_before(const xml_node& proto, const xml_node& node);
      
    bool remove_attribute(const xml_attribute& a);
    bool remove_attribute(const char_t* name);
      
    bool remove_child(const xml_node& n);
    bool remove_child(const char_t* name);
      
    template <typename Predicate> xml_attribute find_attribute(Predicate pred) const{
      if (!_root) return xml_attribute();
        
      for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
        if (pred(attrib))
          return attrib;
        
      return xml_attribute();
    }
      
    template <typename Predicate> xml_node find_child(Predicate pred) const{
      if (!_root) return xml_node();
        
      for (xml_node node = first_child(); node; node = node.next_sibling())
        if (pred(node))
          return node;
        
      return xml_node();
    }
      
    template <typename Predicate> xml_node find_node(Predicate pred) const{
      if (!_root) return xml_node();
        
      xml_node cur = first_child();
        
      while (cur._root && cur._root != _root)
        {
          if (pred(cur)) return cur;
            
          if (cur.first_child()) cur = cur.first_child();
          else if (cur.next_sibling()) cur = cur.next_sibling();
          else
            {
              while (!cur.next_sibling() && cur._root != _root) cur = cur.parent();
                
              if (cur._root != _root) cur = cur.next_sibling();
            }
        }
        
      return xml_node();
    }
      
    xml_node find_child_by_attribute(const char_t* name, const char_t* attr_name, const char_t* attr_value) const;
    xml_node find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const;
      
#ifndef PUGIXML_NO_STL

    string_t path(char_t delimiter = '/') const;
#endif
      
    xml_node first_element_by_path(const char_t* path, char_t delimiter = '/') const;
      
    bool traverse(xml_tree_walker& walker);
      
#ifndef PUGIXML_NO_XPATH

    xpath_node select_single_node(const char_t* query, xpath_variable_set* variables = 0) const;
    xpath_node select_single_node(const xpath_query& query) const;
      
    xpath_node_set select_nodes(const char_t* query, xpath_variable_set* variables = 0) const;
    xpath_node_set select_nodes(const xpath_query& query) const;
#endif
      
    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;
      
#ifndef PUGIXML_NO_STL

    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;
    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;
#endif
      
    typedef xml_node_iterator iterator;
      
    iterator begin() const;
    iterator end() const;
      
    typedef xml_attribute_iterator attribute_iterator;
      
    attribute_iterator attributes_begin() const;
    attribute_iterator attributes_end() const;
      
    ptrdiff_t offset_debug() const;
      
    size_t hash_value() const;
      
    xml_node_struct* internal_object() const;
  };
    

#ifdef __BORLANDC__

  bool PUGIXML_FUNCTION operator&&(const xml_node& lhs, bool rhs);
  bool PUGIXML_FUNCTION operator||(const xml_node& lhs, bool rhs);
#endif


  class PUGIXML_CLASS xml_node_iterator{
    friend class xml_node;
      
    private:
    xml_node _wrap;
    xml_node _parent;
      
    xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent);
      
    public:
    typedef ptrdiff_t difference_type;
    typedef xml_node value_type;
    typedef xml_node* pointer;
    typedef xml_node& reference;
      
#ifndef PUGIXML_NO_STL
    typedef std::bidirectional_iterator_tag iterator_category;
#endif
      
    xml_node_iterator();
      
    xml_node_iterator(const xml_node& node);
      
    bool operator==(const xml_node_iterator& rhs) const;
    bool operator!=(const xml_node_iterator& rhs) const;
      
    xml_node& operator*();
    xml_node* operator->();
      
    const xml_node_iterator& operator++();
    xml_node_iterator operator++(int);
      
    const xml_node_iterator& operator--();
    xml_node_iterator operator--(int);
  };
    
    
  class PUGIXML_CLASS xml_attribute_iterator{
    friend class xml_node;
      
    private:
    xml_attribute _wrap;
    xml_node _parent;
      
    xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent);
      
    public:
    typedef ptrdiff_t difference_type;
    typedef xml_attribute value_type;
    typedef xml_attribute* pointer;
    typedef xml_attribute& reference;
      
#ifndef PUGIXML_NO_STL
    typedef std::bidirectional_iterator_tag iterator_category;
#endif
      
    xml_attribute_iterator();
      
    xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent);
      
    bool operator==(const xml_attribute_iterator& rhs) const;
    bool operator!=(const xml_attribute_iterator& rhs) const;
      
    xml_attribute& operator*();
    xml_attribute* operator->();
      
    const xml_attribute_iterator& operator++();
    xml_attribute_iterator operator++(int);
      
    const xml_attribute_iterator& operator--();
    xml_attribute_iterator operator--(int);
  };

    
  class PUGIXML_CLASS xml_tree_walker{
    friend class xml_node;
      
    private:
    int _depth;
      
    protected:
    int depth() const;
      
    public:
    xml_tree_walker();
    virtual ~xml_tree_walker();
      
    virtual bool begin(xml_node& node);
      
    virtual bool for_each(xml_node& node) = 0;
      
    virtual bool end(xml_node& node);
  };


  enum xml_parse_status{
    status_ok = 0,              
      
    status_file_not_found,      
    status_io_error,            
    status_out_of_memory,       
    status_internal_error,      
      
    status_unrecognized_tag,    
      
    status_bad_pi,              
    status_bad_comment,         
    status_bad_cdata,           
    status_bad_doctype,         
    status_bad_pcdata,          
    status_bad_start_element,   
    status_bad_attribute,       
    status_bad_end_element,     
    status_end_element_mismatch 
  };
    
    
  struct PUGIXML_CLASS xml_parse_result{
    xml_parse_status status;
      
    ptrdiff_t offset;
      
    xml_encoding encoding;
      
    xml_parse_result();
      
    operator bool() const;
      
    const char* description() const;
  };
    

    
  class PUGIXML_CLASS xml_document: public xml_node{
    private:
    char_t* _buffer;
      
    char _memory[192];
      
    xml_document(const xml_document&);
    const xml_document& operator=(const xml_document&);
      
    void create();
    void destroy();
      
    xml_parse_result load_buffer_impl(void* contents, size_t size, unsigned int options, xml_encoding encoding, bool is_mutable, bool own);
      
    public:
    xml_document();
      
    ~xml_document();
      
    void reset();
      
    void reset(const xml_document& proto);
      
#ifndef PUGIXML_NO_STL

    xml_parse_result load(std::basic_istream<char, std::char_traits<char> >& stream, 
                          unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
    xml_parse_result load(std::basic_istream<wchar_t, std::char_traits<wchar_t> >& stream, 
                          unsigned int options = parse_default);
      
    xml_parse_result loadNext(std::basic_istream<char, std::char_traits<char> >& stream, 
                              unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
#endif
      
    xml_parse_result load(const char_t* contents, unsigned int options = parse_default);
      
    xml_parse_result load_file(const char* path, unsigned int options = parse_default, 
                               xml_encoding encoding = encoding_auto);
    xml_parse_result load_file(const wchar_t* path, unsigned int options = parse_default, 
                               xml_encoding encoding = encoding_auto);
      
    xml_parse_result load_buffer(const void* contents, size_t size, unsigned int options = parse_default, 
                                 xml_encoding encoding = encoding_auto);
      

    xml_parse_result load_buffer_inplace(void* contents, size_t size, unsigned int options = parse_default, 
                                         xml_encoding encoding = encoding_auto);
      

    xml_parse_result load_buffer_inplace_own(void* contents, size_t size, unsigned int options = parse_default, 
                                             xml_encoding encoding = encoding_auto);
      
    void save(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), 
              unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
      
#ifndef PUGIXML_NO_STL

    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;
    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;
#endif
      
    bool save_file(const char* path, const char_t* indent = PUGIXML_TEXT("\t"), 
                   unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
    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;
      
    xml_node document_element() const;
  };
    
    
#ifndef PUGIXML_NO_XPATH

  enum xpath_value_type{
    xpath_type_none,      
    xpath_type_node_set,  
    xpath_type_number,    
    xpath_type_string,    
    xpath_type_boolean    
  };
    
    
  struct PUGIXML_CLASS xpath_parse_result{
    const char* error;
      
    ptrdiff_t offset;
      
    xpath_parse_result();
      
    operator bool() const;
      
    const char* description() const;
  };
    
    
  class PUGIXML_CLASS xpath_variable{
    friend class xpath_variable_set;
      
    protected:
    xpath_value_type _type;
    xpath_variable* _next;
      
    xpath_variable();
      
    xpath_variable(const xpath_variable&);
    xpath_variable& operator=(const xpath_variable&);
      
    public:
    const char_t* name() const;
      
    xpath_value_type type() const;
      
    bool get_boolean() const;
    double get_number() const;
    const char_t* get_string() const;
    const xpath_node_set& get_node_set() const;
      
    bool set(bool value);
    bool set(double value);
    bool set(const char_t* value);
    bool set(const xpath_node_set& value);
  };

    
  class PUGIXML_CLASS xpath_variable_set{
    private:
    xpath_variable* _data[64];
      
    xpath_variable_set(const xpath_variable_set&);
    xpath_variable_set& operator=(const xpath_variable_set&);
      
    xpath_variable* find(const char_t* name) const;
      
    public:
    xpath_variable_set();
    ~xpath_variable_set();
      
    xpath_variable* add(const char_t* name, xpath_value_type type);
      
    bool set(const char_t* name, bool value);
    bool set(const char_t* name, double value);
    bool set(const char_t* name, const char_t* value);
    bool set(const char_t* name, const xpath_node_set& value);
      
    xpath_variable* get(const char_t* name);
    const xpath_variable* get(const char_t* name) const;
  };
    
    
  class PUGIXML_CLASS xpath_query{
    private:
    void* _impl;
    xpath_parse_result _result;
      
    typedef void* xpath_query::*unspecified_bool_type;
      
    xpath_query(const xpath_query&);
    xpath_query& operator=(const xpath_query&);
      
    public:

    explicit xpath_query(const char_t* query, xpath_variable_set* variables = 0);
      
    ~xpath_query();
      
    xpath_value_type return_type() const;
      

    bool evaluate_boolean(const xpath_node& n) const;
      

    double evaluate_number(const xpath_node& n) const;
      
#ifndef PUGIXML_NO_STL


    string_t evaluate_string(const xpath_node& n) const;
#endif
      

    size_t evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const;
      

    xpath_node_set evaluate_node_set(const xpath_node& n) const;
      
    const xpath_parse_result& result() const;
      
    operator unspecified_bool_type() const;
      
    bool operator!() const;
  };
        

#ifndef PUGIXML_NO_EXCEPTIONS

  class PUGIXML_CLASS xpath_exception: public std::exception {
    private:
    xpath_parse_result _result;
      
    public:
    explicit xpath_exception(const xpath_parse_result& result);
      
    virtual const char* what() const throw();
      
    const xpath_parse_result& result() const;
  };
#endif
    
  class PUGIXML_CLASS xpath_node{
    private:
    xml_node _node;
    xml_attribute _attribute;
      
    typedef xml_node xpath_node::*unspecified_bool_type;
      
    public:
    xpath_node();
      
    xpath_node(const xml_node& node);
    xpath_node(const xml_attribute& attribute, const xml_node& parent);
      
    xml_node node() const;
    xml_attribute attribute() const;
      
    xml_node parent() const;
      
    operator unspecified_bool_type() const;
      
    bool operator!() const;
      
    bool operator==(const xpath_node& n) const;
    bool operator!=(const xpath_node& n) const;
  };

#ifdef __BORLANDC__

  bool PUGIXML_FUNCTION operator&&(const xpath_node& lhs, bool rhs);
  bool PUGIXML_FUNCTION operator||(const xpath_node& lhs, bool rhs);
#endif


  class PUGIXML_CLASS xpath_node_set{
    public:
    enum type_t{
      type_unsorted,                    
      type_sorted,                      
      type_sorted_reverse               
    };
      
    typedef const xpath_node* const_iterator;
      
    xpath_node_set();
      

    xpath_node_set(const_iterator begin, const_iterator end, type_t type = type_unsorted);
      
    ~xpath_node_set();
      
    xpath_node_set(const xpath_node_set& ns);
    xpath_node_set& operator=(const xpath_node_set& ns);
      
    type_t type() const;
      
    size_t size() const;
      
    const xpath_node& operator[](size_t index) const;
      
    const_iterator begin() const;
    const_iterator end() const;
      
    void sort(bool reverse = false);
      
    xpath_node first() const;
      
    bool empty() const;
      
    private:
    type_t _type;
      
    xpath_node _storage;
      
    xpath_node* _begin;
    xpath_node* _end;
      
    void _assign(const_iterator begin, const_iterator end);
  };
#endif
    
#ifndef PUGIXML_NO_STL

  std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const wchar_t* str);
  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);
    
  std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const char* str);
  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);
#endif
    
  typedef void* (*allocation_function)(size_t size);
    
  typedef void (*deallocation_function)(void* ptr);
    
  void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
    
  allocation_function PUGIXML_FUNCTION get_memory_allocation_function();
  deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function();
}

#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) || defined(__ICC))
namespace std
{
  std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_node_iterator&);
  std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_attribute_iterator&);
}
#endif

#if !defined(PUGIXML_NO_STL) && defined(__SUNPRO_CC)
namespace std
{
  std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_node_iterator&);
  std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_attribute_iterator&);
}
#endif

/*
 * Copyright (c) 2006-2010 Arseny Kapoulkine
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */