boost/property_tree/string_path.hpp
// ---------------------------------------------------------------------------- // 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/assert.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/optional.hpp> #include <boost/throw_exception.hpp> #include <algorithm> #include <string> #include <iterator> 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<std::string>(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; /// Get the separator used by this path. char_type separator() const { return m_separator; } 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. BOOST_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() { BOOST_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