| // Copyright (c) 2001-2010 Hartmut Kaiser |
| // |
| // 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_KARMA_META_CREATE_NOV_21_2009_0425PM) |
| #define BOOST_SPIRIT_KARMA_META_CREATE_NOV_21_2009_0425PM |
| |
| #if defined(_MSC_VER) |
| #pragma once |
| #endif |
| |
| #include <boost/spirit/home/karma/domain.hpp> |
| #include <boost/spirit/home/support/common_terminals.hpp> |
| #include <boost/spirit/home/support/auto/meta_create.hpp> |
| |
| #include <boost/utility/enable_if.hpp> |
| #include <boost/variant.hpp> |
| #include <boost/optional.hpp> |
| #include <boost/config.hpp> |
| #include <boost/mpl/not.hpp> |
| #include <boost/mpl/fold.hpp> |
| #include <boost/mpl/vector.hpp> |
| #include <boost/mpl/push_back.hpp> |
| #include <boost/fusion/include/as_vector.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { namespace spirit { namespace karma |
| { |
| /////////////////////////////////////////////////////////////////////////// |
| // compatible STL containers |
| template <typename Container> |
| struct meta_create_container |
| { |
| typedef make_unary_proto_expr< |
| typename Container::value_type |
| , proto::tag::dereference, karma::domain |
| > make_proto_expr; |
| |
| typedef typename make_proto_expr::type type; |
| |
| static type call() |
| { |
| return make_proto_expr::call(); |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // String types |
| template <typename String> |
| struct meta_create_string |
| { |
| typedef spirit::standard::string_type type; |
| static type const& call() { return spirit::standard::string; } |
| }; |
| |
| template <> |
| struct meta_create_string<wchar_t*> |
| { |
| typedef spirit::standard_wide::string_type type; |
| static type const& call() { return spirit::standard_wide::string; } |
| }; |
| |
| template <> |
| struct meta_create_string<wchar_t const*> |
| { |
| typedef spirit::standard_wide::string_type type; |
| static type const& call() { return spirit::standard_wide::string; } |
| }; |
| |
| template <int N> |
| struct meta_create_string<wchar_t[N]> |
| { |
| typedef spirit::standard_wide::string_type type; |
| static type const& call() { return spirit::standard_wide::string; } |
| }; |
| |
| template <int N> |
| struct meta_create_string<wchar_t const[N]> |
| { |
| typedef spirit::standard_wide::string_type type; |
| static type const& call() { return spirit::standard_wide::string; } |
| }; |
| |
| template <int N> |
| struct meta_create_string<wchar_t(&)[N]> |
| { |
| typedef spirit::standard_wide::string_type type; |
| static type const& call() { return spirit::standard_wide::string; } |
| }; |
| |
| template <int N> |
| struct meta_create_string<wchar_t const(&)[N]> |
| { |
| typedef spirit::standard_wide::string_type type; |
| static type const& call() { return spirit::standard_wide::string; } |
| }; |
| |
| template <typename Traits, typename Allocator> |
| struct meta_create_string<std::basic_string<wchar_t, Traits, Allocator> > |
| { |
| typedef spirit::standard_wide::string_type type; |
| static type const& call() { return spirit::standard_wide::string; } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Fusion sequences |
| template <typename Sequence> |
| struct meta_create_sequence |
| { |
| // create a mpl sequence from the given fusion sequence |
| typedef typename mpl::fold< |
| typename fusion::result_of::as_vector<Sequence>::type |
| , mpl::vector<>, mpl::push_back<mpl::_, mpl::_> |
| >::type sequence_type; |
| |
| typedef make_nary_proto_expr< |
| sequence_type, proto::tag::shift_left, karma::domain |
| > make_proto_expr; |
| |
| typedef typename make_proto_expr::type type; |
| |
| static type call() |
| { |
| return make_proto_expr::call(); |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // the default is to use the standard streaming operator unless it's a |
| // STL container or a fusion sequence |
| |
| // The default implementation will be chosen if no predefined mapping of |
| // the data type T to a Karma component is defined. |
| struct no_auto_mapping_exists {}; |
| |
| template <typename T, typename Enable = void> |
| struct meta_create_impl : mpl::identity<no_auto_mapping_exists> {}; |
| |
| template <typename T> |
| struct meta_create_impl<T |
| , typename enable_if< |
| mpl::and_< |
| traits::is_container<T> |
| , mpl::not_<traits::is_string<T> > |
| , mpl::not_<fusion::traits::is_sequence<T> > |
| > >::type> |
| : meta_create_container<T> {}; |
| |
| template <typename T> |
| struct meta_create_impl<T |
| , typename enable_if<traits::is_string<T> >::type> |
| : meta_create_string<T> {}; |
| |
| template <typename T> |
| struct meta_create_impl<T |
| , typename enable_if<fusion::traits::is_sequence<T> >::type> |
| : meta_create_sequence<T> {}; |
| |
| template <typename T, typename Enable = void> |
| struct meta_create : meta_create_impl<T> {}; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // optional |
| template <typename T> |
| struct meta_create<boost::optional<T> > |
| { |
| typedef make_unary_proto_expr< |
| T, proto::tag::negate, karma::domain |
| > make_proto_expr; |
| |
| typedef typename make_proto_expr::type type; |
| |
| static type call() |
| { |
| return make_proto_expr::call(); |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // alternatives |
| template <BOOST_VARIANT_ENUM_PARAMS(typename T)> |
| struct meta_create<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> > |
| { |
| typedef make_nary_proto_expr< |
| typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types |
| , proto::tag::bitwise_or, karma::domain |
| > make_proto_expr; |
| |
| typedef typename make_proto_expr::type type; |
| |
| static type call() |
| { |
| return make_proto_expr::call(); |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // predefined specializations for primitive components |
| |
| // character generator |
| template <> |
| struct meta_create<char> |
| { |
| typedef spirit::standard::char_type type; |
| static type const& call() { return spirit::standard::char_; } |
| }; |
| template <> |
| struct meta_create<signed char> |
| { |
| typedef spirit::standard::char_type type; |
| static type const& call() { return spirit::standard::char_; } |
| }; |
| template <> |
| struct meta_create<wchar_t> |
| { |
| typedef spirit::standard_wide::char_type type; |
| static type const& call() { return spirit::standard_wide::char_; } |
| }; |
| |
| template <> |
| struct meta_create<unsigned char> |
| { |
| typedef spirit::standard::char_type type; |
| static type const& call() { return spirit::standard::char_; } |
| }; |
| |
| // boolean generator |
| template <> |
| struct meta_create<bool> |
| { |
| typedef spirit::bool__type type; |
| static type const& call() { return spirit::bool_; } |
| }; |
| |
| // integral generators |
| template <> |
| struct meta_create<int> |
| { |
| typedef spirit::int__type type; |
| static type const& call() { return spirit::int_; } |
| }; |
| template <> |
| struct meta_create<short> |
| { |
| typedef spirit::short__type type; |
| static type const& call() { return spirit::short_; } |
| }; |
| template <> |
| struct meta_create<long> |
| { |
| typedef spirit::long__type type; |
| static type const& call() { return spirit::long_; } |
| }; |
| template <> |
| struct meta_create<unsigned int> |
| { |
| typedef spirit::uint__type type; |
| static type const& call() { return spirit::uint_; } |
| }; |
| #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) |
| template <> |
| struct meta_create<unsigned short> |
| { |
| typedef spirit::ushort__type type; |
| static type const& call() { return spirit::ushort_; } |
| }; |
| #endif |
| template <> |
| struct meta_create<unsigned long> |
| { |
| typedef spirit::ulong__type type; |
| static type const& call() { return spirit::ulong_; } |
| }; |
| |
| #ifdef BOOST_HAS_LONG_LONG |
| template <> |
| struct meta_create<boost::long_long_type> |
| { |
| typedef spirit::long_long_type type; |
| static type const& call() { return spirit::long_long; } |
| }; |
| template <> |
| struct meta_create<boost::ulong_long_type> |
| { |
| typedef spirit::ulong_long_type type; |
| static type const& call() { return spirit::ulong_long; } |
| }; |
| #endif |
| |
| // floating point generators |
| template <> |
| struct meta_create<float> |
| { |
| typedef spirit::float__type type; |
| static type const& call() { return spirit::float_; } |
| }; |
| template <> |
| struct meta_create<double> |
| { |
| typedef spirit::double__type type; |
| static type const& call() { return spirit::double_; } |
| }; |
| template <> |
| struct meta_create<long double> |
| { |
| typedef spirit::long_double_type type; |
| static type const& call() { return spirit::long_double; } |
| }; |
| }}} |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { namespace spirit { namespace traits |
| { |
| /////////////////////////////////////////////////////////////////////////// |
| // main customization point for create_generator |
| template <typename T, typename Enable = void> |
| struct create_generator : karma::meta_create<T> {}; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // dispatch this to the karma related specializations |
| template <typename T> |
| struct meta_create<karma::domain, T> |
| : create_generator<typename spirit::detail::remove_const_ref<T>::type> {}; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Check whether a valid mapping exits for the given data type to a Karma |
| // component |
| template <typename T> |
| struct meta_create_exists<karma::domain, T> |
| : mpl::not_<is_same< |
| karma::no_auto_mapping_exists |
| , typename meta_create<karma::domain, T>::type |
| > > {}; |
| }}} |
| |
| #endif |