ptree.hpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// Copyright (C) 2002-2006 Marcin Kalicinski
// Copyright (C) 2009 Sebastian Redl
//
// Distributed under the Boost Software License, Version 1.0. 
// (See accompanying file LICENSE_1_0.txt or copy at 
// http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see www.boost.org
// ----------------------------------------------------------------------------
 
#ifndef BOOST_PROPERTY_TREE_PTREE_HPP_INCLUDED
#define BOOST_PROPERTY_TREE_PTREE_HPP_INCLUDED
 
#include <boost/property_tree/ptree_fwd.hpp>
#include <boost/property_tree/string_path.hpp>
#include <boost/property_tree/stream_translator.hpp>
#include <boost/property_tree/exceptions.hpp>
#include <boost/property_tree/detail/ptree_utils.hpp>
 
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/indexed_by.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/throw_exception.hpp>
#include <boost/optional.hpp>
#include <utility>                  // for std::pair
 
namespace boost { namespace property_tree
{
 
    template<class Key, class Data, class KeyCompare>
    class basic_ptree
    {
#if defined(BOOST_PROPERTY_TREE_DOXYGEN_INVOKED)
    public:
#endif
        // Internal types
        typedef basic_ptree<Key, Data, KeyCompare> self_type;
 
    public:
        // Basic types
        typedef Key                                  key_type;
        typedef Data                                 data_type;
        typedef KeyCompare                           key_compare;
 
        // Container view types
        typedef std::pair<const Key, self_type>      value_type;
        typedef std::size_t                          size_type;
 
        // The problem with the iterators is that I can't make them complete
        // until the container is complete. Sucks. Especially for the reverses.
        class iterator;
        class const_iterator;
        class reverse_iterator;
        class const_reverse_iterator;
 
        // Associative view types
        class assoc_iterator;
        class const_assoc_iterator;
 
        // Property tree view types
        typedef typename path_of<Key>::type          path_type;
 
 
        // The big five
 
        basic_ptree();
        explicit basic_ptree(const data_type &data);
        basic_ptree(const self_type &rhs);
        ~basic_ptree();
        self_type &operator =(const self_type &rhs);
 
        void swap(self_type &rhs);
 
        // Container view functions
 
        size_type size() const;
        size_type max_size() const;
        bool empty() const;
 
        iterator begin();
        const_iterator begin() const;
        iterator end();
        const_iterator end() const;
        reverse_iterator rbegin();
        const_reverse_iterator rbegin() const;
        reverse_iterator rend();
        const_reverse_iterator rend() const;
 
        value_type &front();
        const value_type &front() const;
        value_type &back();
        const value_type &back() const;
 
        iterator insert(iterator where, const value_type &value);
 
        template<class It> void insert(iterator where, It first, It last);
 
        iterator erase(iterator where);
 
        iterator erase(iterator first, iterator last);
 
        iterator push_front(const value_type &value);
 
        iterator push_back(const value_type &value);
 
        void pop_front();
 
        void pop_back();
 
        void reverse();
 
        template<class Compare> void sort(Compare comp);
 
        void sort();
 
        // Equality
 
        bool operator ==(const self_type &rhs) const;
        bool operator !=(const self_type &rhs) const;
 
        // Associative view
 
        assoc_iterator ordered_begin();
        const_assoc_iterator ordered_begin() const;
 
        assoc_iterator not_found();
        const_assoc_iterator not_found() const;
 
        assoc_iterator find(const key_type &key);
 
        const_assoc_iterator find(const key_type &key) const;
 
        std::pair<assoc_iterator, assoc_iterator>
            equal_range(const key_type &key);
 
        std::pair<const_assoc_iterator, const_assoc_iterator>
            equal_range(const key_type &key) const;
 
        size_type count(const key_type &key) const;
 
        size_type erase(const key_type &key);
 
        iterator to_iterator(assoc_iterator it);
 
        const_iterator to_iterator(const_assoc_iterator it) const;
 
        // Property tree view
 
        data_type &data();
 
        const data_type &data() const;
 
        void clear();
 
        self_type &get_child(const path_type &path);
 
        const self_type &get_child(const path_type &path) const;
 
        self_type &get_child(const path_type &path, self_type &default_value);
 
        const self_type &get_child(const path_type &path,
                                   const self_type &default_value) const;
 
        optional<self_type &> get_child_optional(const path_type &path);
 
        optional<const self_type &>
          get_child_optional(const path_type &path) const;
 
        self_type &put_child(const path_type &path, const self_type &value);
 
        self_type &add_child(const path_type &path, const self_type &value);
 
        template<class Type, class Translator>
        typename boost::enable_if<detail::is_translator<Translator>, Type>::type
        get_value(Translator tr) const;
 
        template<class Type>
        Type get_value() const;
 
        template<class Type, class Translator>
        Type get_value(const Type &default_value, Translator tr) const;
 
        template <class Ch, class Translator>
        typename boost::enable_if<
            detail::is_character<Ch>,
            std::basic_string<Ch>
        >::type
        get_value(const Ch *default_value, Translator tr) const;
 
        template<class Type>
        typename boost::disable_if<detail::is_translator<Type>, Type>::type
        get_value(const Type &default_value) const;
 
        template <class Ch>
        typename boost::enable_if<
            detail::is_character<Ch>,
            std::basic_string<Ch>
        >::type
        get_value(const Ch *default_value) const;
 
        template<class Type, class Translator>
        optional<Type> get_value_optional(Translator tr) const;
 
        template<class Type>
        optional<Type> get_value_optional() const;
 
        template<class Type, class Translator>
        void put_value(const Type &value, Translator tr);
 
        template<class Type>
        void put_value(const Type &value);
 
        template<class Type, class Translator>
        typename boost::enable_if<detail::is_translator<Translator>, Type>::type
        get(const path_type &path, Translator tr) const;
 
        template<class Type>
        Type get(const path_type &path) const;
 
        template<class Type, class Translator>
        Type get(const path_type &path,
                 const Type &default_value,
                 Translator tr) const;
 
        template <class Ch, class Translator>
        typename boost::enable_if<
            detail::is_character<Ch>,
            std::basic_string<Ch>
        >::type
        get(const path_type &path, const Ch *default_value, Translator tr)const;
 
        template<class Type>
        typename boost::disable_if<detail::is_translator<Type>, Type>::type
        get(const path_type &path, const Type &default_value) const;
 
        template <class Ch>
        typename boost::enable_if<
            detail::is_character<Ch>,
            std::basic_string<Ch>
        >::type
        get(const path_type &path, const Ch *default_value) const;
 
        template<class Type, class Translator>
        optional<Type> get_optional(const path_type &path, Translator tr) const;
 
        template<class Type>
        optional<Type> get_optional(const path_type &path) const;
 
        template<class Type, class Translator>
        self_type &put(const path_type &path, const Type &value, Translator tr);
 
        template<class Type>
        self_type &put(const path_type &path, const Type &value);
 
        template<class Type, class Translator>
        self_type &add(const path_type &path,
                       const Type &value,
                       Translator tr);
 
        template<class Type>
        self_type &add(const path_type &path, const Type &value);
 
    private:
        // Hold the data of this node
        data_type m_data;
        // Hold the children - this is a void* because we can't complete the
        // container type within the class.
        void* m_children;
 
        // Getter tree-walk. Not const-safe! Gets the node the path refers to,
        // or null. Destroys p's value.
        self_type* walk_path(path_type& p) const;
 
        // Modifer tree-walk. Gets the parent of the node referred to by the
        // path, creating nodes as necessary. p is the path to the remaining
        // child.
        self_type& force_path(path_type& p);
 
        // This struct contains typedefs for the concrete types.
        struct subs;
        friend struct subs;
        friend class iterator;
        friend class const_iterator;
        friend class reverse_iterator;
        friend class const_reverse_iterator;
    };
 
}}
 
#include <boost/property_tree/detail/ptree_implementation.hpp>
 
#endif