manual.qbk

    * `bool `[link xml_node::comparison operator<]`(const xml_node& r) const;`
    * `bool `[link xml_node::comparison operator>]`(const xml_node& r) const;`
    * `bool `[link xml_node::comparison operator<=]`(const xml_node& r) const;`
    * `bool `[link xml_node::comparison operator>=]`(const xml_node& r) const;`
    [lbr]

    * `size_t `[link xml_node::hash_value hash_value]`() const;`
    [lbr]

    * `xml_node_type `[link xml_node::type type]`() const;`
    [lbr]

    * `const char_t* `[link xml_node::name name]`() const;`
    * `const char_t* `[link xml_node::value value]`() const;`
    [lbr]

    * `xml_node `[link xml_node::parent parent]`() const;`
    * `xml_node `[link xml_node::first_child first_child]`() const;`
    * `xml_node `[link xml_node::last_child last_child]`() const;`
    * `xml_node `[link xml_node::next_sibling next_sibling]`() const;`
    * `xml_node `[link xml_node::previous_sibling previous_sibling]`() const;`
    [lbr]

    * `xml_attribute `[link xml_node::first_attribute first_attribute]`() const;`
    * `xml_attribute `[link xml_node::last_attribute last_attribute]`() const;`
    [lbr]

    * `xml_node `[link xml_node::child child]`(const char_t* name) const;`
    * `xml_attribute `[link xml_node::attribute attribute]`(const char_t* name) const;`
    * `xml_node `[link xml_node::next_sibling_name next_sibling]`(const char_t* name) const;`
    * `xml_node `[link xml_node::previous_sibling_name previous_sibling]`(const char_t* name) const;`
    * `xml_node `[link xml_node::find_child_by_attribute find_child_by_attribute]`(const char_t* name, const char_t* attr_name, const char_t* attr_value) const;`
    * `xml_node `[link xml_node::find_child_by_attribute find_child_by_attribute]`(const char_t* attr_name, const char_t* attr_value) const;`
    [lbr]

    * `const char_t* `[link xml_node::child_value child_value]`() const;`
    * `const char_t* `[link xml_node::child_value child_value]`(const char_t* name) const;`
    [lbr]

    * `typedef xml_node_iterator `[link xml_node_iterator iterator]`;`
    * `iterator `[link xml_node::begin begin]`() const;`
    * `iterator `[link xml_node::end end]`() const;`
    [lbr]

    * `typedef xml_attribute_iterator `[link xml_attribute_iterator attribute_iterator]`;`
    * `attribute_iterator `[link xml_node::attributes_begin attributes_begin]`() const;`
    * `attribute_iterator `[link xml_node::attributes_end attributes_end]`() const;`
    [lbr]

    * `bool `[link xml_node::traverse traverse]`(xml_tree_walker& walker);`
    [lbr]

    * `template <typename Predicate> xml_attribute `[link xml_node::find_attribute find_attribute]`(Predicate pred) const;`
    * `template <typename Predicate> xml_node `[link xml_node::find_child find_child]`(Predicate pred) const;`
    * `template <typename Predicate> xml_node `[link xml_node::find_node find_node]`(Predicate pred) const;`
    [lbr]

    * `string_t `[link xml_node::path path]`(char_t delimiter = '/') const;`
    * `xml_node `[link xml_node::first_element_by_path]`(const char_t* path, char_t delimiter = '/') const;`
    * `xml_node `[link xml_node::root root]`() const;`
    * `ptrdiff_t `[link xml_node::offset_debug offset_debug]`() const;`
    [lbr]

    * `bool `[link xml_node::set_name set_name]`(const char_t* rhs);`
    * `bool `[link xml_node::set_value set_value]`(const char_t* rhs);`
    [lbr]

    * `xml_attribute `[link xml_node::append_attribute append_attribute]`(const char_t* name);`
    * `xml_attribute `[link xml_node::prepend_attribute prepend_attribute]`(const char_t* name);`
    * `xml_attribute `[link xml_node::insert_attribute_after insert_attribute_after]`(const char_t* name, const xml_attribute& attr);`
    * `xml_attribute `[link xml_node::insert_attribute_before insert_attribute_before]`(const char_t* name, const xml_attribute& attr);`
    [lbr]

    * `xml_node `[link xml_node::append_child append_child]`(xml_node_type type = node_element);`
    * `xml_node `[link xml_node::prepend_child prepend_child]`(xml_node_type type = node_element);`
    * `xml_node `[link xml_node::insert_child_after insert_child_after]`(xml_node_type type, const xml_node& node);`
    * `xml_node `[link xml_node::insert_child_before insert_child_before]`(xml_node_type type, const xml_node& node);`
    [lbr]

    * `xml_attribute `[link xml_node::append_copy append_copy]`(const xml_attribute& proto);`
    * `xml_attribute `[link xml_node::prepend_copy prepend_copy]`(const xml_attribute& proto);`
    * `xml_attribute `[link xml_node::insert_copy_after insert_copy_after]`(const xml_attribute& proto, const xml_attribute& attr);`
    * `xml_attribute `[link xml_node::insert_copy_before insert_copy_before]`(const xml_attribute& proto, const xml_attribute& attr);`
    [lbr]

    * `xml_node `[link xml_node::append_copy append_copy]`(const xml_node& proto);`
    * `xml_node `[link xml_node::prepend_copy prepend_copy]`(const xml_node& proto);`
    * `xml_node `[link xml_node::insert_copy_after insert_copy_after]`(const xml_node& proto, const xml_node& node);`
    * `xml_node `[link xml_node::insert_copy_before insert_copy_before]`(const xml_node& proto, const xml_node& node);`
    [lbr]

    * `bool `[link xml_node::remove_attribute remove_attribute]`(const xml_attribute& a);`
    * `bool `[link xml_node::remove_attribute remove_attribute]`(const char_t* name);`
    * `bool `[link xml_node::remove_child remove_child]`(const xml_node& n);`
    * `bool `[link xml_node::remove_child remove_child]`(const char_t* name);`
    [lbr]

    * `void `[link xml_node::print print]`(xml_writer& writer, const char_t* indent = "\t", unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;`
    * `void `[link xml_node::print_stream print]`(std::ostream& os, const char_t* indent = "\t", unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;`
    * `void `[link xml_node::print_stream print]`(std::wostream& os, const char_t* indent = "\t", unsigned int flags = format_default, unsigned int depth = 0) const;`
    [lbr]

    * `xpath_node `[link xml_node::select_single_node select_single_node]`(const char_t* query, xpath_variable_set* variables = 0) const;`
    * `xpath_node `[link xml_node::select_single_node_precomp select_single_node]`(const xpath_query& query) const;`
    * `xpath_node_set `[link xml_node::select_nodes select_nodes]`(const char_t* query, xpath_variable_set* variables = 0) const;`
    * `xpath_node_set `[link xml_node::select_nodes_precomp select_nodes]`(const xpath_query& query) const;`
    [lbr]

* `class `[link xml_document]
    * [link xml_document::ctor xml_document]`();`
    * `~`[link xml_document::dtor xml_document]`();`
    [lbr]

    * `xml_parse_result `[link xml_document::load_stream load]`(std::istream& stream, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);`
    * `xml_parse_result `[link xml_document::load_stream load]`(std::wistream& stream, unsigned int options = parse_default);`
    [lbr]

    * `xml_parse_result `[link xml_document::load_string load]`(const char_t* contents, unsigned int options = parse_default);`
    [lbr]

    * `xml_parse_result `[link xml_document::load_file load_file]`(const char* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);`
    * `xml_parse_result `[link xml_document::load_file_wide load_file]`(const wchar_t* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);`
    [lbr]

    * `xml_parse_result `[link xml_document::load_buffer load_buffer]`(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);`
    * `xml_parse_result `[link xml_document::load_buffer_inplace load_buffer_inplace]`(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);`
    * `xml_parse_result `[link xml_document::load_buffer_inplace_own load_buffer_inplace_own]`(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);`
    [lbr]

    * `bool `[link xml_document::save_file save_file]`(const char* path, const char_t* indent = "\t", unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;`
    * `bool `[link xml_document::save_file_wide save_file]`(const wchar_t* path, const char_t* indent = "\t", unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;`
    [lbr]

    * `void `[link xml_document::save_stream save]`(std::ostream& stream, const char_t* indent = "\t", unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;`
    * `void `[link xml_document::save_stream save]`(std::wostream& stream, const char_t* indent = "\t", unsigned int flags = format_default) const;`
    [lbr]

    * `void `[link xml_document::save save]`(xml_writer& writer, const char_t* indent = "\t", unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;`
    [lbr]

    * `xml_node `[link xml_document::document_element document_element]`() const;`
    [lbr]

* `struct `[link xml_parse_result]
    * `xml_parse_status `[link xml_parse_result::status status]`;`
    * `ptrdiff_t `[link xml_parse_result::offset offset]`;`
    * `xml_encoding `[link xml_parse_result::encoding encoding]`;`
    [lbr]

    * `operator `[link xml_parse_result::bool bool]`() const;`
    * `const char* `[link xml_parse_result::description description]`() const;`
    [lbr]

* `class `[link xml_node_iterator]
* `class `[link xml_attribute_iterator]
[lbr]

* `class `[link xml_tree_walker]
    * `virtual bool `[link xml_tree_walker::begin begin]`(xml_node& node);`
    * `virtual bool `[link xml_tree_walker::for_each for_each]`(xml_node& node) = 0;`
    * `virtual bool `[link xml_tree_walker::end end]`(xml_node& node);`
    [lbr]

    * `int `[link xml_tree_walker::depth depth]`() const;`
    [lbr]

* `class `[link xml_writer]
    * `virtual void `[link xml_writer::write write]`(const void* data, size_t size) = 0;`
    [lbr]

* `class `[link xml_writer_file]`: public xml_writer`
    * [link xml_writer_file]`(void* file);`
    [lbr]

* `class `[link xml_writer_stream]`: public xml_writer`
    * [link xml_writer_stream]`(std::ostream& stream);`
    * [link xml_writer_stream]`(std::wostream& stream);`
    [lbr]

* `struct `[link xpath_parse_result]
    * `const char* `[link xpath_parse_result::error error]`;`
    * `ptrdiff_t `[link xpath_parse_result::offset offset]`;`

    * `operator `[link xpath_parse_result::bool bool]`() const;`
    * `const char* `[link xpath_parse_result::description description]`() const;`
	[lbr]

* `class `[link xpath_query]
    * `explicit `[link xpath_query::ctor xpath_query]`(const char_t* query, xpath_variable_set* variables = 0);`
    [lbr]

    * `bool `[link xpath_query::evaluate_boolean evaluate_boolean]`(const xpath_node& n) const;`
    * `double `[link xpath_query::evaluate_number evaluate_number]`(const xpath_node& n) const;`
    * `string_t `[link xpath_query::evaluate_string evaluate_string]`(const xpath_node& n) const;`
	* `size_t `[link xpath_query::evaluate_string_buffer evaluate_string]`(char_t* buffer, size_t capacity, const xpath_node& n) const;`
    * `xpath_node_set `[link xpath_query::evaluate_node_set evaluate_node_set]`(const xpath_node& n) const;`
    [lbr]

    * `xpath_value_type `[link xpath_query::return_type return_type]`() const;`
    [lbr]

    * `const xpath_parse_result& `[link xpath_query::result result]`() const;`
	* `operator `[link xpath_query::unspecified_bool_type unspecified_bool_type]`() const;`
    [lbr]

* `class `[link xpath_exception]`: public std::exception`
    * `virtual const char* `[link xpath_exception::what what]`() const throw();`
    [lbr]

	* `const xpath_parse_result& `[link xpath_exception::result result]`() const;`
    [lbr]

* `class `[link xpath_node]
    * [link xpath_node::ctor xpath_node]`();`
    * [link xpath_node::ctor xpath_node]`(const xml_node& node);`
    * [link xpath_node::ctor xpath_node]`(const xml_attribute& attribute, const xml_node& parent);`
    [lbr]

    * `xml_node `[link xpath_node::node node]`() const;`
    * `xml_attribute `[link xpath_node::attribute attribute]`() const;`
    * `xml_node `[link xpath_node::parent parent]`() const;`
    [lbr]

    * `operator `[link xpath_node::unspecified_bool_type unspecified_bool_type]`() const;`
    * `bool `[link xpath_node::comparison operator==]`(const xpath_node& n) const;`
    * `bool `[link xpath_node::comparison operator!=]`(const xpath_node& n) const;`
    [lbr]

* `class `[link xpath_node_set]
	* [link xpath_node_set::ctor xpath_node_set]`();`
	* [link xpath_node_set::ctor xpath_node_set]`(const_iterator begin, const_iterator end, type_t type = type_unsorted);`
    [lbr]

    * `typedef const xpath_node* `[link xpath_node_set::const_iterator const_iterator]`;`
    * `const_iterator `[link xpath_node_set::begin begin]`() const;`
    * `const_iterator `[link xpath_node_set::end end]`() const;`
    [lbr]

    * `const xpath_node& `[link xpath_node_set::index operator\[\]]`(size_t index) const;`
    * `size_t `[link xpath_node_set::size size]`() const;`
    * `bool `[link xpath_node_set::empty empty]`() const;`
    [lbr]

    * `xpath_node `[link xpath_node_set::first first]`() const;`
    [lbr]

    * `enum type_t {`[link xpath_node_set::type_unsorted type_unsorted], [link xpath_node_set::type_sorted type_sorted], [link xpath_node_set::type_sorted_reverse type_sorted_reverse]`};`
    * `type_t `[link xpath_node_set::type type]`() const;`
    * `void `[link xpath_node_set::sort sort]`(bool reverse = false);`
    [lbr]

* `class `[link xpath_variable]
    * `const char_t* `[link xpath_variable::name name]`() const;`
    * `xpath_value_type `[link xpath_variable::type type]`() const;`
    [lbr]

    * `bool `[link xpath_variable::get_boolean get_boolean]`() const;`
    * `double `[link xpath_variable::get_number get_number]`() const;`
    * `const char_t* `[link xpath_variable::get_string get_string]`() const;`
    * `const xpath_node_set& `[link xpath_variable::get_node_set get_node_set]`() const;`
    [lbr]

    * `bool `[link xpath_variable::set set]`(bool value);`
    * `bool `[link xpath_variable::set set]`(double value);`
    * `bool `[link xpath_variable::set set]`(const char_t* value);`
    * `bool `[link xpath_variable::set set]`(const xpath_node_set& value);`
    [lbr]

* `class `[link xpath_variable_set]
    * `xpath_variable* `[link xpath_variable_set::add add]`(const char_t* name, xpath_value_type type);`
    [lbr]

    * `bool `[link xpath_variable_set::set set]`(const char_t* name, bool value);`
    * `bool `[link xpath_variable_set::set set]`(const char_t* name, double value);`
    * `bool `[link xpath_variable_set::set set]`(const char_t* name, const char_t* value);`
    * `bool `[link xpath_variable_set::set set]`(const char_t* name, const xpath_node_set& value);`
    [lbr]

    * `xpath_variable* `[link xpath_variable_set::get get]`(const char_t* name);`
    * `const xpath_variable* `[link xpath_variable_set::get get]`(const char_t* name) const;`
    [lbr]

Functions:

* `std::string `[link as_utf8]`(const wchar_t* str);`
* `std::string `[link as_utf8]`(const std::wstring& str);`
* `std::wstring `[link as_wide]`(const char* str);`
* `std::wstring `[link as_wide]`(const std::string& str);`
* `void `[link set_memory_management_functions]`(allocation_function allocate, deallocation_function deallocate);`
* `allocation_function `[link get_memory_allocation_function]`();`
* `deallocation_function `[link get_memory_deallocation_function]`();`

[endsect] [/apiref]

[section:toc Table of Contents]

toc-placeholder

[endsect] [/toc]

[/ vim:et ]