#ifndef BOOST_PP_IS_ITERATING /////////////////////////////////////////////////////////////////////////////// /// \file generate.hpp /// Contains definition of generate\<\> class template, which end users can /// specialize for generating domain-specific expression wrappers. // // Copyright 2008 Eric Niebler. 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) #ifndef BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 #define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 #include #include #include #include #include #include #include #include #include #include namespace boost { namespace proto { namespace detail { template struct expr_params; template struct expr_params > { typedef Tag tag; typedef Args args; BOOST_STATIC_CONSTANT(long, arity = N); }; template::arity> struct by_value_generator_; #define BOOST_PROTO_DEFINE_BY_VALUE_TYPE(Z, N, Expr) \ typename uncvref::args::BOOST_PP_CAT(child, N)>::type \ /**/ #define BOOST_PROTO_DEFINE_BY_VALUE(Z, N, expr) \ expr.BOOST_PP_CAT(child, N) \ /**/ template struct by_value_generator_ { typedef proto::expr< typename expr_params::tag , term::args::child0>::value_type> , 0 > type; static type const make(Expr const &e) { type that = {e.child0}; return that; } }; #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, )) #include BOOST_PP_ITERATE() #undef BOOST_PROTO_DEFINE_BY_VALUE #undef BOOST_PROTO_DEFINE_BY_VALUE_TYPE } BOOST_PROTO_BEGIN_ADL_NAMESPACE(generatorns_) /// \brief A simple generator that passes an expression /// through unchanged. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// The \c default_generator makes no modifications to the expressions /// passed to it. struct default_generator { BOOST_PROTO_CALLABLE() template struct result; template struct result { typedef Expr type; }; /// \param expr A Proto expression /// \return expr template #ifdef BOOST_HAS_DECLTYPE Expr #else Expr const & #endif operator ()(Expr const &e) const { return e; } }; /// \brief A generator that wraps expressions passed /// to it in the specified extension wrapper. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// \c generator\<\> wraps each expression passed to it in /// the \c Extends\<\> wrapper. template class Extends> struct generator { BOOST_PROTO_CALLABLE() template struct result; template struct result { typedef Extends type; }; template struct result { typedef Extends type; }; template struct result { typedef Extends type; }; /// \param expr A Proto expression /// \return Extends(expr) template Extends operator ()(Expr const &e) const { return Extends(e); } }; /// \brief A generator that wraps expressions passed /// to it in the specified extension wrapper and uses /// aggregate initialization for the wrapper. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// \c pod_generator\<\> wraps each expression passed to it in /// the \c Extends\<\> wrapper, and uses aggregate initialzation /// for the wrapped object. template class Extends> struct pod_generator { BOOST_PROTO_CALLABLE() template struct result; template struct result { typedef Extends type; }; template struct result { typedef Extends type; }; template struct result { typedef Extends type; }; /// \param expr The expression to wrap /// \return Extends\ that = {expr}; return that; template Extends operator ()(Expr const &e) const { Extends that = {e}; return that; } }; /// \brief A generator that replaces child nodes held by /// reference with ones held by value. Use with /// \c compose_generators to forward that result to another /// generator. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// \c by_value_generator ensures all child nodes are /// held by value. This generator is typically composed with a /// second generator for further processing, as /// compose_generators\. struct by_value_generator { BOOST_PROTO_CALLABLE() template struct result; template struct result { typedef typename detail::by_value_generator_::type type; }; template struct result { typedef typename detail::by_value_generator_::type type; }; template struct result { typedef typename detail::by_value_generator_::type type; }; /// \param expr The expression to modify. /// \return deep_copy(expr) template typename result::type operator ()(Expr const &e) const { return detail::by_value_generator_::make(e); } }; /// \brief A composite generator that first applies one /// transform to an expression and then forwards the result /// on to another generator for further transformation. /// /// Generators are intended for use as the first template parameter /// to the \c domain\<\> class template and control if and how /// expressions within that domain are to be customized. /// \c compose_generators\<\> is a composite generator that first /// applies one transform to an expression and then forwards the /// result on to another generator for further transformation. template struct compose_generators { BOOST_PROTO_CALLABLE() template struct result; template struct result { typedef typename Second::template result< Second(typename First::template result::type) >::type type; }; template struct result { typedef typename Second::template result< Second(typename First::template result::type) >::type type; }; template struct result { typedef typename Second::template result< Second(typename First::template result::type) >::type type; }; /// \param expr The expression to modify. /// \return Second()(First()(expr)) template typename result::type operator ()(Expr const &e) const { return Second()(First()(e)); } }; BOOST_PROTO_END_ADL_NAMESPACE(generatorns_) /// INTERNAL ONLY template<> struct is_callable : mpl::true_ {}; /// INTERNAL ONLY template class Extends> struct is_callable > : mpl::true_ {}; /// INTERNAL ONLY template class Extends> struct is_callable > : mpl::true_ {}; /// INTERNAL ONLY template<> struct is_callable : mpl::true_ {}; /// INTERNAL ONLY template struct is_callable > : mpl::true_ {}; }} // Specialization of boost::result_of to eliminate some unnecessary template instantiations namespace boost { template struct result_of { typedef Expr type; }; } #endif // BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 #else // BOOST_PP_IS_ITERATING #define N BOOST_PP_ITERATION() template struct by_value_generator_ { typedef proto::expr< typename expr_params::tag , BOOST_PP_CAT(list, N)< // typename uncvref::args::child0>::type, ... BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_BY_VALUE_TYPE, Expr) > , N > type; static type const make(Expr const &e) { type that = { // expr.child0, ... BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_BY_VALUE, e) }; return that; } }; #undef N #endif