comparison DEPENDENCIES/generic/include/boost/proto/context/callable.hpp @ 16:2665513ce2d3

Add boost headers

+///////////////////////////////////////////////////////////////////////////////
+/// \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