| #ifndef BOOST_PP_IS_ITERATING |
| /////////////////////////////////////////////////////////////////////////////// |
| /// \file callable.hpp |
| /// Definintion of callable_context\<\>, an evaluation context for |
| /// proto::eval() that explodes each node and calls the derived context |
| /// type with the expressions constituents. If the derived context doesn't |
| /// have an overload that handles this node, fall back to some other |
| /// context. |
| // |
| // 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_CONTEXT_CALLABLE_HPP_EAN_06_23_2007 |
| #define BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007 |
| |
| #include <boost/config.hpp> |
| #include <boost/detail/workaround.hpp> |
| #include <boost/preprocessor/cat.hpp> |
| #include <boost/preprocessor/iteration/iterate.hpp> |
| #include <boost/preprocessor/facilities/intercept.hpp> |
| #include <boost/preprocessor/repetition/repeat.hpp> |
| #include <boost/preprocessor/repetition/enum_params.hpp> |
| #include <boost/preprocessor/repetition/enum_trailing.hpp> |
| #include <boost/preprocessor/repetition/enum_trailing_params.hpp> |
| #include <boost/preprocessor/arithmetic/inc.hpp> |
| #include <boost/preprocessor/selection/max.hpp> |
| #include <boost/mpl/if.hpp> |
| #include <boost/mpl/bool.hpp> |
| #include <boost/utility/result_of.hpp> |
| #include <boost/type_traits/remove_cv.hpp> |
| #include <boost/proto/proto_fwd.hpp> |
| #include <boost/proto/traits.hpp> // for child_c |
| |
| namespace boost { namespace proto |
| { |
| namespace detail |
| { |
| template<typename Context> |
| struct callable_context_wrapper |
| : remove_cv<Context>::type |
| { |
| callable_context_wrapper(); |
| typedef private_type_ fun_type(...); |
| operator fun_type *() const; |
| private: |
| callable_context_wrapper &operator =(callable_context_wrapper const &); |
| }; |
| |
| template<typename T> |
| yes_type check_is_expr_handled(T const &); |
| |
| no_type check_is_expr_handled(private_type_ const &); |
| |
| template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> |
| struct is_expr_handled; |
| |
| template<typename Expr, typename Context> |
| struct is_expr_handled<Expr, Context, 0> |
| { |
| static callable_context_wrapper<Context> &sctx_; |
| static Expr &sexpr_; |
| static typename Expr::proto_tag &stag_; |
| |
| BOOST_STATIC_CONSTANT(bool, value = |
| ( |
| sizeof(yes_type) == |
| sizeof( |
| detail::check_is_expr_handled( |
| (sctx_(stag_, proto::value(sexpr_)), 0) |
| ) |
| ))); |
| |
| typedef mpl::bool_<value> type; |
| }; |
| } |
| |
| namespace context |
| { |
| /// \brief A BinaryFunction that accepts a Proto expression and a |
| /// callable context and calls the context with the expression tag |
| /// and children as arguments, effectively fanning the expression |
| /// out. |
| /// |
| /// <tt>callable_eval\<\></tt> requires that \c Context is a |
| /// PolymorphicFunctionObject that can be invoked with \c Expr's |
| /// tag and children as expressions, as follows: |
| /// |
| /// \code |
| /// context(Expr::proto_tag(), child_c<0>(expr), child_c<1>(expr), ...) |
| /// \endcode |
| template< |
| typename Expr |
| , typename Context |
| , long Arity // = Expr::proto_arity_c |
| > |
| struct callable_eval |
| {}; |
| |
| /// \brief A BinaryFunction that accepts a Proto expression and a |
| /// callable context and calls the context with the expression tag |
| /// and children as arguments, effectively fanning the expression |
| /// out. |
| /// |
| /// <tt>callable_eval\<\></tt> requires that \c Context is a |
| /// PolymorphicFunctionObject that can be invoked with \c Expr's |
| /// tag and children as expressions, as follows: |
| /// |
| /// \code |
| /// context(Expr::proto_tag(), value(expr)) |
| /// \endcode |
| template<typename Expr, typename Context> |
| struct callable_eval<Expr, Context, 0> |
| { |
| typedef typename proto::result_of::value<Expr const &>::type value_type; |
| |
| typedef |
| typename boost::tr1_result_of< |
| Context(typename Expr::proto_tag, value_type) |
| >::type |
| result_type; |
| |
| /// \param expr The current expression |
| /// \param context The callable evaluation context |
| /// \return <tt>context(Expr::proto_tag(), value(expr))</tt> |
| result_type operator ()(Expr &expr, Context &context) const |
| { |
| return context(typename Expr::proto_tag(), proto::value(expr)); |
| } |
| }; |
| |
| /// \brief An evaluation context adaptor that makes authoring a |
| /// context a simple matter of writing function overloads, rather |
| /// then writing template specializations. |
| /// |
| /// <tt>callable_context\<\></tt> is a base class that implements |
| /// the context protocol by passing fanned-out expression nodes to |
| /// the derived context, making it easy to customize the handling |
| /// of expression types by writing function overloads. Only those |
| /// expression types needing special handling require explicit |
| /// handling. All others are dispatched to a user-specified |
| /// default context, \c DefaultCtx. |
| /// |
| /// <tt>callable_context\<\></tt> is defined simply as: |
| /// |
| /// \code |
| /// template<typename Context, typename DefaultCtx = default_context> |
| /// struct callable_context |
| /// { |
| /// template<typename Expr, typename ThisContext = Context> |
| /// struct eval |
| /// : mpl::if_< |
| /// is_expr_handled_<Expr, Context> // For exposition |
| /// , callable_eval<Expr, ThisContext> |
| /// , typename DefaultCtx::template eval<Expr, Context> |
| /// >::type |
| /// {}; |
| /// }; |
| /// \endcode |
| /// |
| /// The Boolean metafunction <tt>is_expr_handled_\<\></tt> uses |
| /// metaprogramming tricks to determine whether \c Context has |
| /// an overloaded function call operator that accepts the |
| /// fanned-out constituents of an expression of type \c Expr. |
| /// If so, the handling of the expression is dispatched to |
| /// <tt>callable_eval\<\></tt>. If not, it is dispatched to |
| /// the user-specified \c DefaultCtx. |
| /// |
| /// Below is an example of how to use <tt>callable_context\<\></tt>: |
| /// |
| /// \code |
| /// // An evaluation context that increments all |
| /// // integer terminals in-place. |
| /// struct increment_ints |
| /// : callable_context< |
| /// increment_ints const // derived context |
| /// , null_context const // fall-back context |
| /// > |
| /// { |
| /// typedef void result_type; |
| /// |
| /// // Handle int terminals here: |
| /// void operator()(proto::tag::terminal, int &i) const |
| /// { |
| /// ++i; |
| /// } |
| /// }; |
| /// \endcode |
| /// |
| /// With \c increment_ints, we can do the following: |
| /// |
| /// \code |
| /// literal<int> i = 0, j = 10; |
| /// proto::eval( i - j * 3.14, increment_ints() ); |
| /// |
| /// assert( i.get() == 1 && j.get() == 11 ); |
| /// \endcode |
| template< |
| typename Context |
| , typename DefaultCtx // = default_context |
| > |
| struct callable_context |
| { |
| /// A BinaryFunction that accepts an \c Expr and a |
| /// \c Context, and either fans out the expression and passes |
| /// it to the context, or else hands off the expression to |
| /// \c DefaultCtx. |
| /// |
| /// If \c Context is a PolymorphicFunctionObject such that |
| /// it can be invoked with the tag and children of \c Expr, |
| /// as <tt>ctx(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr)...)</tt>, |
| /// then <tt>eval\<Expr, ThisContext\></tt> inherits from |
| /// <tt>callable_eval\<Expr, ThisContext\></tt>. Otherwise, |
| /// <tt>eval\<Expr, ThisContext\></tt> inherits from |
| /// <tt>DefaultCtx::eval\<Expr, Context\></tt>. |
| template<typename Expr, typename ThisContext = Context> |
| struct eval |
| : mpl::if_c< |
| detail::is_expr_handled<Expr, Context>::value |
| , callable_eval<Expr, ThisContext> |
| , typename DefaultCtx::template eval<Expr, Context> |
| >::type |
| {}; |
| }; |
| } |
| |
| #define BOOST_PROTO_CHILD_N_TYPE(Z, N, Expr) \ |
| typedef typename proto::result_of::child_c<Expr const &, N>::type BOOST_PP_CAT(child, N); \ |
| /**/ |
| |
| #define BOOST_PROTO_CHILD_N(Z, N, expr) \ |
| proto::child_c<N>(expr) \ |
| /**/ |
| |
| #define BOOST_PP_ITERATION_PARAMS_1 \ |
| (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/callable.hpp>)) \ |
| /**/ |
| |
| #include BOOST_PP_ITERATE() |
| |
| #undef BOOST_PROTO_CHILD_N_TYPE |
| #undef BOOST_PROTO_CHILD_N |
| |
| }} |
| |
| #endif |
| |
| #else |
| |
| #define N BOOST_PP_ITERATION() |
| |
| namespace detail |
| { |
| template<typename Expr, typename Context> |
| struct is_expr_handled<Expr, Context, N> |
| { |
| static callable_context_wrapper<Context> &sctx_; |
| static Expr &sexpr_; |
| static typename Expr::proto_tag &stag_; |
| |
| BOOST_STATIC_CONSTANT(bool, value = |
| ( |
| sizeof(yes_type) == |
| sizeof( |
| detail::check_is_expr_handled( |
| (sctx_( |
| stag_ |
| BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, sexpr_) |
| ), 0) |
| ) |
| ))); |
| |
| typedef mpl::bool_<value> type; |
| }; |
| } |
| |
| namespace context |
| { |
| /// \brief A BinaryFunction that accepts a Proto expression and a |
| /// callable context and calls the context with the expression tag |
| /// and children as arguments, effectively fanning the expression |
| /// out. |
| /// |
| /// <tt>callable_eval\<\></tt> requires that \c Context is a |
| /// PolymorphicFunctionObject that can be invoked with \c Expr's |
| /// tag and children as expressions, as follows: |
| /// |
| /// \code |
| /// context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...) |
| /// \endcode |
| template<typename Expr, typename Context> |
| struct callable_eval<Expr, Context, N> |
| { |
| BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD_N_TYPE, Expr) |
| |
| typedef |
| typename boost::tr1_result_of< |
| Context( |
| typename Expr::proto_tag |
| BOOST_PP_ENUM_TRAILING_PARAMS(N, child) |
| ) |
| >::type |
| result_type; |
| |
| /// \param expr The current expression |
| /// \param context The callable evaluation context |
| /// \return <tt>context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)</tt> |
| result_type operator ()(Expr &expr, Context &context) const |
| { |
| return context( |
| typename Expr::proto_tag() |
| BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, expr) |
| ); |
| } |
| }; |
| } |
| |
| #undef N |
| |
| #endif |