1 files changed, 273 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/property_tree/string_path.hpp b/3rdParty/Boost/src/boost/property_tree/string_path.hpp
new file mode 100644
index 0000000..07ec6b0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/property_tree/string_path.hpp
@@ -0,0 +1,273 @@
+// ----------------------------------------------------------------------------
+// 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_STRING_PATH_HPP_INCLUDED
+#define BOOST_PROPERTY_TREE_STRING_PATH_HPP_INCLUDED
+
+#include <boost/property_tree/ptree_fwd.hpp>
+#include <boost/property_tree/id_translator.hpp>
+#include <boost/property_tree/exceptions.hpp>
+#include <boost/property_tree/detail/ptree_utils.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/optional.hpp>
+#include <boost/throw_exception.hpp>
+#include <algorithm>
+#include <string>
+#include <iterator>
+#include <cassert>
+
+namespace boost { namespace property_tree
+{
+    namespace detail
+    {
+        template <typename Sequence, typename Iterator>
+        void append_and_preserve_iter(Sequence &s, const Sequence &r,
+                                      Iterator &, std::forward_iterator_tag)
+        {
+            // Here we boldly assume that anything that is not random-access
+            // preserves validity. This is valid for the STL sequences.
+            s.insert(s.end(), r.begin(), r.end());
+        }
+        template <typename Sequence, typename Iterator>
+        void append_and_preserve_iter(Sequence &s, const Sequence &r,
+                                      Iterator &it,
+                                      std::random_access_iterator_tag)
+        {
+            // Convert the iterator to an index, and later back.
+            typename std::iterator_traits<Iterator>::difference_type idx =
+                it - s.begin();
+            s.insert(s.end(), r.begin(), r.end());
+            it = s.begin() + idx;
+        }
+
+        template <typename Sequence>
+        inline std::string dump_sequence(const Sequence &)
+        {
+            return "<undumpable sequence>";
+        }
+        inline std::string dump_sequence(const std::string &s)
+        {
+            return s;
+        }
+#ifndef BOOST_NO_STD_WSTRING
+        inline std::string dump_sequence(const std::wstring &s)
+        {
+            return narrow(s.c_str());
+        }
+#endif
+    }
+
+    /// Default path class. A path is a sequence of values. Groups of values
+    /// are separated by the separator value, which defaults to '.' cast to
+    /// the sequence's value type. The group of values is then passed to the
+    /// translator to get a key.
+    ///
+    /// If instantiated with std::string and id_translator\<std::string\>,
+    /// it accepts paths of the form "one.two.three.four".
+    ///
+    /// @tparam String Any Sequence. If the sequence does not support random-
+    ///                access iteration, concatenation of paths assumes that
+    ///                insertions at the end preserve iterator validity.
+    /// @tparam Translator A translator with internal_type == String.
+    template <typename String, typename Translator>
+    class string_path
+    {
+        BOOST_STATIC_ASSERT((is_same<String,
+                                   typename Translator::internal_type>::value));
+    public:
+        typedef typename Translator::external_type key_type;
+        typedef typename String::value_type char_type;
+
+        /// Create an empty path.
+        explicit string_path(char_type separator = char_type('.'));
+        /// Create a path by parsing the given string.
+        /// @param value A sequence, possibly with separators, that describes
+        ///              the path, e.g. "one.two.three".
+        /// @param separator The separator used in parsing. Defaults to '.'.
+        /// @param tr The translator used by this path to convert the individual
+        ///           parts to keys.
+        string_path(const String &value, char_type separator = char_type('.'),
+                    Translator tr = Translator());
+        /// Create a path by parsing the given string.
+        /// @param value A zero-terminated array of values. Only use if zero-
+        ///              termination makes sense for your type, and your
+        ///              sequence supports construction from it. Intended for
+        ///              string literals.
+        /// @param separator The separator used in parsing. Defaults to '.'.
+        /// @param tr The translator used by this path to convert the individual
+        ///           parts to keys.
+        string_path(const char_type *value,
+                    char_type separator = char_type('.'),
+                    Translator tr = Translator());
+
+        // Default copying doesn't do the right thing with the iterator
+        string_path(const string_path &o);
+        string_path& operator =(const string_path &o);
+
+        /// Take a single element off the path at the front and return it.
+        key_type reduce();
+
+        /// Test if the path is empty.
+        bool empty() const;
+
+        /// Test if the path contains a single element, i.e. no separators.
+        bool single() const;
+
+        std::string dump() const {
+            return detail::dump_sequence(m_value);
+        }
+
+        /// Append a second path to this one.
+        /// @pre o's separator is the same as this one's, or o has no separators
+        string_path& operator /=(const string_path &o) {
+            // If it's single, there's no separator. This allows to do
+            // p /= "piece";
+            // even for non-default separators.
+            assert((m_separator == o.m_separator || o.empty() || o.single())
+                   && "Incompatible paths.");
+            if(!o.empty()) {
+                String sub;
+                if(!this->empty()) {
+                    sub.push_back(m_separator);
+                }
+                sub.insert(sub.end(), o.cstart(), o.m_value.end());
+                detail::append_and_preserve_iter(m_value, sub, m_start,
+                    typename std::iterator_traits<s_iter>::iterator_category());
+            }
+            return *this;
+        }
+
+    private:
+        typedef typename String::iterator s_iter;
+        typedef typename String::const_iterator s_c_iter;
+        String m_value;
+        char_type m_separator;
+        Translator m_tr;
+        s_iter m_start;
+        s_c_iter cstart() const { return m_start; }
+    };
+
+    template <typename String, typename Translator> inline
+    string_path<String, Translator>::string_path(char_type separator)
+        : m_separator(separator), m_start(m_value.begin())
+    {}
+
+    template <typename String, typename Translator> inline
+    string_path<String, Translator>::string_path(const String &value,
+                                                 char_type separator,
+                                                 Translator tr)
+        : m_value(value), m_separator(separator),
+          m_tr(tr), m_start(m_value.begin())
+    {}
+
+    template <typename String, typename Translator> inline
+    string_path<String, Translator>::string_path(const char_type *value,
+                                                 char_type separator,
+                                                 Translator tr)
+        : m_value(value), m_separator(separator),
+          m_tr(tr), m_start(m_value.begin())
+    {}
+
+    template <typename String, typename Translator> inline
+    string_path<String, Translator>::string_path(const string_path &o)
+        : m_value(o.m_value), m_separator(o.m_separator),
+          m_tr(o.m_tr), m_start(m_value.begin())
+    {
+        std::advance(m_start, std::distance(o.m_value.begin(), o.cstart()));
+    }
+
+    template <typename String, typename Translator> inline
+    string_path<String, Translator>&
+    string_path<String, Translator>::operator =(const string_path &o)
+    {
+        m_value = o.m_value;
+        m_separator = o.m_separator;
+        m_tr = o.m_tr;
+        m_start = m_value.begin();
+        std::advance(m_start, std::distance(o.m_value.begin(), o.cstart()));
+        return *this;
+    }
+
+    template <typename String, typename Translator>
+    typename Translator::external_type string_path<String, Translator>::reduce()
+    {
+        assert(!empty() && "Reducing empty path");
+
+        s_iter next_sep = std::find(m_start, m_value.end(), m_separator);
+        String part(m_start, next_sep);
+        m_start = next_sep;
+        if(!empty()) {
+          // Unless we're at the end, skip the separator we found.
+          ++m_start;
+        }
+
+        if(optional<key_type> key = m_tr.get_value(part)) {
+            return *key;
+        }
+        BOOST_PROPERTY_TREE_THROW(ptree_bad_path("Path syntax error", *this));
+    }
+
+    template <typename String, typename Translator> inline
+    bool string_path<String, Translator>::empty() const
+    {
+        return m_start == m_value.end();
+    }
+
+    template <typename String, typename Translator> inline
+    bool string_path<String, Translator>::single() const
+    {
+        return std::find(static_cast<s_c_iter>(m_start),
+                         m_value.end(), m_separator)
+            == m_value.end();
+    }
+
+    // By default, this is the path for strings. You can override this by
+    // specializing path_of for a more specific form of std::basic_string.
+    template <typename Ch, typename Traits, typename Alloc>
+    struct path_of< std::basic_string<Ch, Traits, Alloc> >
+    {
+        typedef std::basic_string<Ch, Traits, Alloc> _string;
+        typedef string_path< _string, id_translator<_string> > type;
+    };
+
+    template <typename String, typename Translator> inline
+    string_path<String, Translator> operator /(
+                                  string_path<String, Translator> p1,
+                                  const string_path<String, Translator> &p2)
+    {
+        p1 /= p2;
+        return p1;
+    }
+
+    // These shouldn't be necessary, but GCC won't find the one above.
+    template <typename String, typename Translator> inline
+    string_path<String, Translator> operator /(
+                                  string_path<String, Translator> p1,
+                                  const typename String::value_type *p2)
+    {
+        p1 /= p2;
+        return p1;
+    }
+
+    template <typename String, typename Translator> inline
+    string_path<String, Translator> operator /(
+                                  const typename String::value_type *p1,
+                                  const string_path<String, Translator> &p2)
+    {
+        string_path<String, Translator> t(p1);
+        t /= p2;
+        return t;
+    }
+
+}}
+
+#endif