| // ---------------------------------------------------------------------------- |
| // 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 |