boost/proto/context/callable.hpp
/////////////////////////////////////////////////////////////////////////////// /// \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_; static const 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_PROTO_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 {}; }; } #include <boost/proto/context/detail/callable_eval.hpp> }} #endif