Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/context')
9 files changed, 1916 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/context/callable.hpp b/3rdParty/Boost/src/boost/proto/context/callable.hpp new file mode 100644 index 0000000..793ba83 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/callable.hpp @@ -0,0 +1,229 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \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 diff --git a/3rdParty/Boost/src/boost/proto/context/default.hpp b/3rdParty/Boost/src/boost/proto/context/default.hpp new file mode 100644 index 0000000..f3e586f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/default.hpp @@ -0,0 +1,409 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file default.hpp +/// Definintion of default_context, a default evaluation context for +/// proto::eval() that uses Boost.Typeof to deduce return types +/// of the built-in operators. +// +// 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_DEFAULT_HPP_EAN_01_08_2007 +#define BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007 + +#include <boost/config.hpp> +#include <boost/preprocessor/arithmetic/add.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_shifted.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/is_function.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/type_traits/is_member_pointer.hpp> +#include <boost/type_traits/is_member_object_pointer.hpp> +#include <boost/type_traits/is_member_function_pointer.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/tags.hpp> +#include <boost/proto/eval.hpp> +#include <boost/proto/traits.hpp> // for proto::child_c() +#include <boost/proto/detail/decltype.hpp> + +namespace boost { namespace proto +{ +/// INTERNAL ONLY +/// +#define UNREF(x) typename boost::remove_reference<x>::type + + namespace context + { + template< + typename Expr + , typename Context + , typename Tag // = typename Expr::proto_tag + , long Arity // = Expr::proto_arity_c + > + struct default_eval + {}; + + template<typename Expr, typename Context> + struct default_eval<Expr, Context, tag::terminal, 0> + { + typedef + typename proto::result_of::value<Expr &>::type + result_type; + + result_type operator ()(Expr &expr, Context &) const + { + return proto::value(expr); + } + }; + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \ + template<typename Expr, typename Context> \ + struct default_eval<Expr, Context, TAG, 1> \ + { \ + private: \ + typedef typename proto::result_of::child_c<Expr, 0>::type e0; \ + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; \ + public: \ + BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \ + result_type operator ()(Expr &expr, Context &ctx) const \ + { \ + return OP proto::eval(proto::child_c<0>(expr), ctx); \ + } \ + }; \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \ + template<typename Expr, typename Context> \ + struct default_eval<Expr, Context, TAG, 2> \ + { \ + private: \ + typedef typename proto::result_of::child_c<Expr, 0>::type e0; \ + typedef typename proto::result_of::child_c<Expr, 1>::type e1; \ + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; \ + typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; \ + public: \ + BOOST_PROTO_DECLTYPE_( \ + proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \ + , result_type \ + ) \ + result_type operator ()(Expr &expr, Context &ctx) const \ + { \ + return proto::eval( \ + proto::child_c<0>(expr), ctx) OP proto::eval(proto::child_c<1>(expr) \ + , ctx \ + ); \ + } \ + }; \ + /**/ + + BOOST_PROTO_UNARY_DEFAULT_EVAL(+, proto::tag::unary_plus, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(-, proto::tag::negate, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(*, proto::tag::dereference, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(~, proto::tag::complement, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(&, proto::tag::address_of, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(!, proto::tag::logical_not, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(++, proto::tag::pre_inc, make_mutable) + BOOST_PROTO_UNARY_DEFAULT_EVAL(--, proto::tag::pre_dec, make_mutable) + + BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, proto::tag::shift_left, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, proto::tag::shift_right, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(*, proto::tag::multiplies, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(/, proto::tag::divides, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(%, proto::tag::modulus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(+, proto::tag::plus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(-, proto::tag::minus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<, proto::tag::less, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>, proto::tag::greater, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, proto::tag::less_equal, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, proto::tag::greater_equal, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(==, proto::tag::equal_to, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, proto::tag::not_equal_to, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(||, proto::tag::logical_or, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, proto::tag::logical_and, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&, proto::tag::bitwise_and, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(|, proto::tag::bitwise_or, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(^, proto::tag::bitwise_xor, make, make) + + BOOST_PROTO_BINARY_DEFAULT_EVAL(=, proto::tag::assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, proto::tag::shift_left_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, proto::tag::shift_right_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, proto::tag::multiplies_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, proto::tag::divides_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, proto::tag::modulus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, proto::tag::plus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, proto::tag::minus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, proto::tag::bitwise_and_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, proto::tag::bitwise_or_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, proto::tag::bitwise_xor_assign, make_mutable, make) + + #undef BOOST_PROTO_UNARY_DEFAULT_EVAL + #undef BOOST_PROTO_BINARY_DEFAULT_EVAL + + /// INTERNAL ONLY + template<typename Expr, typename Context> + struct is_member_function_eval + : is_member_function_pointer< + typename detail::uncvref< + typename proto::result_of::eval< + typename remove_reference< + typename proto::result_of::child_c<Expr, 1>::type + >::type + , Context + >::type + >::type + > + {}; + + /// INTERNAL ONLY + template<typename Expr, typename Context, bool IsMemFunCall> + struct memfun_eval + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; + typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; + public: + typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type; + result_type operator ()(Expr &expr, Context &ctx) const + { + return detail::mem_ptr_fun<r0, r1>()( + proto::eval(proto::child_c<0>(expr), ctx) + , proto::eval(proto::child_c<1>(expr), ctx) + ); + } + }; + + /// INTERNAL ONLY + template<typename Expr, typename Context> + struct memfun_eval<Expr, Context, true> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; + typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; + public: + typedef detail::memfun<r0, r1> result_type; + result_type const operator ()(Expr &expr, Context &ctx) const + { + return detail::memfun<r0, r1>( + proto::eval(proto::child_c<0>(expr), ctx) + , proto::eval(proto::child_c<1>(expr), ctx) + ); + } + }; + + template<typename Expr, typename Context> + struct default_eval<Expr, Context, tag::mem_ptr, 2> + : memfun_eval<Expr, Context, is_member_function_eval<Expr, Context>::value> + {}; + + // Handle post-increment specially. + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::post_inc, 1> + { + private: + typedef typename proto::result_of::child_c<Expr, 0>::type e0; + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; + public: + BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type) + result_type operator ()(Expr &expr, Context &ctx) const + { + return proto::eval(proto::child_c<0>(expr), ctx) ++; + } + }; + + // Handle post-decrement specially. + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::post_dec, 1> + { + private: + typedef typename proto::result_of::child_c<Expr, 0>::type e0; + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; + public: + BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type) + result_type operator ()(Expr &expr, Context &ctx) const + { + return proto::eval(proto::child_c<0>(expr), ctx) --; + } + }; + + // Handle subscript specially. + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::subscript, 2> + { + private: + typedef typename proto::result_of::child_c<Expr, 0>::type e0; + typedef typename proto::result_of::child_c<Expr, 1>::type e1; + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; + typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; + public: + BOOST_PROTO_DECLTYPE_(proto::detail::make_subscriptable<r0>()[proto::detail::make<r1>()], result_type) + result_type operator ()(Expr &expr, Context &ctx) const + { + return proto::eval(proto::child_c<0>(expr), ctx)[proto::eval(proto::child_c<1>(expr), ctx)]; + } + }; + + // Handle if_else_ specially. + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::if_else_, 3> + { + private: + typedef typename proto::result_of::child_c<Expr, 0>::type e0; + typedef typename proto::result_of::child_c<Expr, 1>::type e1; + typedef typename proto::result_of::child_c<Expr, 2>::type e2; + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; + typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; + typedef typename proto::result_of::eval<UNREF(e2), Context>::type r2; + public: + BOOST_PROTO_DECLTYPE_( + proto::detail::make<r0>() + ? proto::detail::make<r1>() + : proto::detail::make<r2>() + , result_type + ) + result_type operator ()(Expr &expr, Context &ctx) const + { + return proto::eval(proto::child_c<0>(expr), ctx) + ? proto::eval(proto::child_c<1>(expr), ctx) + : proto::eval(proto::child_c<2>(expr), ctx); + } + }; + + // Handle comma specially. + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::comma, 2> + { + private: + typedef typename proto::result_of::child_c<Expr, 0>::type e0; + typedef typename proto::result_of::child_c<Expr, 1>::type e1; + typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0; + typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1; + public: + typedef typename proto::detail::comma_result<r0, r1>::type result_type; + result_type operator ()(Expr &expr, Context &ctx) const + { + return proto::eval(proto::child_c<0>(expr), ctx), proto::eval(proto::child_c<1>(expr), ctx); + } + }; + + // Handle function specially + #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \ + typename proto::result_of::eval< \ + typename remove_reference< \ + typename proto::result_of::child_c<DATA, N>::type \ + >::type \ + , Context \ + >::type \ + /**/ + + #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \ + proto::eval(proto::child_c<N>(DATA), context) \ + /**/ + + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 1> + { + typedef + typename proto::detail::result_of_fixup< + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) + >::type + function_type; + + typedef + typename BOOST_PROTO_RESULT_OF<function_type()>::type + result_type; + + result_type operator ()(Expr &expr, Context &context) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(); + } + }; + + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 2> + { + typedef + typename proto::detail::result_of_fixup< + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) + >::type + function_type; + + typedef + typename detail::result_of_< + function_type(BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr)) + >::type + result_type; + + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke( + expr + , context + , is_member_function_pointer<function_type>() + , is_member_object_pointer<function_type>() + ); + } + + private: + result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::false_) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(BOOST_PROTO_DEFAULT_EVAL(~, 1, expr)); + } + + result_type invoke(Expr &expr, Context &context, mpl::true_, mpl::false_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, expr))) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, expr) + )(); + } + + result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, expr))) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, expr) + ); + } + }; + + // Additional specialization are generated by the preprocessor + #include <boost/proto/context/detail/default_eval.hpp> + + #undef BOOST_PROTO_DEFAULT_EVAL_TYPE + #undef BOOST_PROTO_DEFAULT_EVAL + + /// default_context + /// + struct default_context + { + /// default_context::eval + /// + template<typename Expr, typename ThisContext = default_context const> + struct eval + : default_eval<Expr, ThisContext> + {}; + }; + + } // namespace context + +}} // namespace boost::proto + +#undef UNREF + +#endif diff --git a/3rdParty/Boost/src/boost/proto/context/detail/callable_eval.hpp b/3rdParty/Boost/src/boost/proto/context/detail/callable_eval.hpp new file mode 100644 index 0000000..abe7803 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/detail/callable_eval.hpp @@ -0,0 +1,113 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/context/detail/preprocessed/callable_eval.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #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) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/callable_eval.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file callable_eval.hpp + /// Contains specializations of the callable_eval\<\> class template. + // + // 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) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 1) + #endif + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/callable_eval.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_CHILD_N_TYPE + #undef BOOST_PROTO_CHILD_N + +#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_; + + static const 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_PROTO_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 diff --git a/3rdParty/Boost/src/boost/proto/context/detail/default_eval.hpp b/3rdParty/Boost/src/boost/proto/context/detail/default_eval.hpp new file mode 100644 index 0000000..9804276 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/detail/default_eval.hpp @@ -0,0 +1,82 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/context/detail/preprocessed/default_eval.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_DEFAULT_EVAL_SHIFTED(Z, M, DATA) \ + BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/default_eval.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file default_eval.hpp + /// Contains specializations of the default_eval\<\> class template. + // + // 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) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 1) + #endif + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/default_eval.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_DEFAULT_EVAL_SHIFTED + +#else + + #define N BOOST_PP_ITERATION() + + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, N> + { + typedef + typename proto::detail::result_of_fixup< + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) + >::type + function_type; + + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr)) + >::type + result_type; + + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)( + BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, expr) + ); + } + + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, expr))) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, expr) + )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), BOOST_PROTO_DEFAULT_EVAL_SHIFTED, expr)); + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/context/detail/null_eval.hpp b/3rdParty/Boost/src/boost/proto/context/detail/null_eval.hpp new file mode 100644 index 0000000..dcf0077 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/detail/null_eval.hpp @@ -0,0 +1,54 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/context/detail/preprocessed/null_eval.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_EVAL_N(Z, N, DATA) \ + proto::eval(proto::child_c<N>(expr), ctx); \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/null_eval.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file null_eval.hpp + /// Contains specializations of the null_eval\<\> class template. + // + // 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) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 1) + #endif + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/null_eval.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_EVAL_N + +#else + + #define N BOOST_PP_ITERATION() + + template<typename Expr, typename Context> + struct null_eval<Expr, Context, N> + { + typedef void result_type; + + void operator ()(Expr &expr, Context &ctx) const + { + BOOST_PP_REPEAT(N, BOOST_PROTO_EVAL_N, ~) + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/callable_eval.hpp b/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/callable_eval.hpp new file mode 100644 index 0000000..5b32c8f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/callable_eval.hpp @@ -0,0 +1,597 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file callable_eval.hpp + /// Contains specializations of the callable_eval\<\> class template. + // + // 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) + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 1> + { + 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::child_c< 0>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 1> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 2> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 2> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 3> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 3> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 , child2 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 4> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 4> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 , child2 , child3 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 5> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 5> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 , child2 , child3 , child4 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 6> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 6> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 , child2 , child3 , child4 , child5 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 7> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 7> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 , child2 , child3 , child4 , child5 , child6 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 8> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 8> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 9> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 9> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr) + ); + } + }; + } + namespace detail + { + template<typename Expr, typename Context> + struct is_expr_handled<Expr, Context, 10> + { + 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::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_) , proto::child_c< 9>( sexpr_) + ), 0) + ) + ); + typedef mpl::bool_<value> type; + }; + } + namespace context + { + + + + + + + + + + + + + template<typename Expr, typename Context> + struct callable_eval<Expr, Context, 10> + { + typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8; typedef typename proto::result_of::child_c< Expr const &, 9>::type child9; + typedef + typename BOOST_PROTO_RESULT_OF< + Context( + typename Expr::proto_tag + , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9 + ) + >::type + result_type; + + + + result_type operator ()(Expr &expr, Context &context) const + { + return context( + typename Expr::proto_tag() + , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr) , proto::child_c< 9>( expr) + ); + } + }; + } diff --git a/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/default_eval.hpp b/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/default_eval.hpp new file mode 100644 index 0000000..ebc69ce --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/default_eval.hpp @@ -0,0 +1,279 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file default_eval.hpp + /// Contains specializations of the default_eval\<\> class template. + // + // 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) + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 3> + { + typedef + typename proto::detail::result_of_fixup< + typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type + >::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type) + >::type + result_type; + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return proto::eval(proto::child_c< 0>( expr), context)( + proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) + ); + } + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* + proto::eval(proto::child_c< 0>( expr), context) + )(proto::eval(proto::child_c< 2>( expr), context)); + } + }; + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 4> + { + typedef + typename proto::detail::result_of_fixup< + typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type + >::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type) + >::type + result_type; + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return proto::eval(proto::child_c< 0>( expr), context)( + proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) + ); + } + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* + proto::eval(proto::child_c< 0>( expr), context) + )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context)); + } + }; + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 5> + { + typedef + typename proto::detail::result_of_fixup< + typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type + >::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type) + >::type + result_type; + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return proto::eval(proto::child_c< 0>( expr), context)( + proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) + ); + } + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* + proto::eval(proto::child_c< 0>( expr), context) + )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context)); + } + }; + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 6> + { + typedef + typename proto::detail::result_of_fixup< + typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type + >::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type) + >::type + result_type; + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return proto::eval(proto::child_c< 0>( expr), context)( + proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) + ); + } + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* + proto::eval(proto::child_c< 0>( expr), context) + )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context)); + } + }; + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 7> + { + typedef + typename proto::detail::result_of_fixup< + typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type + >::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type) + >::type + result_type; + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return proto::eval(proto::child_c< 0>( expr), context)( + proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) + ); + } + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* + proto::eval(proto::child_c< 0>( expr), context) + )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context)); + } + }; + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 8> + { + typedef + typename proto::detail::result_of_fixup< + typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type + >::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type) + >::type + result_type; + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return proto::eval(proto::child_c< 0>( expr), context)( + proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) + ); + } + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* + proto::eval(proto::child_c< 0>( expr), context) + )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context)); + } + }; + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 9> + { + typedef + typename proto::detail::result_of_fixup< + typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type + >::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type) + >::type + result_type; + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return proto::eval(proto::child_c< 0>( expr), context)( + proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) + ); + } + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* + proto::eval(proto::child_c< 0>( expr), context) + )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context)); + } + }; + template<typename Expr, typename Context> + struct default_eval<Expr, Context, proto::tag::function, 10> + { + typedef + typename proto::detail::result_of_fixup< + typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type + >::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 9>::type >::type , Context >::type) + >::type + result_type; + result_type operator ()(Expr &expr, Context &context) const + { + return this->invoke(expr, context, is_member_function_pointer<function_type>()); + } + private: + result_type invoke(Expr &expr, Context &context, mpl::false_) const + { + return proto::eval(proto::child_c< 0>( expr), context)( + proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context) + ); + } + result_type invoke(Expr &expr, Context &context, mpl::true_) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->* + proto::eval(proto::child_c< 0>( expr), context) + )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context)); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/null_eval.hpp b/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/null_eval.hpp new file mode 100644 index 0000000..e124408 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/detail/preprocessed/null_eval.hpp @@ -0,0 +1,97 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file null_eval.hpp + /// Contains specializations of the null_eval\<\> class template. + // + // 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) + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 1> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 2> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 3> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 4> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 5> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 6> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 7> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 8> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 9> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx); + } + }; + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 10> + { + typedef void result_type; + void operator ()(Expr &expr, Context &ctx) const + { + proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx); proto::eval(proto::child_c< 9>(expr), ctx); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/context/null.hpp b/3rdParty/Boost/src/boost/proto/context/null.hpp new file mode 100644 index 0000000..7e0dc5f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context/null.hpp @@ -0,0 +1,56 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file null.hpp +/// Definintion of null_context\<\>, an evaluation context for +/// proto::eval() that simply evaluates each child expression, doesn't +/// combine the results at all, and returns void. +// +// 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_NULL_HPP_EAN_06_24_2007 +#define BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007 + +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/eval.hpp> +#include <boost/proto/traits.hpp> + +namespace boost { namespace proto { namespace context +{ + + template< + typename Expr + , typename Context + , long Arity // = Expr::proto_arity_c + > + struct null_eval + {}; + + template<typename Expr, typename Context> + struct null_eval<Expr, Context, 0> + { + typedef void result_type; + void operator()(Expr &, Context &) const + {} + }; + + // Additional specializations generated by the preprocessor + #include <boost/proto/context/detail/null_eval.hpp> + + /// null_context + /// + struct null_context + { + /// null_context::eval + /// + template<typename Expr, typename ThisContext = null_context const> + struct eval + : null_eval<Expr, ThisContext> + {}; + }; + +}}} + +#endif |