--- /dev/null
+/*=============================================================================
+ Copyright (c) 2001-2011 Joel de Guzman
+ Copyright (c) 2001-2011 Hartmut Kaiser
+ Copyright (c) 2010-2011 Bryce Lelbach
+
+ 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_OUTPUT_UTREE_TRAITS_APR_16_2010_0655AM)
+#define BOOST_SPIRIT_OUTPUT_UTREE_TRAITS_APR_16_2010_0655AM
+
+#include <boost/spirit/home/support/attributes.hpp>
+#include <boost/spirit/home/support/container.hpp>
+#include <boost/spirit/home/support/utree.hpp>
+#include <boost/spirit/home/qi/domain.hpp>
+#include <boost/spirit/home/karma/domain.hpp>
+#include <boost/spirit/home/qi/nonterminal/nonterminal_fwd.hpp>
+#include <boost/spirit/home/karma/nonterminal/nonterminal_fwd.hpp>
+
+#include <string>
+
+#include <boost/cstdint.hpp>
+#include <boost/variant.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/utility/enable_if.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost
+{
+ template <typename T>
+ inline T get(boost::spirit::utree const& x)
+ {
+ return x.get<T>();
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace traits
+{
+ namespace detail
+ {
+ inline bool is_list(utree const& ut)
+ {
+ switch (traits::which(ut))
+ {
+ case utree_type::reference_type:
+ return is_list(ut.deref());
+
+ case utree_type::list_type:
+ case utree_type::range_type:
+ return true;
+
+ default:
+ break;
+ }
+ return false;
+ }
+
+ inline bool is_uninitialized(utree const& ut)
+ {
+ return traits::which(ut) == utree_type::invalid_type;
+ }
+ }
+
+ // this specialization tells Spirit how to extract the type of the value
+ // stored in the given utree node
+ template <>
+ struct variant_which<utree>
+ {
+ static int call(utree const& u) { return u.which(); }
+ };
+
+ template <>
+ struct variant_which<utree::list_type>
+ {
+ static int call(utree::list_type const& u) { return u.which(); }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // Make sure all components of an alternative expose utree, even if they
+ // actually expose a utree::list_type
+ template <typename Domain>
+ struct alternative_attribute_transform<utree::list_type, Domain>
+ : mpl::identity<utree>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // Make sure all components of a sequence expose utree, even if they
+ // actually expose a utree::list_type
+ template <typename Domain>
+ struct sequence_attribute_transform<utree::list_type, Domain>
+ : mpl::identity<utree>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // this specialization lets Spirit know that typed basic_strings
+ // are strings
+ template <typename Base, utree_type::info I>
+ struct is_string<spirit::basic_string<Base, I> >
+ : mpl::true_
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // these specializations extract the character type of a utree typed string
+ template <typename T, utree_type::info I>
+ struct char_type_of<spirit::basic_string<iterator_range<T>, I> >
+ : char_type_of<T>
+ {};
+
+ template <utree_type::info I>
+ struct char_type_of<spirit::basic_string<std::string, I> >
+ : mpl::identity<char>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // these specializations extract a c string from a utree typed string
+ template <typename String>
+ struct extract_c_string;
+
+ template <typename T, utree_type::info I>
+ struct extract_c_string<
+ spirit::basic_string<iterator_range<T const*>, I>
+ > {
+ typedef T char_type;
+
+ typedef spirit::basic_string<iterator_range<T const*>, I> string;
+
+ static T const* call (string& s)
+ {
+ return s.begin();
+ }
+
+ static T const* call (string const& s)
+ {
+ return s.begin();
+ }
+ };
+
+ template <utree_type::info I>
+ struct extract_c_string<spirit::basic_string<std::string, I> >
+ {
+ typedef char char_type;
+
+ typedef spirit::basic_string<std::string, I> string;
+
+ static char const* call (string& s)
+ {
+ return s.c_str();
+ }
+
+ static char const* call (string const& s)
+ {
+ return s.c_str();
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // these specializations are needed because utree::value_type == utree
+ template <>
+ struct is_substitute<utree, utree>
+ : mpl::true_
+ {};
+
+ template <>
+ struct is_weak_substitute<utree, utree>
+ : mpl::true_
+ {};
+
+ template <>
+ struct is_substitute<utree::list_type, utree::list_type>
+ : mpl::true_
+ {};
+
+ template <>
+ struct is_weak_substitute<utree::list_type, utree::list_type>
+ : mpl::true_
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // this specialization tells Spirit.Qi to allow assignment to an utree from
+ // a variant
+ namespace detail
+ {
+ struct assign_to_utree_visitor : static_visitor<>
+ {
+ assign_to_utree_visitor(utree& ut) : ut_(ut) {}
+
+ template <typename T>
+ void operator()(T& val) const
+ {
+ ut_ = val;
+ }
+
+ utree& ut_;
+ };
+ }
+
+ template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+ struct assign_to_container_from_value<
+ utree, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+ {
+ static void
+ call(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& val, utree& attr)
+ {
+ apply_visitor(detail::assign_to_utree_visitor(attr), val);
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // this specialization tells Spirit.Qi to allow assignment to an utree from
+ // a STL container
+ template <typename Attribute>
+ struct assign_to_container_from_value<utree, Attribute>
+ {
+ // any non-container type will be either directly assigned or appended
+ static void call(Attribute const& val, utree& attr, mpl::false_)
+ {
+ if (attr.empty())
+ attr = val;
+ else
+ push_back(attr, val);
+ }
+
+ // any container type will be converted into a list_type utree
+ static void call(Attribute const& val, utree& attr, mpl::true_)
+ {
+ typedef typename traits::container_iterator<Attribute const>::type
+ iterator_type;
+
+ // make sure the attribute is a list, at least an empty one
+ if (attr.empty())
+ attr = empty_list;
+
+ iterator_type end = traits::end(val);
+ for (iterator_type i = traits::begin(val); i != end; traits::next(i))
+ push_back(attr, traits::deref(i));
+ }
+
+ static void call(Attribute const& val, utree& attr)
+ {
+ call(val, attr, is_container<Attribute>());
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // this specialization is required to disambiguate the specializations
+ // related to utree
+ template <>
+ struct assign_to_container_from_value<utree, utree>
+ {
+ static void call(utree const& val, utree& attr)
+ {
+ if (attr.empty()) {
+ attr = val;
+ }
+ else if (detail::is_list(val)) {
+ typedef utree::const_iterator iterator_type;
+
+ iterator_type end = traits::end(val);
+ for (iterator_type i = traits::begin(val); i != end; traits::next(i))
+ push_back(attr, traits::deref(i));
+ }
+ else {
+ push_back(attr, val);
+ }
+ }
+ };
+
+ template <>
+ struct assign_to_container_from_value<utree, utree::list_type>
+ : assign_to_container_from_value<utree, utree>
+ {};
+
+ // If the destination is a utree_list, we need to force the right hand side
+ // value into a new sub-node, always, no questions asked.
+ template <>
+ struct assign_to_container_from_value<utree::list_type, utree>
+ {
+ static void call(utree const& val, utree& attr)
+ {
+ push_back(attr, val);
+ }
+ };
+
+ // If both, the right hand side and the left hand side are utree_lists
+ // we have a lhs rule which has a single rule exposing a utree_list as its
+ // rhs (optionally wrapped into a directive or other unary parser). In this
+ // case we do not create a new sub-node.
+ template <>
+ struct assign_to_container_from_value<utree::list_type, utree::list_type>
+ : assign_to_container_from_value<utree, utree>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // this specialization makes sure strings get assigned as a whole and are
+ // not converted into a utree list
+ template <>
+ struct assign_to_container_from_value<utree, utf8_string_type>
+ {
+ static void call(utf8_string_type const& val, utree& attr)
+ {
+ if (attr.empty())
+ attr = val;
+ else
+ push_back(attr, val);
+ }
+ };
+
+ // this specialization keeps symbols from being transformed into strings
+ template<>
+ struct assign_to_container_from_value<utree, utf8_symbol_type>
+ {
+ static void call (utf8_symbol_type const& val, utree& attr)
+ {
+ if (attr.empty())
+ attr = val;
+ else
+ push_back(attr, val);
+ }
+ };
+
+ template <>
+ struct assign_to_container_from_value<utree, binary_string_type>
+ {
+ static void call(binary_string_type const& val, utree& attr)
+ {
+ if (attr.empty())
+ attr = val;
+ else
+ push_back(attr, val);
+ }
+ };
+
+ template<>
+ struct assign_to_container_from_value<utree, utf8_symbol_range_type>
+ {
+ static void call (utf8_symbol_range_type const& val, utree& attr)
+ {
+ if (attr.empty())
+ attr = val;
+ else
+ push_back(attr, val);
+ }
+ };
+
+ template <>
+ struct assign_to_container_from_value<utree, binary_range_type>
+ {
+ static void call(binary_range_type const& val, utree& attr)
+ {
+ if (attr.empty())
+ attr = val;
+ else
+ push_back(attr, val);
+ }
+ };
+
+ template <>
+ struct assign_to_container_from_value<utree, std::string>
+ {
+ static void call(std::string const& val, utree& attr)
+ {
+ if (attr.empty())
+ attr = val;
+ else
+ push_back(attr, val);
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // this specialization tells Spirit.Qi to allow assignment to an utree from
+ // generic iterators
+ template <typename Iterator>
+ struct assign_to_attribute_from_iterators<utree, Iterator>
+ {
+ static void
+ call(Iterator const& first, Iterator const& last, utree& attr)
+ {
+ if (attr.empty())
+ attr.assign(first, last);
+ else {
+ for (Iterator i = first; i != last; ++i)
+ push_back(attr, traits::deref(i));
+ }
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // Karma only: convert utree node to string
+ namespace detail
+ {
+ struct attribute_as_string_type
+ {
+ typedef utf8_string_range_type type;
+
+ static type call(utree const& attr)
+ {
+ return boost::get<utf8_string_range_type>(attr);
+ }
+
+ static bool is_valid(utree const& attr)
+ {
+ switch (traits::which(attr))
+ {
+ case utree_type::reference_type:
+ return is_valid(attr.deref());
+
+ case utree_type::string_range_type:
+ case utree_type::string_type:
+ return true;
+
+ default:
+ return false;
+ }
+ }
+ };
+ }
+
+ template <>
+ struct attribute_as<std::string, utree>
+ : detail::attribute_as_string_type
+ {};
+
+ template <>
+ struct attribute_as<utf8_string_type, utree>
+ : detail::attribute_as_string_type
+ {};
+
+ template <>
+ struct attribute_as<utf8_string_range_type, utree>
+ : detail::attribute_as_string_type
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ namespace detail
+ {
+ struct attribute_as_symbol_type
+ {
+ typedef utf8_symbol_range_type type;
+
+ static type call(utree const& attr)
+ {
+ return boost::get<utf8_symbol_range_type>(attr);
+ }
+
+ static bool is_valid(utree const& attr)
+ {
+ switch (traits::which(attr))
+ {
+ case utree_type::reference_type:
+ return is_valid(attr.deref());
+
+ case utree_type::symbol_type:
+ return true;
+
+ default:
+ return false;
+ }
+ }
+ };
+ }
+
+ template <>
+ struct attribute_as<utf8_symbol_type, utree>
+ : detail::attribute_as_symbol_type
+ {};
+
+ template <>
+ struct attribute_as<utf8_symbol_range_type, utree>
+ : detail::attribute_as_symbol_type
+ {};
+
+ template <typename Attribute>
+ struct attribute_as<Attribute, utree::list_type>
+ : attribute_as<Attribute, utree>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ namespace detail
+ {
+ struct attribute_as_binary_string_type
+ {
+ typedef binary_range_type type;
+
+ static type call(utree const& attr)
+ {
+ return boost::get<binary_range_type>(attr);
+ }
+
+ static bool is_valid(utree const& attr)
+ {
+ switch (traits::which(attr))
+ {
+ case utree_type::reference_type:
+ return is_valid(attr.deref());
+
+ case utree_type::binary_type:
+ return true;
+
+ default:
+ return false;
+ }
+ }
+ };
+ }
+
+ template <>
+ struct attribute_as<binary_string_type, utree>
+ : detail::attribute_as_binary_string_type
+ {};
+
+ template <>
+ struct attribute_as<binary_range_type, utree>
+ : detail::attribute_as_binary_string_type
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // push_back support for utree
+ template <typename T>
+ struct push_back_container<utree, T>
+ {
+ static bool call(utree& c, T const& val)
+ {
+ switch (traits::which(c))
+ {
+ case utree_type::invalid_type:
+ case utree_type::nil_type:
+ case utree_type::list_type:
+ c.push_back(val);
+ break;
+
+ default:
+ {
+ utree ut;
+ ut.push_back(c);
+ ut.push_back(val);
+ c.swap(ut);
+ }
+ break;
+ }
+ return true;
+ }
+ };
+
+ template <typename T>
+ struct push_back_container<utree::list_type, T>
+ : push_back_container<utree, T>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // ensure the utree attribute is an empty list
+ template <>
+ struct make_container_attribute<utree>
+ {
+ static void call(utree& ut)
+ {
+ if (!detail::is_list(ut)) {
+ if (detail::is_uninitialized(ut))
+ ut = empty_list;
+ else {
+ utree retval (empty_list);
+ retval.push_back(ut);
+ ut.swap(retval);
+ }
+ }
+ }
+ };
+
+ template <>
+ struct make_container_attribute<utree::list_type>
+ : make_container_attribute<utree>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // an utree is a container on its own
+ template <>
+ struct build_std_vector<utree>
+ {
+ typedef utree type;
+ };
+
+ template <>
+ struct build_std_vector<utree::list_type>
+ {
+ typedef utree::list_type type;
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // debug support for utree
+ template <typename Out>
+ struct print_attribute_debug<Out, utree>
+ {
+ static void call(Out& out, utree const& val)
+ {
+ out << val;
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // force utree list attribute in a sequence to be dereferenced if a rule
+ // or a grammar exposes an utree as it's attribute
+ namespace detail
+ {
+ // Checks whether the exposed Attribute allows to handle utree or
+ // utree::list_type directly. Returning mpl::false_ from this meta
+ // function will force a new utree instance to be created for each
+ // invocation of the embedded parser.
+
+ // The purpose of using utree::list_type as an attribute is to force a
+ // new sub-node in the result.
+ template <typename Attribute, typename Enable = void>
+ struct handles_utree_list_container
+ : mpl::and_<
+ mpl::not_<is_same<utree::list_type, Attribute> >,
+ traits::is_container<Attribute> >
+ {};
+
+ // The following specializations make sure that the actual handling of
+ // an utree (or utree::list_type) attribute is deferred to the embedded
+ // parsers of a sequence, alternative or optional component.
+ template <typename Attribute>
+ struct handles_utree_list_container<Attribute
+ , typename enable_if<fusion::traits::is_sequence<Attribute> >::type>
+ : mpl::true_
+ {};
+
+ template <typename Attribute>
+ struct handles_utree_list_container<boost::optional<Attribute> >
+ : mpl::true_
+ {};
+
+ template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+ struct handles_utree_list_container<
+ boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+ : mpl::true_
+ {};
+ }
+
+ template <
+ typename IteratorA, typename IteratorB, typename Context
+ , typename T1, typename T2, typename T3, typename T4>
+ struct handles_container<qi::rule<IteratorA, T1, T2, T3, T4>
+ , utree, Context, IteratorB>
+ : detail::handles_utree_list_container<typename attribute_of<
+ qi::rule<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+ >::type>
+ {};
+
+ template <
+ typename IteratorA, typename IteratorB, typename Context
+ , typename T1, typename T2, typename T3, typename T4>
+ struct handles_container<qi::grammar<IteratorA, T1, T2, T3, T4>
+ , utree, Context, IteratorB>
+ : detail::handles_utree_list_container<typename attribute_of<
+ qi::grammar<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+ >::type>
+ {};
+
+ template <
+ typename IteratorA, typename IteratorB, typename Context
+ , typename T1, typename T2, typename T3, typename T4>
+ struct handles_container<qi::rule<IteratorA, T1, T2, T3, T4>
+ , utree::list_type, Context, IteratorB>
+ : detail::handles_utree_list_container<typename attribute_of<
+ qi::rule<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+ >::type>
+ {};
+
+ template <
+ typename IteratorA, typename IteratorB, typename Context
+ , typename T1, typename T2, typename T3, typename T4>
+ struct handles_container<qi::grammar<IteratorA, T1, T2, T3, T4>
+ , utree::list_type, Context, IteratorB>
+ : detail::handles_utree_list_container<typename attribute_of<
+ qi::grammar<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+ >::type>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename Attribute, typename Sequence>
+ struct pass_through_container<
+ utree, utree, Attribute, Sequence, qi::domain>
+ : detail::handles_utree_list_container<Attribute>
+ {};
+
+ template <typename Attribute, typename Sequence>
+ struct pass_through_container<
+ utree::list_type, utree, Attribute, Sequence, qi::domain>
+ : detail::handles_utree_list_container<Attribute>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ namespace detail
+ {
+ // Checks whether the exposed Attribute allows to handle utree or
+ // utree::list_type directly. Returning mpl::false_ from this meta
+ // function will force a new utree instance to be created for each
+ // invocation of the embedded parser.
+
+ // The purpose of using utree::list_type as an attribute is to force a
+ // new sub-node in the result.
+ template <typename Attribute, typename Enable = void>
+ struct handles_utree_container
+ : mpl::and_<
+ mpl::not_<is_same<utree, Attribute> >,
+ traits::is_container<Attribute> >
+ {};
+
+ // The following specializations make sure that the actual handling of
+ // an utree (or utree::list_type) attribute is deferred to the embedded
+ // parsers of a sequence, alternative or optional component.
+ template <typename Attribute>
+ struct handles_utree_container<Attribute
+ , typename enable_if<fusion::traits::is_sequence<Attribute> >::type>
+ : mpl::true_
+ {};
+
+ template <typename Attribute>
+ struct handles_utree_container<boost::optional<Attribute> >
+ : mpl::true_
+ {};
+
+ template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+ struct handles_utree_container<
+ boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+ : mpl::true_
+ {};
+ }
+
+ template <
+ typename IteratorA, typename IteratorB, typename Context
+ , typename T1, typename T2, typename T3, typename T4>
+ struct handles_container<karma::rule<IteratorA, T1, T2, T3, T4>
+ , utree, Context, IteratorB>
+ : detail::handles_utree_container<typename attribute_of<
+ karma::rule<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+ >::type>
+ {};
+
+ template <
+ typename IteratorA, typename IteratorB, typename Context
+ , typename T1, typename T2, typename T3, typename T4>
+ struct handles_container<karma::grammar<IteratorA, T1, T2, T3, T4>
+ , utree, Context, IteratorB>
+ : detail::handles_utree_container<typename attribute_of<
+ karma::grammar<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+ >::type>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename Attribute, typename Sequence>
+ struct pass_through_container<
+ utree, utree, Attribute, Sequence, karma::domain>
+ : detail::handles_utree_container<Attribute>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // the specialization below tells Spirit how to handle utree if it is used
+ // with an optional component
+ template <>
+ struct optional_attribute<utree>
+ {
+ typedef utree const& type;
+
+ static type call(utree const& val)
+ {
+ return val;
+ }
+
+ // only 'invalid_type' utree nodes are not valid
+ static bool is_valid(utree const& val)
+ {
+ return !detail::is_uninitialized(val);
+ }
+ };
+
+ template <>
+ struct build_optional<utree>
+ {
+ typedef utree type;
+ };
+
+ template <>
+ struct build_optional<utree::list_type>
+ {
+ typedef utree::list_type type;
+ };
+
+ // an utree is an optional (in any domain)
+ template <>
+ struct not_is_optional<utree, qi::domain>
+ : mpl::false_
+ {};
+
+ template <>
+ struct not_is_optional<utree::list_type, qi::domain>
+ : mpl::false_
+ {};
+
+ template <>
+ struct not_is_optional<utree, karma::domain>
+ : mpl::false_
+ {};
+
+ template <>
+ struct not_is_optional<utree::list_type, karma::domain>
+ : mpl::false_
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ // the specialization below tells Spirit to handle utree as if it
+ // where a 'real' variant (in the context of karma)
+ template <>
+ struct not_is_variant<utree, karma::domain>
+ : mpl::false_
+ {};
+
+ template <>
+ struct not_is_variant<utree::list_type, karma::domain>
+ : mpl::false_
+ {};
+
+ // The specializations below tell Spirit to verify whether an attribute
+ // type is compatible with a given variant type
+ template <>
+ struct compute_compatible_component_variant<
+ utree, iterator_range<utree::iterator> >
+ : mpl::true_
+ {
+ typedef iterator_range<utree::iterator> compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::list_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<
+ utree, iterator_range<utree::const_iterator> >
+ : mpl::true_
+ {
+ typedef iterator_range<utree::const_iterator> compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::list_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<utree, utree::invalid_type>
+ : mpl::true_
+ {
+ typedef utree::invalid_type compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::invalid_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<utree, utree::nil_type>
+ : mpl::true_
+ {
+ typedef utree::nil_type compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::nil_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<utree, bool>
+ : mpl::true_
+ {
+ typedef bool compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::bool_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<utree, int>
+ : mpl::true_
+ {
+ typedef int compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::int_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<utree, double>
+ : mpl::true_
+ {
+ typedef double compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::double_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<
+ utree, utf8_string_range_type>
+ : mpl::true_
+ {
+ typedef utf8_string_range_type compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::string_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<
+ utree, utf8_string_type>
+ : mpl::true_
+ {
+ typedef utf8_string_type compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::string_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<
+ utree, utf8_symbol_range_type>
+ : mpl::true_
+ {
+ typedef utf8_symbol_range_type compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::symbol_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<
+ utree, utf8_symbol_type>
+ : mpl::true_
+ {
+ typedef utf8_symbol_type compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::symbol_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<
+ utree, binary_range_type>
+ : mpl::true_
+ {
+ typedef binary_range_type compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::binary_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<
+ utree, binary_string_type>
+ : mpl::true_
+ {
+ typedef binary_string_type compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::binary_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<utree, utree>
+ : mpl::true_
+ {
+ typedef utree compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d >= utree_type::invalid_type &&
+ d <= utree_type::reference_type;
+ }
+ };
+
+ template <>
+ struct compute_compatible_component_variant<
+ utree, std::vector<utree> >
+ : mpl::true_
+ {
+ typedef utree compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d >= utree_type::invalid_type &&
+ d <= utree_type::reference_type;
+ }
+ };
+
+ template <typename Sequence>
+ struct compute_compatible_component_variant<utree, Sequence
+ , mpl::false_
+ , typename enable_if<fusion::traits::is_sequence<Sequence> >::type>
+ : mpl::true_
+ {
+ typedef iterator_range<utree::const_iterator> compatible_type;
+
+ static bool is_compatible(int d)
+ {
+ return d == utree_type::list_type;
+ }
+ };
+
+ template <typename Attribute>
+ struct compute_compatible_component_variant<utree::list_type, Attribute>
+ : compute_compatible_component_variant<utree, Attribute>
+ {};
+
+ ///////////////////////////////////////////////////////////////////////////
+ template <>
+ struct symbols_lookup<utree, utf8_symbol_type>
+ {
+ typedef std::string type;
+
+ static type call(utree const& t)
+ {
+ utf8_symbol_range_type r = boost::get<utf8_symbol_range_type>(t);
+ return std::string(traits::begin(r), traits::end(r));
+ }
+ };
+
+ template <>
+ struct symbols_lookup<utf8_symbol_type, utf8_symbol_type>
+ {
+ typedef std::string type;
+
+ static type call(utf8_symbol_type const& t)
+ {
+ return t;
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ namespace detail
+ {
+ template <typename T>
+ inline T get_or_deref(utree const& t)
+ {
+ if (detail::is_list(t))
+ return boost::get<T>(t.front());
+ return boost::get<T>(t);
+ }
+ }
+
+ template <>
+ struct extract_from_container<utree, utree::nil_type>
+ {
+ typedef utree::nil_type type;
+
+ template <typename Context>
+ static type call(utree const&, Context&)
+ {
+ return nil;
+ }
+ };
+
+ template <>
+ struct extract_from_container<utree, char>
+ {
+ typedef char type;
+
+ template <typename Context>
+ static type call(utree const& t, Context&)
+ {
+ utf8_symbol_range_type r = detail::get_or_deref<utf8_symbol_range_type>(t);
+ return r.front();
+ }
+ };
+
+ template <>
+ struct extract_from_container<utree, bool>
+ {
+ typedef bool type;
+
+ template <typename Context>
+ static type call(utree const& t, Context&)
+ {
+ return detail::get_or_deref<bool>(t);
+ }
+ };
+
+ template <>
+ struct extract_from_container<utree, int>
+ {
+ typedef int type;
+
+ template <typename Context>
+ static type call(utree const& t, Context&)
+ {
+ return detail::get_or_deref<int>(t);
+ }
+ };
+
+ template <>
+ struct extract_from_container<utree, double>
+ {
+ typedef double type;
+
+ template <typename Context>
+ static type call(utree const& t, Context&)
+ {
+ return detail::get_or_deref<double>(t);
+ }
+ };
+
+ template <typename Traits, typename Alloc>
+ struct extract_from_container<utree, std::basic_string<char, Traits, Alloc> >
+ {
+ typedef std::basic_string<char, Traits, Alloc> type;
+
+ template <typename Context>
+ static type call(utree const& t, Context&)
+ {
+ utf8_string_range_type r = detail::get_or_deref<utf8_string_range_type>(t);
+ return type(traits::begin(r), traits::end(r));
+ }
+ };
+
+ template <>
+ struct extract_from_container<utree, utf8_symbol_type>
+ {
+ typedef std::string type;
+
+ template <typename Context>
+ static type call(utree const& t, Context&)
+ {
+ utf8_symbol_range_type r = detail::get_or_deref<utf8_symbol_range_type>(t);
+ return std::string(traits::begin(r), traits::end(r));
+ }
+ };
+
+ template <>
+ struct extract_from_container<utree, utf8_string_type>
+ {
+ typedef std::string type;
+
+ template <typename Context>
+ static type call(utree const& t, Context&)
+ {
+ utf8_string_range_type r = detail::get_or_deref<utf8_string_range_type>(t);
+ return std::string(traits::begin(r), traits::end(r));
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ template <>
+ struct transform_attribute<utree const, utree::nil_type, karma::domain>
+ {
+ typedef utree::nil_type type;
+
+ static type pre(utree const&)
+ {
+ return nil;
+ }
+ };
+
+ template <>
+ struct transform_attribute<utree const, char, karma::domain>
+ {
+ typedef char type;
+
+ static type pre(utree const& t)
+ {
+ utf8_string_range_type r = detail::get_or_deref<utf8_string_range_type>(t);
+ return r.front();
+ }
+ };
+
+ template <>
+ struct transform_attribute<utree const, bool, karma::domain>
+ {
+ typedef bool type;
+
+ static type pre(utree const& t)
+ {
+ return detail::get_or_deref<bool>(t);
+ }
+ };
+
+ template <>
+ struct transform_attribute<utree const, int, karma::domain>
+ {
+ typedef int type;
+
+ static type pre(utree const& t)
+ {
+ return detail::get_or_deref<int>(t);
+ }
+ };
+
+ template <>
+ struct transform_attribute<utree const, double, karma::domain>
+ {
+ typedef double type;
+
+ static type pre(utree const& t)
+ {
+ return detail::get_or_deref<double>(t);
+ }
+ };
+
+ template <typename Traits, typename Alloc>
+ struct transform_attribute<
+ utree const, std::basic_string<char, Traits, Alloc>, karma::domain>
+ {
+ typedef std::basic_string<char, Traits, Alloc> type;
+
+ static type pre(utree const& t)
+ {
+ utf8_string_range_type r = detail::get_or_deref<utf8_string_range_type>(t);
+ return type(traits::begin(r), traits::end(r));
+ }
+ };
+
+ // this specialization is used whenever a utree is passed to a rule as part
+ // of a sequence
+ template <typename Iterator>
+ struct transform_attribute<
+ iterator_range<Iterator> const, utree, karma::domain>
+ {
+ typedef utree type;
+
+ static type pre(iterator_range<Iterator> const& t)
+ {
+ // return utree the begin iterator points to
+ Iterator it = boost::begin(t);
+ utree result(boost::ref(*it));
+ ++it;
+ return result;
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ template <>
+ struct transform_attribute<utree const, utf8_string_type, karma::domain>
+ {
+ typedef std::string type;
+
+ static type pre(utree const& t)
+ {
+ utf8_string_range_type r = detail::get_or_deref<utf8_string_range_type>(t);
+ return std::string(traits::begin(r), traits::end(r));
+ }
+ };
+
+ template <>
+ struct transform_attribute<utree const, utf8_symbol_type, karma::domain>
+ {
+ typedef std::string type;
+
+ static type pre(utree const& t)
+ {
+ utf8_symbol_range_type r = detail::get_or_deref<utf8_symbol_range_type>(t);
+ return std::string(traits::begin(r), traits::end(r));
+ }
+ };
+
+ template <typename Attribute>
+ struct transform_attribute<utree::list_type const, Attribute, karma::domain>
+ : transform_attribute<utree const, Attribute, karma::domain>
+ {};
+}}}
+
+#endif
projects / ceph.git / blobdiff