1 files changed, 0 insertions, 905 deletions
diff --git a/3rdParty/Boost/src/boost/property_tree/detail/ptree_implementation.hpp b/3rdParty/Boost/src/boost/property_tree/detail/ptree_implementation.hpp
deleted file mode 100644
index 4220002..0000000
--- a/3rdParty/Boost/src/boost/property_tree/detail/ptree_implementation.hpp
+++ /dev/null
@@ -1,905 +0,0 @@
-// ----------------------------------------------------------------------------
-// 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_DETAIL_PTREE_IMPLEMENTATION_HPP_INCLUDED
-#define BOOST_PROPERTY_TREE_DETAIL_PTREE_IMPLEMENTATION_HPP_INCLUDED
-
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <memory>
-#include <cassert>
-
-#if defined(BOOST_MSVC) && \
-    (_MSC_FULL_VER >= 160000000 && _MSC_FULL_VER < 170000000)
-#define BOOST_PROPERTY_TREE_PAIR_BUG
-#endif
-
-namespace boost { namespace property_tree
-{
-    template <class K, class D, class C>
-    struct basic_ptree<K, D, C>::subs
-    {
-        struct by_name {};
-        // The actual child container.
-#if defined(BOOST_PROPERTY_TREE_PAIR_BUG)
-        // MSVC 10 has moved std::pair's members to a base
-        // class. Unfortunately this does break the interface.
-        BOOST_STATIC_CONSTANT(unsigned,
-            first_offset = offsetof(value_type, first));
-        typedef multi_index_container<value_type,
-            multi_index::indexed_by<
-                multi_index::sequenced<>,
-                multi_index::ordered_non_unique<multi_index::tag<by_name>,
-                    multi_index::member_offset<value_type, const key_type,
-                                        first_offset>,
-                    key_compare
-                >
-            >
-        > base_container;
-#else
-        typedef multi_index_container<value_type,
-            multi_index::indexed_by<
-                multi_index::sequenced<>,
-                multi_index::ordered_non_unique<multi_index::tag<by_name>,
-                    multi_index::member<value_type, const key_type,
-                                        &value_type::first>,
-                    key_compare
-                >
-            >
-        > base_container;
-#endif
-        // The by-name lookup index.
-        typedef typename base_container::template index<by_name>::type
-            by_name_index;
-
-        // Access functions for getting to the children of a tree.
-        static base_container& ch(self_type *s) {
-            return *static_cast<base_container*>(s->m_children);
-        }
-        static const base_container& ch(const self_type *s) {
-            return *static_cast<const base_container*>(s->m_children);
-        }
-        static by_name_index& assoc(self_type *s) {
-            return ch(s).BOOST_NESTED_TEMPLATE get<by_name>();
-        }
-        static const by_name_index& assoc(const self_type *s) {
-            return ch(s).BOOST_NESTED_TEMPLATE get<by_name>();
-        }
-    };
-    template <class K, class D, class C>
-    class basic_ptree<K, D, C>::iterator : public boost::iterator_adaptor<
-        iterator, typename subs::base_container::iterator, value_type>
-    {
-        friend class boost::iterator_core_access;
-        typedef boost::iterator_adaptor<
-            iterator, typename subs::base_container::iterator, value_type>
-            baset;
-    public:
-        typedef typename baset::reference reference;
-        iterator() {}
-        explicit iterator(typename iterator::base_type b)
-            : iterator::iterator_adaptor_(b)
-        {}
-        reference dereference() const
-        {
-            // multi_index doesn't allow modification of its values, because
-            // indexes could sort by anything, and modification screws that up.
-            // However, we only sort by the key, and it's protected against
-            // modification in the value_type, so this const_cast is safe.
-            return const_cast<reference>(*this->base_reference());
-        }
-    };
-    template <class K, class D, class C>
-    class basic_ptree<K, D, C>::const_iterator : public boost::iterator_adaptor<
-        const_iterator, typename subs::base_container::const_iterator>
-    {
-    public:
-        const_iterator() {}
-        explicit const_iterator(typename const_iterator::base_type b)
-            : const_iterator::iterator_adaptor_(b)
-        {}
-        const_iterator(iterator b)
-            : const_iterator::iterator_adaptor_(b.base())
-        {}
-    };
-    template <class K, class D, class C>
-    class basic_ptree<K, D, C>::reverse_iterator
-        : public boost::reverse_iterator<iterator>
-    {
-    public:
-        reverse_iterator() {}
-        explicit reverse_iterator(iterator b)
-            : boost::reverse_iterator<iterator>(b)
-        {}
-    };
-    template <class K, class D, class C>
-    class basic_ptree<K, D, C>::const_reverse_iterator
-        : public boost::reverse_iterator<const_iterator>
-    {
-    public:
-        const_reverse_iterator() {}
-        explicit const_reverse_iterator(const_iterator b)
-            : boost::reverse_iterator<const_iterator>(b)
-        {}
-        const_reverse_iterator(
-            typename basic_ptree<K, D, C>::reverse_iterator b)
-            : boost::reverse_iterator<const_iterator>(b)
-        {}
-    };
-    template <class K, class D, class C>
-    class basic_ptree<K, D, C>::assoc_iterator
-        : public boost::iterator_adaptor<assoc_iterator,
-                                         typename subs::by_name_index::iterator,
-                                         value_type>
-    {
-        friend class boost::iterator_core_access;
-        typedef boost::iterator_adaptor<assoc_iterator,
-                                         typename subs::by_name_index::iterator,
-                                         value_type>
-            baset;
-    public:
-        typedef typename baset::reference reference;
-        assoc_iterator() {}
-        explicit assoc_iterator(typename assoc_iterator::base_type b)
-            : assoc_iterator::iterator_adaptor_(b)
-        {}
-        reference dereference() const
-        {
-            return const_cast<reference>(*this->base_reference());
-        }
-    };
-    template <class K, class D, class C>
-    class basic_ptree<K, D, C>::const_assoc_iterator
-        : public boost::iterator_adaptor<const_assoc_iterator,
-                                   typename subs::by_name_index::const_iterator>
-    {
-    public:
-        const_assoc_iterator() {}
-        explicit const_assoc_iterator(
-            typename const_assoc_iterator::base_type b)
-            : const_assoc_iterator::iterator_adaptor_(b)
-        {}
-        const_assoc_iterator(assoc_iterator b)
-            : const_assoc_iterator::iterator_adaptor_(b.base())
-        {}
-    };
-
-
-    // Big five
-
-    // Perhaps the children collection could be created on-demand only, to
-    // reduce heap traffic. But that's a lot more work to implement.
-
-    template<class K, class D, class C> inline
-    basic_ptree<K, D, C>::basic_ptree()
-        : m_children(new typename subs::base_container)
-    {
-    }
-
-    template<class K, class D, class C> inline
-    basic_ptree<K, D, C>::basic_ptree(const data_type &d)
-        : m_data(d), m_children(new typename subs::base_container)
-    {
-    }
-
-    template<class K, class D, class C> inline
-    basic_ptree<K, D, C>::basic_ptree(const basic_ptree<K, D, C> &rhs)
-        : m_data(rhs.m_data),
-          m_children(new typename subs::base_container(subs::ch(&rhs)))
-    {
-    }
-
-    template<class K, class D, class C>
-    basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::operator =(const basic_ptree<K, D, C> &rhs)
-    {
-        self_type(rhs).swap(*this);
-        return *this;
-    }
-
-    template<class K, class D, class C>
-    basic_ptree<K, D, C>::~basic_ptree()
-    {
-        delete &subs::ch(this);
-    }
-
-    template<class K, class D, class C> inline
-    void basic_ptree<K, D, C>::swap(basic_ptree<K, D, C> &rhs)
-    {
-        m_data.swap(rhs.m_data);
-        // Void pointers, no ADL necessary
-        std::swap(m_children, rhs.m_children);
-    }
-
-    // Container view
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::size_type
-        basic_ptree<K, D, C>::size() const
-    {
-        return subs::ch(this).size();
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::size_type
-        basic_ptree<K, D, C>::max_size() const
-    {
-        return subs::ch(this).max_size();
-    }
-
-    template<class K, class D, class C> inline
-    bool basic_ptree<K, D, C>::empty() const
-    {
-        return subs::ch(this).empty();
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::iterator
-        basic_ptree<K, D, C>::begin()
-    {
-        return iterator(subs::ch(this).begin());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::const_iterator
-        basic_ptree<K, D, C>::begin() const
-    {
-        return const_iterator(subs::ch(this).begin());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::iterator
-        basic_ptree<K, D, C>::end()
-    {
-        return iterator(subs::ch(this).end());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::const_iterator
-        basic_ptree<K, D, C>::end() const
-    {
-        return const_iterator(subs::ch(this).end());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::reverse_iterator
-        basic_ptree<K, D, C>::rbegin()
-    {
-        return reverse_iterator(this->end());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::const_reverse_iterator
-        basic_ptree<K, D, C>::rbegin() const
-    {
-        return const_reverse_iterator(this->end());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::reverse_iterator
-        basic_ptree<K, D, C>::rend()
-    {
-        return reverse_iterator(this->begin());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::const_reverse_iterator
-        basic_ptree<K, D, C>::rend() const
-    {
-        return const_reverse_iterator(this->begin());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::value_type &
-        basic_ptree<K, D, C>::front()
-    {
-        return const_cast<value_type&>(subs::ch(this).front());
-    }
-
-    template<class K, class D, class C> inline
-    const typename basic_ptree<K, D, C>::value_type &
-        basic_ptree<K, D, C>::front() const
-    {
-        return subs::ch(this).front();
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::value_type &
-        basic_ptree<K, D, C>::back()
-    {
-        return const_cast<value_type&>(subs::ch(this).back());
-    }
-
-    template<class K, class D, class C> inline
-    const typename basic_ptree<K, D, C>::value_type &
-        basic_ptree<K, D, C>::back() const
-    {
-        return subs::ch(this).back();
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::iterator
-    basic_ptree<K, D, C>::insert(iterator where, const value_type &value)
-    {
-        return iterator(subs::ch(this).insert(where.base(), value).first);
-    }
-
-    template<class K, class D, class C>
-    template<class It> inline
-    void basic_ptree<K, D, C>::insert(iterator where, It first, It last)
-    {
-        subs::ch(this).insert(where.base(), first, last);
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::iterator
-        basic_ptree<K, D, C>::erase(iterator where)
-    {
-        return iterator(subs::ch(this).erase(where.base()));
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::iterator
-        basic_ptree<K, D, C>::erase(iterator first, iterator last)
-    {
-        return iterator(subs::ch(this).erase(first.base(), last.base()));
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::iterator
-        basic_ptree<K, D, C>::push_front(const value_type &value)
-    {
-        return iterator(subs::ch(this).push_front(value).first);
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::iterator
-        basic_ptree<K, D, C>::push_back(const value_type &value)
-    {
-        return iterator(subs::ch(this).push_back(value).first);
-    }
-
-    template<class K, class D, class C> inline
-    void basic_ptree<K, D, C>::pop_front()
-    {
-        subs::ch(this).pop_front();
-    }
-
-    template<class K, class D, class C> inline
-    void basic_ptree<K, D, C>::pop_back()
-    {
-        subs::ch(this).pop_back();
-    }
-
-    template<class K, class D, class C> inline
-    void basic_ptree<K, D, C>::reverse()
-    {
-        subs::ch(this).reverse();
-    }
-
-    template<class K, class D, class C> inline
-    void basic_ptree<K, D, C>::sort()
-    {
-        subs::ch(this).sort();
-    }
-
-    template<class K, class D, class C>
-    template<class Compare> inline
-    void basic_ptree<K, D, C>::sort(Compare comp)
-    {
-        subs::ch(this).sort(comp);
-    }
-
-    // Equality
-
-    template<class K, class D, class C> inline
-    bool basic_ptree<K, D, C>::operator ==(
-                                  const basic_ptree<K, D, C> &rhs) const
-    {
-        // The size test is cheap, so add it as an optimization
-        return size() == rhs.size() && data() == rhs.data() &&
-            subs::ch(this) == subs::ch(&rhs);
-    }
-
-    template<class K, class D, class C> inline
-    bool basic_ptree<K, D, C>::operator !=(
-                                  const basic_ptree<K, D, C> &rhs) const
-    {
-        return !(*this == rhs);
-    }
-
-    // Associative view
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::assoc_iterator
-        basic_ptree<K, D, C>::ordered_begin()
-    {
-        return assoc_iterator(subs::assoc(this).begin());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::const_assoc_iterator
-        basic_ptree<K, D, C>::ordered_begin() const
-    {
-        return const_assoc_iterator(subs::assoc(this).begin());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::assoc_iterator
-        basic_ptree<K, D, C>::not_found()
-    {
-        return assoc_iterator(subs::assoc(this).end());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::const_assoc_iterator
-        basic_ptree<K, D, C>::not_found() const
-    {
-        return const_assoc_iterator(subs::assoc(this).end());
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::assoc_iterator
-        basic_ptree<K, D, C>::find(const key_type &key)
-    {
-        return assoc_iterator(subs::assoc(this).find(key));
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::const_assoc_iterator
-        basic_ptree<K, D, C>::find(const key_type &key) const
-    {
-        return const_assoc_iterator(subs::assoc(this).find(key));
-    }
-
-    template<class K, class D, class C> inline
-    std::pair<
-        typename basic_ptree<K, D, C>::assoc_iterator,
-        typename basic_ptree<K, D, C>::assoc_iterator
-    > basic_ptree<K, D, C>::equal_range(const key_type &key)
-    {
-        std::pair<typename subs::by_name_index::iterator,
-                  typename subs::by_name_index::iterator> r(
-            subs::assoc(this).equal_range(key));
-        return std::pair<assoc_iterator, assoc_iterator>(
-          assoc_iterator(r.first), assoc_iterator(r.second));
-    }
-
-    template<class K, class D, class C> inline
-    std::pair<
-        typename basic_ptree<K, D, C>::const_assoc_iterator,
-        typename basic_ptree<K, D, C>::const_assoc_iterator
-    > basic_ptree<K, D, C>::equal_range(const key_type &key) const
-    {
-        std::pair<typename subs::by_name_index::const_iterator,
-                  typename subs::by_name_index::const_iterator> r(
-            subs::assoc(this).equal_range(key));
-        return std::pair<const_assoc_iterator, const_assoc_iterator>(
-            const_assoc_iterator(r.first), const_assoc_iterator(r.second));
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::size_type
-        basic_ptree<K, D, C>::count(const key_type &key) const
-    {
-        return subs::assoc(this).count(key);
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::size_type
-        basic_ptree<K, D, C>::erase(const key_type &key)
-    {
-        return subs::assoc(this).erase(key);
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::iterator
-        basic_ptree<K, D, C>::to_iterator(assoc_iterator ai)
-    {
-        return iterator(subs::ch(this).
-            BOOST_NESTED_TEMPLATE project<0>(ai.base()));
-    }
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::const_iterator
-        basic_ptree<K, D, C>::to_iterator(const_assoc_iterator ai) const
-    {
-        return const_iterator(subs::ch(this).
-            BOOST_NESTED_TEMPLATE project<0>(ai.base()));
-    }
-
-    // Property tree view
-
-    template<class K, class D, class C> inline
-    typename basic_ptree<K, D, C>::data_type &
-        basic_ptree<K, D, C>::data()
-    {
-        return m_data;
-    }
-
-    template<class K, class D, class C> inline
-    const typename basic_ptree<K, D, C>::data_type &
-        basic_ptree<K, D, C>::data() const
-    {
-        return m_data;
-    }
-
-    template<class K, class D, class C> inline
-    void basic_ptree<K, D, C>::clear()
-    {
-        m_data = data_type();
-        subs::ch(this).clear();
-    }
-
-    template<class K, class D, class C>
-    basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::get_child(const path_type &path)
-    {
-        path_type p(path);
-        self_type *n = walk_path(p);
-        if (!n) {
-            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path));
-        }
-        return *n;
-    }
-
-    template<class K, class D, class C> inline
-    const basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::get_child(const path_type &path) const
-    {
-        return const_cast<self_type*>(this)->get_child(path);
-    }
-
-    template<class K, class D, class C> inline
-    basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::get_child(const path_type &path,
-                                        self_type &default_value)
-    {
-        path_type p(path);
-        self_type *n = walk_path(p);
-        return n ? *n : default_value;
-    }
-
-    template<class K, class D, class C> inline
-    const basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::get_child(const path_type &path,
-                                        const self_type &default_value) const
-    {
-        return const_cast<self_type*>(this)->get_child(path,
-            const_cast<self_type&>(default_value));
-    }
-
-
-    template<class K, class D, class C>
-    optional<basic_ptree<K, D, C> &>
-        basic_ptree<K, D, C>::get_child_optional(const path_type &path)
-    {
-        path_type p(path);
-        self_type *n = walk_path(p);
-        if (!n) {
-            return optional<self_type&>();
-        }
-        return *n;
-    }
-
-    template<class K, class D, class C>
-    optional<const basic_ptree<K, D, C> &>
-        basic_ptree<K, D, C>::get_child_optional(const path_type &path) const
-    {
-        path_type p(path);
-        self_type *n = walk_path(p);
-        if (!n) {
-            return optional<const self_type&>();
-        }
-        return *n;
-    }
-
-    template<class K, class D, class C>
-    basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::put_child(const path_type &path,
-                                        const self_type &value)
-    {
-        path_type p(path);
-        self_type &parent = force_path(p);
-        // Got the parent. Now get the correct child.
-        key_type fragment = p.reduce();
-        assoc_iterator el = parent.find(fragment);
-        // If the new child exists, replace it.
-        if(el != parent.not_found()) {
-            return el->second = value;
-        } else {
-            return parent.push_back(value_type(fragment, value))->second;
-        }
-    }
-
-    template<class K, class D, class C>
-    basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::add_child(const path_type &path,
-                                        const self_type &value)
-    {
-        path_type p(path);
-        self_type &parent = force_path(p);
-        // Got the parent.
-        key_type fragment = p.reduce();
-        return parent.push_back(value_type(fragment, value))->second;
-    }
-
-    template<class K, class D, class C>
-    template<class Type, class Translator>
-    typename boost::enable_if<detail::is_translator<Translator>, Type>::type
-    basic_ptree<K, D, C>::get_value(Translator tr) const
-    {
-        if(boost::optional<Type> o = get_value_optional<Type>(tr)) {
-            return *o;
-        }
-        BOOST_PROPERTY_TREE_THROW(ptree_bad_data(
-            std::string("conversion of data to type \"") +
-            typeid(Type).name() + "\" failed", data()));
-    }
-
-    template<class K, class D, class C>
-    template<class Type> inline
-    Type basic_ptree<K, D, C>::get_value() const
-    {
-        return get_value<Type>(
-            typename translator_between<data_type, Type>::type());
-    }
-
-    template<class K, class D, class C>
-    template<class Type, class Translator> inline
-    Type basic_ptree<K, D, C>::get_value(const Type &default_value,
-                                         Translator tr) const
-    {
-        return get_value_optional<Type>(tr).get_value_or(default_value);
-    }
-
-    template<class K, class D, class C>
-    template <class Ch, class Translator>
-    typename boost::enable_if<
-        detail::is_character<Ch>,
-        std::basic_string<Ch>
-    >::type
-    basic_ptree<K, D, C>::get_value(const Ch *default_value, Translator tr)const
-    {
-        return get_value<std::basic_string<Ch>, Translator>(default_value, tr);
-    }
-
-    template<class K, class D, class C>
-    template<class Type> inline
-    typename boost::disable_if<detail::is_translator<Type>, Type>::type
-    basic_ptree<K, D, C>::get_value(const Type &default_value) const
-    {
-        return get_value(default_value,
-                         typename translator_between<data_type, Type>::type());
-    }
-
-    template<class K, class D, class C>
-    template <class Ch>
-    typename boost::enable_if<
-        detail::is_character<Ch>,
-        std::basic_string<Ch>
-    >::type
-    basic_ptree<K, D, C>::get_value(const Ch *default_value) const
-    {
-        return get_value< std::basic_string<Ch> >(default_value);
-    }
-
-    template<class K, class D, class C>
-    template<class Type, class Translator> inline
-    optional<Type> basic_ptree<K, D, C>::get_value_optional(
-                                                Translator tr) const
-    {
-        return tr.get_value(data());
-    }
-
-    template<class K, class D, class C>
-    template<class Type> inline
-    optional<Type> basic_ptree<K, D, C>::get_value_optional() const
-    {
-        return get_value_optional<Type>(
-            typename translator_between<data_type, Type>::type());
-    }
-
-    template<class K, class D, class C>
-    template<class Type, class Translator> inline
-    typename boost::enable_if<detail::is_translator<Translator>, Type>::type
-    basic_ptree<K, D, C>::get(const path_type &path,
-                              Translator tr) const
-    {
-        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
-    }
-
-    template<class K, class D, class C>
-    template<class Type> inline
-    Type basic_ptree<K, D, C>::get(const path_type &path) const
-    {
-        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>();
-    }
-
-    template<class K, class D, class C>
-    template<class Type, class Translator> inline
-    Type basic_ptree<K, D, C>::get(const path_type &path,
-                                   const Type &default_value,
-                                   Translator tr) const
-    {
-        return get_optional<Type>(path, tr).get_value_or(default_value);
-    }
-
-    template<class K, class D, class C>
-    template <class Ch, class Translator>
-    typename boost::enable_if<
-        detail::is_character<Ch>,
-        std::basic_string<Ch>
-    >::type
-    basic_ptree<K, D, C>::get(
-        const path_type &path, const Ch *default_value, Translator tr) const
-    {
-        return get<std::basic_string<Ch>, Translator>(path, default_value, tr);
-    }
-
-    template<class K, class D, class C>
-    template<class Type> inline
-    typename boost::disable_if<detail::is_translator<Type>, Type>::type
-    basic_ptree<K, D, C>::get(const path_type &path,
-                              const Type &default_value) const
-    {
-        return get_optional<Type>(path).get_value_or(default_value);
-    }
-
-    template<class K, class D, class C>
-    template <class Ch>
-    typename boost::enable_if<
-        detail::is_character<Ch>,
-        std::basic_string<Ch>
-    >::type
-    basic_ptree<K, D, C>::get(
-        const path_type &path, const Ch *default_value) const
-    {
-        return get< std::basic_string<Ch> >(path, default_value);
-    }
-
-    template<class K, class D, class C>
-    template<class Type, class Translator>
-    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path,
-                                                         Translator tr) const
-    {
-        if (optional<const self_type&> child = get_child_optional(path))
-            return child.get().
-                BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
-        else
-            return optional<Type>();
-    }
-
-    template<class K, class D, class C>
-    template<class Type>
-    optional<Type> basic_ptree<K, D, C>::get_optional(
-                                                const path_type &path) const
-    {
-        if (optional<const self_type&> child = get_child_optional(path))
-            return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>();
-        else
-            return optional<Type>();
-    }
-
-    template<class K, class D, class C>
-    template<class Type, class Translator>
-    void basic_ptree<K, D, C>::put_value(const Type &value, Translator tr)
-    {
-        if(optional<data_type> o = tr.put_value(value)) {
-            data() = *o;
-        } else {
-            BOOST_PROPERTY_TREE_THROW(ptree_bad_data(
-                std::string("conversion of type \"") + typeid(Type).name() +
-                "\" to data failed", boost::any()));
-        }
-    }
-
-    template<class K, class D, class C>
-    template<class Type> inline
-    void basic_ptree<K, D, C>::put_value(const Type &value)
-    {
-        put_value(value, typename translator_between<data_type, Type>::type());
-    }
-
-    template<class K, class D, class C>
-    template<class Type, typename Translator>
-    basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
-        const path_type &path, const Type &value, Translator tr)
-    {
-        if(optional<self_type &> child = get_child_optional(path)) {
-            child.get().put_value(value, tr);
-            return *child;
-        } else {
-            self_type &child2 = put_child(path, self_type());
-            child2.put_value(value, tr);
-            return child2;
-        }
-    }
-
-    template<class K, class D, class C>
-    template<class Type> inline
-    basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
-        const path_type &path, const Type &value)
-    {
-        return put(path, value,
-                   typename translator_between<data_type, Type>::type());
-    }
-
-    template<class K, class D, class C>
-    template<class Type, typename Translator> inline
-    basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
-        const path_type &path, const Type &value, Translator tr)
-    {
-        self_type &child = add_child(path, self_type());
-        child.put_value(value, tr);
-        return child;
-    }
-
-    template<class K, class D, class C>
-    template<class Type> inline
-    basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
-        const path_type &path, const Type &value)
-    {
-        return add(path, value,
-                   typename translator_between<data_type, Type>::type());
-    }
-
-
-    template<class K, class D, class C>
-    basic_ptree<K, D, C> *
-    basic_ptree<K, D, C>::walk_path(path_type &p) const
-    {
-        if(p.empty()) {
-            // I'm the child we're looking for.
-            return const_cast<basic_ptree*>(this);
-        }
-        // Recurse down the tree to find the path.
-        key_type fragment = p.reduce();
-        const_assoc_iterator el = find(fragment);
-        if(el == not_found()) {
-            // No such child.
-            return 0;
-        }
-        // Not done yet, recurse.
-        return el->second.walk_path(p);
-    }
-
-    template<class K, class D, class C>
-    basic_ptree<K, D, C> & basic_ptree<K, D, C>::force_path(path_type &p)
-    {
-        assert(!p.empty() && "Empty path not allowed for put_child.");
-        if(p.single()) {
-            // I'm the parent we're looking for.
-            return *this;
-        }
-        key_type fragment = p.reduce();
-        assoc_iterator el = find(fragment);
-        // If we've found an existing child, go down that path. Else
-        // create a new one.
-        self_type& child = el == not_found() ?
-            push_back(value_type(fragment, self_type()))->second : el->second;
-        return child.force_path(p);
-    }
-
-    // Free functions
-
-    template<class K, class D, class C>
-    inline void swap(basic_ptree<K, D, C> &pt1, basic_ptree<K, D, C> &pt2)
-    {
-        pt1.swap(pt2);
-    }
-
-} }
-
-#if defined(BOOST_PROPERTY_TREE_PAIR_BUG)
-#undef BOOST_PROPERTY_TREE_PAIR_BUG
-#endif
-
-#endif