Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto')
148 files changed, 37598 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/args.hpp b/3rdParty/Boost/src/boost/proto/args.hpp new file mode 100644 index 0000000..9b7afdb --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/args.hpp @@ -0,0 +1,132 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file args.hpp +/// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ... +/// class templates. +// +// 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_ARGS_HPP_EAN_04_01_2005 +#define BOOST_PROTO_ARGS_HPP_EAN_04_01_2005 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/void.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/detail/is_noncopyable.hpp> + +#include <boost/mpl/or.hpp> +#include <boost/type_traits/is_function.hpp> +#include <boost/type_traits/is_abstract.hpp> + +namespace boost { namespace proto +{ + namespace detail + { + /// INTERNAL ONLY + template<typename Expr> + struct expr_traits + { + typedef Expr value_type; + typedef Expr &reference; + typedef Expr const &const_reference; + }; + + /// INTERNAL ONLY + template<typename Expr> + struct expr_traits<Expr &> + { + typedef Expr value_type; + typedef Expr &reference; + typedef Expr &const_reference; + }; + + /// INTERNAL ONLY + template<typename Expr> + struct expr_traits<Expr const &> + { + typedef Expr value_type; + typedef Expr const &reference; + typedef Expr const &const_reference; + }; + + /// INTERNAL ONLY + template<typename T> + struct term_traits + { + typedef T value_type; + typedef T &reference; + typedef T const &const_reference; + }; + + /// INTERNAL ONLY + template<typename T> + struct term_traits<T &> + { + typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type value_type; + typedef T &reference; + typedef T &const_reference; + }; + + /// INTERNAL ONLY + template<typename T> + struct term_traits<T const &> + { + typedef T value_type; + typedef T const &reference; + typedef T const &const_reference; + }; + + /// INTERNAL ONLY + template<typename T, std::size_t N> + struct term_traits<T (&)[N]> + { + typedef T value_type[N]; + typedef T (&reference)[N]; + typedef T (&const_reference)[N]; + }; + + /// INTERNAL ONLY + template<typename T, std::size_t N> + struct term_traits<T const (&)[N]> + { + typedef T value_type[N]; + typedef T const (&reference)[N]; + typedef T const (&const_reference)[N]; + }; + + /// INTERNAL ONLY + template<typename T, std::size_t N> + struct term_traits<T[N]> + { + typedef T value_type[N]; + typedef T (&reference)[N]; + typedef T const (&const_reference)[N]; + }; + + /// INTERNAL ONLY + template<typename T, std::size_t N> + struct term_traits<T const[N]> + { + typedef T value_type[N]; + typedef T const (&reference)[N]; + typedef T const (&const_reference)[N]; + }; + } + + namespace argsns_ + { + // This is where term and all the different listN templates are defined + #include <boost/proto/detail/args.hpp> + } + +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/proto/context.hpp b/3rdParty/Boost/src/boost/proto/context.hpp new file mode 100644 index 0000000..8ac9200 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/context.hpp @@ -0,0 +1,16 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file context.hpp +/// Includes all the context classes in the context/ sub-directory. +// +// 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_HPP_EAN_06_23_2007 +#define BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007 + +#include <boost/proto/context/null.hpp> +#include <boost/proto/context/default.hpp> +#include <boost/proto/context/callable.hpp> + +#endif 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 diff --git a/3rdParty/Boost/src/boost/proto/core.hpp b/3rdParty/Boost/src/boost/proto/core.hpp new file mode 100644 index 0000000..615e7e8 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/core.hpp @@ -0,0 +1,30 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file core.hpp +/// Includes the core of Proto. Not included are the contexts, transforms and +/// debugging utilities. +// +// 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_CORE_HPP_EAN_04_01_2005 +#define BOOST_PROTO_CORE_HPP_EAN_04_01_2005 + +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/args.hpp> +#include <boost/proto/tags.hpp> +#include <boost/proto/eval.hpp> +#include <boost/proto/expr.hpp> +#include <boost/proto/repeat.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/domain.hpp> +#include <boost/proto/fusion.hpp> +#include <boost/proto/matches.hpp> +#include <boost/proto/extends.hpp> +#include <boost/proto/literal.hpp> +#include <boost/proto/generate.hpp> +#include <boost/proto/operators.hpp> +#include <boost/proto/deep_copy.hpp> +#include <boost/proto/make_expr.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/debug.hpp b/3rdParty/Boost/src/boost/proto/debug.hpp new file mode 100644 index 0000000..f732bc2 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/debug.hpp @@ -0,0 +1,267 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file debug.hpp +/// Utilities for debugging Proto expression trees +// +// 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_DEBUG_HPP_EAN_12_31_2006 +#define BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006 + +#include <iostream> +#include <boost/preprocessor/stringize.hpp> +#include <boost/ref.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/matches.hpp> +#include <boost/proto/fusion.hpp> +#include <boost/fusion/algorithm/iteration/for_each.hpp> +#include <boost/detail/sp_typeinfo.hpp> + +namespace boost { namespace proto +{ + namespace tagns_ { namespace tag + { + #define BOOST_PROTO_DEFINE_TAG_INSERTION(Tag) \ + /** \brief INTERNAL ONLY */ \ + inline std::ostream &operator <<(std::ostream &sout, Tag const &) \ + { \ + return sout << BOOST_PP_STRINGIZE(Tag); \ + } \ + /**/ + + BOOST_PROTO_DEFINE_TAG_INSERTION(terminal) + BOOST_PROTO_DEFINE_TAG_INSERTION(unary_plus) + BOOST_PROTO_DEFINE_TAG_INSERTION(negate) + BOOST_PROTO_DEFINE_TAG_INSERTION(dereference) + BOOST_PROTO_DEFINE_TAG_INSERTION(complement) + BOOST_PROTO_DEFINE_TAG_INSERTION(address_of) + BOOST_PROTO_DEFINE_TAG_INSERTION(logical_not) + BOOST_PROTO_DEFINE_TAG_INSERTION(pre_inc) + BOOST_PROTO_DEFINE_TAG_INSERTION(pre_dec) + BOOST_PROTO_DEFINE_TAG_INSERTION(post_inc) + BOOST_PROTO_DEFINE_TAG_INSERTION(post_dec) + BOOST_PROTO_DEFINE_TAG_INSERTION(shift_left) + BOOST_PROTO_DEFINE_TAG_INSERTION(shift_right) + BOOST_PROTO_DEFINE_TAG_INSERTION(multiplies) + BOOST_PROTO_DEFINE_TAG_INSERTION(divides) + BOOST_PROTO_DEFINE_TAG_INSERTION(modulus) + BOOST_PROTO_DEFINE_TAG_INSERTION(plus) + BOOST_PROTO_DEFINE_TAG_INSERTION(minus) + BOOST_PROTO_DEFINE_TAG_INSERTION(less) + BOOST_PROTO_DEFINE_TAG_INSERTION(greater) + BOOST_PROTO_DEFINE_TAG_INSERTION(less_equal) + BOOST_PROTO_DEFINE_TAG_INSERTION(greater_equal) + BOOST_PROTO_DEFINE_TAG_INSERTION(equal_to) + BOOST_PROTO_DEFINE_TAG_INSERTION(not_equal_to) + BOOST_PROTO_DEFINE_TAG_INSERTION(logical_or) + BOOST_PROTO_DEFINE_TAG_INSERTION(logical_and) + BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_and) + BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_or) + BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_xor) + BOOST_PROTO_DEFINE_TAG_INSERTION(comma) + BOOST_PROTO_DEFINE_TAG_INSERTION(mem_ptr) + BOOST_PROTO_DEFINE_TAG_INSERTION(assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(shift_left_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(shift_right_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(multiplies_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(divides_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(modulus_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(plus_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(minus_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_and_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_or_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_xor_assign) + BOOST_PROTO_DEFINE_TAG_INSERTION(subscript) + BOOST_PROTO_DEFINE_TAG_INSERTION(member) + BOOST_PROTO_DEFINE_TAG_INSERTION(if_else_) + BOOST_PROTO_DEFINE_TAG_INSERTION(function) + + #undef BOOST_PROTO_DEFINE_TAG_INSERTION + }} + + namespace hidden_detail_ + { + struct ostream_wrapper + { + ostream_wrapper(std::ostream &sout) + : sout_(sout) + {} + + std::ostream &sout_; + + private: + ostream_wrapper &operator =(ostream_wrapper const &); + }; + + struct named_any + { + template<typename T> + named_any(T const &) + : name_(BOOST_SP_TYPEID(T).name()) + {} + + char const *name_; + }; + + inline std::ostream &operator <<(ostream_wrapper sout_wrap, named_any t) + { + return sout_wrap.sout_ << t.name_; + } + } + + namespace detail + { + struct display_expr_impl + { + explicit display_expr_impl(std::ostream &sout, int depth = 0) + : depth_(depth) + , first_(true) + , sout_(sout) + {} + + template<typename Expr> + void operator()(Expr const &expr) const + { + this->impl(expr, mpl::long_<arity_of<Expr>::value>()); + } + + private: + display_expr_impl(display_expr_impl const &); + display_expr_impl &operator =(display_expr_impl const &); + + template<typename Expr> + void impl(Expr const &expr, mpl::long_<0>) const + { + using namespace hidden_detail_; + typedef typename tag_of<Expr>::type tag; + this->sout_.width(this->depth_); + this->sout_ << (this->first_? "" : ", "); + this->sout_ << tag() << "(" << proto::value(expr) << ")\n"; + this->first_ = false; + } + + template<typename Expr, typename Arity> + void impl(Expr const &expr, Arity) const + { + using namespace hidden_detail_; + typedef typename tag_of<Expr>::type tag; + this->sout_.width(this->depth_); + this->sout_ << (this->first_? "" : ", "); + this->sout_ << tag() << "(\n"; + display_expr_impl display(this->sout_, this->depth_ + 4); + fusion::for_each(expr, display); + this->sout_.width(this->depth_); + this->sout_ << "" << ")\n"; + this->first_ = false; + } + + int depth_; + mutable bool first_; + std::ostream &sout_; + }; + } + + namespace functional + { + /// \brief Pretty-print a Proto expression tree. + /// + /// A PolymorphicFunctionObject which accepts a Proto expression + /// tree and pretty-prints it to an \c ostream for debugging + /// purposes. + struct display_expr + { + BOOST_PROTO_CALLABLE() + + typedef void result_type; + + /// \param sout The \c ostream to which the expression tree + /// will be written. + /// \param depth The starting indentation depth for this node. + /// Children nodes will be displayed at a starting + /// depth of <tt>depth+4</tt>. + explicit display_expr(std::ostream &sout = std::cout, int depth = 0) + : depth_(depth) + , sout_(sout) + {} + + /// \brief Pretty-print the current node in a Proto expression + /// tree. + template<typename Expr> + void operator()(Expr const &expr) const + { + detail::display_expr_impl(this->sout_, this->depth_)(expr); + } + + private: + int depth_; + reference_wrapper<std::ostream> sout_; + }; + } + + /// \brief Pretty-print a Proto expression tree. + /// + /// \note Equivalent to <tt>functional::display_expr(0, sout)(expr)</tt> + /// \param expr The Proto expression tree to pretty-print + /// \param sout The \c ostream to which the output should be + /// written. If not specified, defaults to + /// <tt>std::cout</tt>. + template<typename Expr> + void display_expr(Expr const &expr, std::ostream &sout) + { + functional::display_expr(sout, 0)(expr); + } + + /// \overload + /// + template<typename Expr> + void display_expr(Expr const &expr) + { + functional::display_expr()(expr); + } + + /// \brief Assert at compile time that a particular expression + /// matches the specified grammar. + /// + /// \note Equivalent to <tt>BOOST_MPL_ASSERT((proto::matches\<Expr, Grammar\>))</tt> + /// \param expr The Proto expression to check againts <tt>Grammar</tt> + template<typename Grammar, typename Expr> + void assert_matches(Expr const & /*expr*/) + { + BOOST_MPL_ASSERT((proto::matches<Expr, Grammar>)); + } + + /// \brief Assert at compile time that a particular expression + /// does not match the specified grammar. + /// + /// \note Equivalent to <tt>BOOST_MPL_ASSERT_NOT((proto::matches\<Expr, Grammar\>))</tt> + /// \param expr The Proto expression to check againts <tt>Grammar</tt> + template<typename Grammar, typename Expr> + void assert_matches_not(Expr const & /*expr*/) + { + BOOST_MPL_ASSERT_NOT((proto::matches<Expr, Grammar>)); + } + + /// \brief Assert at compile time that a particular expression + /// matches the specified grammar. + /// + /// \note Equivalent to <tt>proto::assert_matches\<Grammar\>(Expr)</tt> + /// \param Expr The Proto expression to check againts <tt>Grammar</tt> + /// \param Grammar The grammar used to validate Expr. + #define BOOST_PROTO_ASSERT_MATCHES(Expr, Grammar) \ + (true ? (void)0 : boost::proto::assert_matches<Grammar>(Expr)) + + /// \brief Assert at compile time that a particular expression + /// does not match the specified grammar. + /// + /// \note Equivalent to <tt>proto::assert_matches_not\<Grammar\>(Expr)</tt> + /// \param Expr The Proto expression to check againts <tt>Grammar</tt> + /// \param Grammar The grammar used to validate Expr. + #define BOOST_PROTO_ASSERT_MATCHES_NOT(Expr, Grammar) \ + (true ? (void)0 : boost::proto::assert_matches_not<Grammar>(Expr)) + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/deep_copy.hpp b/3rdParty/Boost/src/boost/proto/deep_copy.hpp new file mode 100644 index 0000000..35107eb --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/deep_copy.hpp @@ -0,0 +1,163 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file deep_copy.hpp +/// Replace all nodes stored by reference by nodes stored by value. +// +// 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_DEEP_COPY_HPP_EAN_11_21_2006 +#define BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/args.hpp> +#include <boost/proto/expr.hpp> + +namespace boost { namespace proto +{ + namespace detail + { + template<typename Expr, long Arity = Expr::proto_arity_c> + struct deep_copy_impl; + + template<typename Expr> + struct deep_copy_impl<Expr, 0> + { + typedef + typename base_expr< + typename Expr::proto_domain + , tag::terminal + , term<typename term_traits<typename Expr::proto_child0>::value_type> + >::type + expr_type; + + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + return proto_generator()(expr_type::make(e.proto_base().child0)); + } + }; + } + + namespace result_of + { + /// \brief A metafunction for calculating the return type + /// of \c proto::deep_copy(). + /// + /// A metafunction for calculating the return type + /// of \c proto::deep_copy(). The type parameter \c Expr + /// should be the type of a Proto expression tree. + /// It should not be a reference type, nor should it + /// be cv-qualified. + template<typename Expr> + struct deep_copy + { + typedef + typename detail::deep_copy_impl< + BOOST_PROTO_UNCVREF(Expr) + >::result_type + type; + }; + } + + namespace functional + { + /// \brief A PolymorphicFunctionObject type for deep-copying + /// Proto expression trees. + /// + /// A PolymorphicFunctionObject type for deep-copying + /// Proto expression trees. When a tree is deep-copied, + /// all internal nodes and most terminals held by reference + /// are instead held by value. + /// + /// \attention Terminals of reference-to-function type are + /// left unchanged. Terminals of reference-to-array type are + /// stored by value, which can cause a large amount of data + /// to be passed by value and stored on the stack. + struct deep_copy + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef + typename detail::deep_copy_impl< + BOOST_PROTO_UNCVREF(Expr) + >::result_type + type; + }; + + /// \brief Deep-copies a Proto expression tree, turning all + /// nodes and terminals held by reference into ones held by + /// value. + template<typename Expr> + typename result_of::deep_copy<Expr>::type + operator()(Expr const &e) const + { + return proto::detail::deep_copy_impl<Expr>()(e, 0, 0); + } + }; + } + + /// \brief A function for deep-copying + /// Proto expression trees. + /// + /// A function for deep-copying + /// Proto expression trees. When a tree is deep-copied, + /// all internal nodes and most terminals held by reference + /// are instead held by value. + /// + /// \attention Terminals of reference-to-function type are + /// left unchanged. + /// + /// \sa proto::functional::deep_copy. + template<typename Expr> + typename proto::result_of::deep_copy<Expr>::type + deep_copy(Expr const &e) + { + return proto::detail::deep_copy_impl<Expr>()(e, 0, 0); + } + + /// \brief A PrimitiveTransform for deep-copying + /// Proto expression trees. + /// + /// A PrimitiveTransform for deep-copying + /// Proto expression trees. When a tree is deep-copied, + /// all internal nodes and most terminals held by reference + /// are instead held by value. + /// + /// \attention Terminals of reference-to-function type are + /// left unchanged. + /// + /// \sa proto::functional::deep_copy. + struct _deep_copy + : proto::transform<_deep_copy> + { + template<typename E, typename S, typename D> + struct impl + : detail::deep_copy_impl<BOOST_PROTO_UNCVREF(E)> + {}; + }; + + namespace detail + { + // include the definition of deep_copy_impl + #include <boost/proto/detail/deep_copy.hpp> + } + +}} + +#endif // BOOST_PROTO_COMPILER_DEEP_COPY_HPP_EAN_11_21_2006 + diff --git a/3rdParty/Boost/src/boost/proto/detail/and_n.hpp b/3rdParty/Boost/src/boost/proto/detail/and_n.hpp new file mode 100644 index 0000000..a046f49 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/and_n.hpp @@ -0,0 +1,94 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/and_n.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/and_n.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file and_n.hpp + /// Definitions of and_N, and_impl + // + // 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, (2, BOOST_PP_MAX(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_MAX_LOGICAL_ARITY), <boost/proto/detail/and_n.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + // Assymetry here between the handling of and_N and or_N because + // and_N is used by lambda_matches up to BOOST_PROTO_MAX_ARITY, + // regardless of how low BOOST_PROTO_MAX_LOGICAL_ARITY is. + template<bool B, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)> + struct BOOST_PP_CAT(and_, N) + #if 2 == N + : mpl::bool_<P0::value> + {}; + #else + : BOOST_PP_CAT(and_, BOOST_PP_DEC(N))< + P0::value BOOST_PP_COMMA_IF(BOOST_PP_SUB(N,2)) + BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_DEC(N), P) + > + {}; + #endif + + template<BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)> + struct BOOST_PP_CAT(and_, N)<false, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), P)> + : mpl::false_ + {}; + + #if N <= BOOST_PROTO_MAX_LOGICAL_ARITY + + template<BOOST_PP_ENUM_PARAMS(N, typename G), typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<BOOST_PP_ENUM_PARAMS(N, G)>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + #define M0(Z, N, DATA) \ + typedef \ + typename proto::when<proto::_, BOOST_PP_CAT(G, N)> \ + ::template impl<Expr, State, Data> \ + BOOST_PP_CAT(Gimpl, N); \ + /**/ + BOOST_PP_REPEAT(N, M0, ~) + #undef M0 + + typedef typename BOOST_PP_CAT(Gimpl, BOOST_PP_DEC(N))::result_type result_type; + + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + // Fix: jfalcou - 12/29/2010 + // Avoid the use of comma operator here so as not to find Proto's + // by accident. + // expands to G0()(e,s,d); G1()(e,s,d); ... G{N-1}()(e,s,d); + #define M0(Z,N,DATA) BOOST_PP_CAT(Gimpl,N)()(e,s,d); + BOOST_PP_REPEAT(BOOST_PP_DEC(N),M0,~) + return BOOST_PP_CAT(Gimpl,BOOST_PP_DEC(N))()(e,s,d); + #undef M0 + } + }; + + #endif + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/any.hpp b/3rdParty/Boost/src/boost/proto/detail/any.hpp new file mode 100644 index 0000000..ae47b1c --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/any.hpp @@ -0,0 +1,85 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file any.hpp +/// Contains definition the detail::any type +// +// Copyright 2012 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_DETAIL_ANY_HPP_EAN_18_07_2012 +#define BOOST_PROTO_DETAIL_ANY_HPP_EAN_18_07_2012 + +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto +{ + namespace detail + { + namespace anyns + { + //////////////////////////////////////////////////////////////////////////////////////////// + struct any + { + template<typename T> any(T const &) {} + any operator=(any); + any operator[](any); + #define M0(Z, N, DATA) any operator()(BOOST_PP_ENUM_PARAMS_Z(Z, N, any BOOST_PP_INTERCEPT)); + BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, M0, ~) + #undef M0 + + template<typename T> + operator T &() const volatile; + + any operator+(); + any operator-(); + any operator*(); + any operator&(); + any operator~(); + any operator!(); + any operator++(); + any operator--(); + any operator++(int); + any operator--(int); + + friend any operator<<(any, any); + friend any operator>>(any, any); + friend any operator*(any, any); + friend any operator/(any, any); + friend any operator%(any, any); + friend any operator+(any, any); + friend any operator-(any, any); + friend any operator<(any, any); + friend any operator>(any, any); + friend any operator<=(any, any); + friend any operator>=(any, any); + friend any operator==(any, any); + friend any operator!=(any, any); + friend any operator||(any, any); + friend any operator&&(any, any); + friend any operator&(any, any); + friend any operator|(any, any); + friend any operator^(any, any); + friend any operator,(any, any); + friend any operator->*(any, any); + + friend any operator<<=(any, any); + friend any operator>>=(any, any); + friend any operator*=(any, any); + friend any operator/=(any, any); + friend any operator%=(any, any); + friend any operator+=(any, any); + friend any operator-=(any, any); + friend any operator&=(any, any); + friend any operator|=(any, any); + friend any operator^=(any, any); + }; + } + + using anyns::any; + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/args.hpp b/3rdParty/Boost/src/boost/proto/detail/args.hpp new file mode 100644 index 0000000..83cdf4d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/args.hpp @@ -0,0 +1,85 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/args.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_DEFINE_CHILD_N(Z, N, DATA) \ + typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(child, N); \ + /**< INTERNAL ONLY */ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_DEFINE_VOID_N(z, n, data) \ + typedef mpl::void_ BOOST_PP_CAT(child, n); \ + /**< INTERNAL ONLY */ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/args.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file args.hpp + /// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ... + /// class templates. + // + // 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 + + /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template. + /// + /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template. + /// The types in the sequence correspond to the children of a node in an expression tree. + template< typename Arg0 > + struct term + { + static const long arity = 0; + typedef Arg0 child0; + BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~) + + /// INTERNAL ONLY + /// + typedef Arg0 back_; + }; + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/args.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_DEFINE_VOID_N + #undef BOOST_PROTO_DEFINE_CHILD_N + +#else + + #define N BOOST_PP_ITERATION() + + /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template. + /// + /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template. + /// The types in the sequence correspond to the children of a node in an expression tree. + template< BOOST_PP_ENUM_PARAMS(N, typename Arg) > + struct BOOST_PP_CAT(list, N) + { + static const long arity = N; + BOOST_PP_REPEAT(N, BOOST_PROTO_DEFINE_CHILD_N, ~) + BOOST_PP_REPEAT_FROM_TO(N, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~) + + /// INTERNAL ONLY + /// + typedef BOOST_PP_CAT(Arg, BOOST_PP_DEC(N)) back_; + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/as_expr.hpp b/3rdParty/Boost/src/boost/proto/detail/as_expr.hpp new file mode 100644 index 0000000..fb46576 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/as_expr.hpp @@ -0,0 +1,187 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file as_expr.hpp +/// Contains definition of the as_expr\<\> and as_child\<\> helper class +/// templates used to implement proto::domain's as_expr\<\> and as_child\<\> +/// member templates. +// +// Copyright 2010 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_DETAIL_AS_EXPR_HPP_EAN_06_09_2010 +#define BOOST_PROTO_DETAIL_AS_EXPR_HPP_EAN_06_09_2010 + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/args.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto { namespace detail +{ + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename Generator> + struct base_generator + { + typedef Generator type; + }; + + template<typename Generator> + struct base_generator<use_basic_expr<Generator> > + { + typedef Generator type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T, typename Generator, bool WantsBasicExpr> + struct as_expr; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T, typename Generator> + struct as_expr<T, Generator, false> + { + typedef typename term_traits<T &>::value_type value_type; + typedef proto::expr<proto::tag::terminal, term<value_type>, 0> expr_type; + typedef typename Generator::template result<Generator(expr_type)>::type result_type; + + BOOST_FORCEINLINE + result_type operator()(T &t) const + { + return Generator()(expr_type::make(t)); + } + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T, typename Generator> + struct as_expr<T, Generator, true> + { + typedef typename term_traits<T &>::value_type value_type; + typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> expr_type; + typedef typename Generator::template result<Generator(expr_type)>::type result_type; + + BOOST_FORCEINLINE + result_type operator()(T &t) const + { + return Generator()(expr_type::make(t)); + } + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct as_expr<T, proto::default_generator, false> + { + typedef typename term_traits<T &>::value_type value_type; + typedef proto::expr<proto::tag::terminal, term<value_type>, 0> result_type; + + BOOST_FORCEINLINE + result_type operator()(T &t) const + { + return result_type::make(t); + } + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct as_expr<T, proto::default_generator, true> + { + typedef typename term_traits<T &>::value_type value_type; + typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> result_type; + + BOOST_FORCEINLINE + result_type operator()(T &t) const + { + return result_type::make(t); + } + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T, typename Generator, bool WantsBasicExpr> + struct as_child; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T, typename Generator> + struct as_child<T, Generator, false> + { + #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + typedef typename term_traits<T &>::reference reference; + #else + typedef T &reference; + #endif + typedef proto::expr<proto::tag::terminal, term<reference>, 0> expr_type; + typedef typename Generator::template result<Generator(expr_type)>::type result_type; + + BOOST_FORCEINLINE + result_type operator()(T &t) const + { + return Generator()(expr_type::make(t)); + } + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T, typename Generator> + struct as_child<T, Generator, true> + { + #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + typedef typename term_traits<T &>::reference reference; + #else + typedef T &reference; + #endif + typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> expr_type; + typedef typename Generator::template result<Generator(expr_type)>::type result_type; + + BOOST_FORCEINLINE + result_type operator()(T &t) const + { + return Generator()(expr_type::make(t)); + } + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct as_child<T, proto::default_generator, false> + { + #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + typedef typename term_traits<T &>::reference reference; + #else + typedef T &reference; + #endif + typedef proto::expr<proto::tag::terminal, term<reference>, 0> result_type; + + BOOST_FORCEINLINE + result_type operator()(T &t) const + { + return result_type::make(t); + } + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct as_child<T, proto::default_generator, true> + { + #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + typedef typename term_traits<T &>::reference reference; + #else + typedef T &reference; + #endif + typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> result_type; + + BOOST_FORCEINLINE + result_type operator()(T &t) const + { + return result_type::make(t); + } + }; + +}}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/as_lvalue.hpp b/3rdParty/Boost/src/boost/proto/detail/as_lvalue.hpp new file mode 100644 index 0000000..8ff9091 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/as_lvalue.hpp @@ -0,0 +1,43 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file as_lvalue.hpp +/// Contains definition the as_lvalue() functions. +// +// 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_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007 +#define BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007 + +#include <boost/proto/proto_fwd.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template<typename T> + BOOST_FORCEINLINE + T &as_lvalue(T &t) + { + return t; + } + + template<typename T> + BOOST_FORCEINLINE + T const &as_lvalue(T const &t) + { + return t; + } + } +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/basic_expr.hpp b/3rdParty/Boost/src/boost/proto/detail/basic_expr.hpp new file mode 100644 index 0000000..51c4d95 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/basic_expr.hpp @@ -0,0 +1,185 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/basic_expr.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_CHILD(Z, N, DATA) \ + typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N); \ + BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N); \ + /**< INTERNAL ONLY */ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_VOID(Z, N, DATA) \ + typedef void BOOST_PP_CAT(proto_child, N); \ + /**< INTERNAL ONLY */ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/basic_expr.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file basic_expr.hpp + /// Contains definition of basic_expr\<\> 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 + + // The expr<> specializations are actually defined here. + #define BOOST_PROTO_DEFINE_TERMINAL + #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/basic_expr.hpp>)) + #include BOOST_PP_ITERATE() + + #undef BOOST_PROTO_DEFINE_TERMINAL + #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/basic_expr.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_CHILD + #undef BOOST_PROTO_VOID + +#else + + #define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION()) + + /// \brief Simplified representation of a node in an expression tree. + /// + /// \c proto::basic_expr\<\> is a node in an expression template tree. It + /// is a container for its child sub-trees. It also serves as + /// the terminal nodes of the tree. + /// + /// \c Tag is type that represents the operation encoded by + /// this expression. It is typically one of the structs + /// in the \c boost::proto::tag namespace, but it doesn't + /// have to be. + /// + /// \c Args is a type list representing the type of the children + /// of this expression. It is an instantiation of one + /// of \c proto::list1\<\>, \c proto::list2\<\>, etc. The + /// child types must all themselves be either \c expr\<\> + /// or <tt>proto::expr\<\>&</tt>. If \c Args is an + /// instantiation of \c proto::term\<\> then this + /// \c expr\<\> type represents a terminal expression; + /// the parameter to the \c proto::term\<\> template + /// represents the terminal's value type. + /// + /// \c Arity is an integral constant representing the number of child + /// nodes this node contains. If \c Arity is 0, then this + /// node is a terminal. + /// + /// \c proto::basic_expr\<\> is a valid Fusion random-access sequence, where + /// the elements of the sequence are the child expressions. + #ifdef BOOST_PROTO_DEFINE_TERMINAL + template<typename Tag, typename Arg0> + struct basic_expr<Tag, term<Arg0>, 0> + #else + template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)> + struct basic_expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() > + #endif + { + typedef Tag proto_tag; + static const long proto_arity_c = BOOST_PP_ITERATION(); + typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity; + typedef basic_expr proto_base_expr; + #ifdef BOOST_PROTO_DEFINE_TERMINAL + typedef term<Arg0> proto_args; + #else + typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args; + #endif + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; /**< INTERNAL ONLY */ + + BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD, ~) + BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~) + + /// \return *this + /// + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + /// \overload + /// + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + #ifdef BOOST_PROTO_DEFINE_TERMINAL + /// \return A new \c expr\<\> object initialized with the specified + /// arguments. + /// + template<typename A0> + BOOST_FORCEINLINE + static basic_expr const make(A0 &a0) + { + return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0)); + } + + /// \overload + /// + template<typename A0> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0) + { + return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0)); + } + #else + /// \return A new \c expr\<\> object initialized with the specified + /// arguments. + /// + template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)> + BOOST_FORCEINLINE + static basic_expr const make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const &a)) + { + basic_expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)}; + return that; + } + #endif + + #if 1 == BOOST_PP_ITERATION() + /// If \c Tag is \c boost::proto::tag::address_of and \c proto_child0 is + /// <tt>T&</tt>, then \c address_of_hack_type_ is <tt>T*</tt>. + /// Otherwise, it is some undefined type. + typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; + + /// \return The address of <tt>this->child0</tt> if \c Tag is + /// \c boost::proto::tag::address_of. Otherwise, this function will + /// fail to compile. + /// + /// \attention Proto overloads <tt>operator&</tt>, which means that + /// proto-ified objects cannot have their addresses taken, unless we use + /// the following hack to make \c &x implicitly convertible to \c X*. + BOOST_FORCEINLINE + operator address_of_hack_type_() const + { + return boost::addressof(this->child0); + } + #else + /// INTERNAL ONLY + /// + typedef detail::not_a_valid_type address_of_hack_type_; + #endif + }; + +#undef ARG_COUNT + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/class_member_traits.hpp b/3rdParty/Boost/src/boost/proto/detail/class_member_traits.hpp new file mode 100644 index 0000000..98d8ebb --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/class_member_traits.hpp @@ -0,0 +1,51 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/class_member_traits.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/class_member_traits.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + // class_member_traits.hpp + // Contains specializations of the class_member_traits\<\> 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, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/class_member_traits.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + #define N BOOST_PP_ITERATION() + + template<typename T, typename U BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct class_member_traits<T (U::*)(BOOST_PP_ENUM_PARAMS(N, A))> + { + typedef U class_type; + typedef T result_type; + }; + + template<typename T, typename U BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct class_member_traits<T (U::*)(BOOST_PP_ENUM_PARAMS(N, A)) const> + { + typedef U class_type; + typedef T result_type; + }; + + #undef N + +#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES diff --git a/3rdParty/Boost/src/boost/proto/detail/decltype.hpp b/3rdParty/Boost/src/boost/proto/detail/decltype.hpp new file mode 100644 index 0000000..629ef99 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/decltype.hpp @@ -0,0 +1,453 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file decltype.hpp +/// Contains definition the BOOST_PROTO_DECLTYPE_() macro and assorted helpers +// +// 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_DETAIL_DECLTYPE_HPP_EAN_04_04_2008 +#define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008 + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/get_pointer.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/preprocessor/iteration/local.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_class.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/type_traits/is_pointer.hpp> +#include <boost/type_traits/is_function.hpp> +#include <boost/type_traits/is_member_object_pointer.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_reference.hpp> +#include <boost/typeof/typeof.hpp> +#include <boost/utility/addressof.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/detail/any.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +// We're STILL using Boost.Typeof on MSVC even for msvc-11.0 because of this bug: +// https://connect.microsoft.com/VisualStudio/feedback/details/765392/decltype-of-a-pointer-to-member-operator-gets-ref-qualification-wrong +#if !defined(BOOST_NO_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700)) +# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype((EXPR)) TYPE; +#else +# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \ + BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR) \ + static int const BOOST_PP_CAT(sz, NESTED) = sizeof(boost::proto::detail::check_reference(EXPR));\ + struct NESTED \ + : boost::mpl::if_c< \ + 1 == BOOST_PP_CAT(sz, NESTED) \ + , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type & \ + , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type \ + > \ + {}; +# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \ + BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR)) \ + typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE; +#endif + +namespace boost { namespace proto +{ + namespace detail + { + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct as_mutable + { + typedef T &type; + }; + + template<typename T> + struct as_mutable<T &> + { + typedef T &type; + }; + + template<typename T> + struct as_mutable<T const &> + { + typedef T &type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + T make(); + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + typename as_mutable<T>::type make_mutable(); + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct subscript_wrapper + : T + { + using T::operator[]; + + #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) + any operator[](any const volatile &) const volatile; + #else + any operator[](any const &) const volatile; + #endif + }; + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct as_subscriptable + { + typedef + typename mpl::if_c< + is_class<T>::value + , subscript_wrapper<T> + , T + >::type + type; + }; + + template<typename T> + struct as_subscriptable<T const> + { + typedef + typename mpl::if_c< + is_class<T>::value + , subscript_wrapper<T> const + , T const + >::type + type; + }; + + template<typename T> + struct as_subscriptable<T &> + { + typedef + typename mpl::if_c< + is_class<T>::value + , subscript_wrapper<T> & + , T & + >::type + type; + }; + + template<typename T> + struct as_subscriptable<T const &> + { + typedef + typename mpl::if_c< + is_class<T>::value + , subscript_wrapper<T> const & + , T const & + >::type + type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + typename as_subscriptable<T>::type make_subscriptable(); + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + char check_reference(T &); + + template<typename T> + char (&check_reference(T const &))[2]; + + namespace has_get_pointerns + { + using boost::get_pointer; + void *(&get_pointer(...))[2]; + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct has_get_pointer + { + static const bool value = sizeof(void *) == sizeof(get_pointer(make<T &>())); + typedef mpl::bool_<value> type; + }; + } + + using has_get_pointerns::has_get_pointer; + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct class_member_traits; + + template<typename T, typename U> + struct class_member_traits<T U::*> + { + typedef U class_type; + typedef T result_type; + }; + + // Other specializations are generated by the preprocessor + #include <boost/proto/detail/class_member_traits.hpp> + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + T &lvalue(T &t) + { + return t; + } + + template<typename T> + T const &lvalue(T const &t) + { + return t; + } + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename U, typename V, typename T> + U *proto_get_pointer(T &t, V *, U *) + { + return boost::addressof(t); + } + + template<typename U, typename V, typename T> + U const *proto_get_pointer(T &t, V *, U const *) + { + return boost::addressof(t); + } + + template<typename U, typename V, typename T> + V *proto_get_pointer(T &t, V *, ...) + { + return get_pointer(t); + } + + //////////////////////////////////////////////////////////////////////////////////////////// + #define BOOST_PROTO_USE_GET_POINTER() \ + using namespace boost::proto::detail::get_pointerns \ + /**/ + + #define BOOST_PROTO_GET_POINTER(Type, Obj) \ + boost::proto::detail::proto_get_pointer<Type>( \ + boost::proto::detail::lvalue(Obj) \ + , (true ? 0 : get_pointer(Obj)) \ + , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(Obj))) \ + ) \ + /**/ + + //////////////////////////////////////////////////////////////////////////////////////////// + namespace get_pointerns + { + using boost::get_pointer; + + template<typename T> + typename disable_if_c<has_get_pointer<T>::value, T *>::type + get_pointer(T &t) + { + return boost::addressof(t); + } + + template<typename T> + typename disable_if_c<has_get_pointer<T>::value, T const *>::type + get_pointer(T const &t) + { + return boost::addressof(t); + } + + char test_ptr_to_const(void *); + char (&test_ptr_to_const(void const *))[2]; + + template<typename U> char test_V_is_a_U(U *); + template<typename U> char test_V_is_a_U(U const *); + template<typename U> char (&test_V_is_a_U(...))[2]; + + //////////////////////////////////////////////////////////////////////////////////////////// + // result_of_ is a wrapper around boost::result_of that also handles "invocations" of + // member object pointers. + template<typename T, typename Void = void> + struct result_of_ + : BOOST_PROTO_RESULT_OF<T> + {}; + + template<typename T, typename U, typename V> + struct result_of_<T U::*(V), typename enable_if_c<is_member_object_pointer<T U::*>::value>::type> + { + static const bool is_V_a_smart_ptr = 2 == sizeof(test_V_is_a_U<U>(&lvalue(make<V>()))); + static const bool is_ptr_to_const = 2 == sizeof(test_ptr_to_const(BOOST_PROTO_GET_POINTER(U, make<V>()))); + + // If V is not a U, then it is a (smart) pointer and we can always return an lvalue. + // Otherwise, we can only return an lvalue if we are given one. + typedef + typename mpl::eval_if_c< + (is_V_a_smart_ptr || is_reference<V>::value) + , mpl::eval_if_c< + is_ptr_to_const + , add_reference<typename add_const<T>::type> + , add_reference<T> + > + , mpl::identity<T> + >::type + type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////// + template< + typename T + , typename U + , bool IsMemPtr = is_member_object_pointer< + typename remove_reference<U>::type + >::value + > + struct mem_ptr_fun + { + BOOST_PROTO_DECLTYPE_( + proto::detail::make_mutable<T>() ->* proto::detail::make<U>() + , result_type + ) + + result_type operator()( + typename add_reference<typename add_const<T>::type>::type t + , typename add_reference<typename add_const<U>::type>::type u + ) const + { + return t ->* u; + } + }; + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename T, typename U> + struct mem_ptr_fun<T, U, true> + { + typedef + typename class_member_traits< + typename uncvref<U>::type + >::class_type + V; + + BOOST_PROTO_DECLTYPE_( + BOOST_PROTO_GET_POINTER(V, proto::detail::make_mutable<T>()) ->* proto::detail::make<U>() + , result_type + ) + + result_type operator()( + typename add_reference<typename add_const<T>::type>::type t + , U u + ) const + { + return BOOST_PROTO_GET_POINTER(V, t) ->* u; + } + }; + } + + using get_pointerns::result_of_; + using get_pointerns::mem_ptr_fun; + + //////////////////////////////////////////////////////////////////////////////////////////// + template<typename A0, typename A1> + struct comma_result + { + BOOST_PROTO_DECLTYPE_((proto::detail::make<A0>(), proto::detail::make<A1>()), type) + }; + + template<typename A0> + struct comma_result<A0, void> + { + typedef void type; + }; + + template<typename A1> + struct comma_result<void, A1> + { + typedef A1 type; + }; + + template<> + struct comma_result<void, void> + { + typedef void type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////// + // normalize a function type for use with boost::result_of + template<typename T, typename U = T> + struct result_of_fixup + : mpl::if_c<is_function<T>::value, T *, U> + {}; + + template<typename T, typename U> + struct result_of_fixup<T &, U> + : result_of_fixup<T, T> + {}; + + template<typename T, typename U> + struct result_of_fixup<T const &, U> + : result_of_fixup<T, T> + {}; + + template<typename T, typename U> + struct result_of_fixup<T *, U> + : result_of_fixup<T, U> + {}; + + template<typename R, typename T, typename U> + struct result_of_fixup<R T::*, U> + { + typedef R T::*type; + }; + + template<typename T, typename U> + struct result_of_fixup<T const, U> + : result_of_fixup<T, U> + {}; + + //// Tests for result_of_fixup + //struct bar {}; + //BOOST_MPL_ASSERT((is_same<bar, result_of_fixup<bar>::type>)); + //BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const>::type>)); + //BOOST_MPL_ASSERT((is_same<bar, result_of_fixup<bar &>::type>)); + //BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const &>::type>)); + //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(*)()>::type>)); + //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(* const)()>::type>)); + //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(* const &)()>::type>)); + //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(&)()>::type>)); + + template<typename T, typename PMF> + struct memfun + { + typedef typename uncvref<PMF>::type pmf_type; + typedef typename class_member_traits<pmf_type>::class_type V; + typedef typename class_member_traits<pmf_type>::result_type result_type; + + memfun(T t, pmf_type p) + : obj(t) + , pmf(p) + {} + + result_type operator()() const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(); + } + + // Other overloads generated by the preprocessor + #include <boost/proto/detail/memfun_funop.hpp> + + private: + T obj; + pmf_type pmf; + }; + + } // namespace detail +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/deduce_domain.hpp b/3rdParty/Boost/src/boost/proto/detail/deduce_domain.hpp new file mode 100644 index 0000000..630304f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/deduce_domain.hpp @@ -0,0 +1,200 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file deduce_domain.hpp +/// Contains definition of deduce_domain\<\> class templates +/// for finding the domain that is common among the specified +/// domains +// +// Copyright 2010 Daniel Wallin, 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) +// +// Many thanks to Daniel Wallin who first implemented this code. Thanks +// also to Jeremiah Willcock, John Bytheway and Krishna Achuthan who +// offered alternate solutions to this tricky programming problem. + +#ifndef BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 +#define BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 + +#include <boost/config.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/iteration/local.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/proto/proto_fwd.hpp> + +#ifndef BOOST_PROTO_ASSERT_VALID_DOMAIN +# define BOOST_PROTO_ASSERT_VALID_DOMAIN(DOM) BOOST_MPL_ASSERT_NOT((boost::is_same<DOM, boost::proto::detail::not_a_domain>)) +#endif + +namespace boost +{ + namespace proto + { + namespace detail + { + template<typename Domain> + struct domain_ + : domain_<typename Domain::proto_super_domain> + { + typedef Domain type; + typedef domain_<typename Domain::proto_super_domain> base; + #ifdef BOOST_NO_DECLTYPE + using base::deduce98; + static int const index = base::index + 1; + static typename sized_type<index>::type deduce98(domain_<Domain>*); + #else + using base::deduce0x; + static Domain deduce0x(domain_<Domain>*); + #endif + }; + + template<> + struct domain_<not_a_domain> + { + typedef not_a_domain type; + #ifdef BOOST_NO_DECLTYPE + static int const index = 1; + static sized_type<1>::type deduce98(void*); + #else + static not_a_domain deduce0x(void*); + #endif + }; + + template<> + struct domain_<default_domain> + : domain_<not_a_domain> + {}; + + template<> + struct domain_<basic_default_domain> + : domain_<not_a_domain> + {}; + + sized_type<1>::type default_test(void*, void*); + sized_type<2>::type default_test(domain_<default_domain>*, void*); + sized_type<2>::type default_test(domain_<basic_default_domain>*, void*); + sized_type<3>::type default_test(void*, domain_<default_domain>*); + sized_type<3>::type default_test(void*, domain_<basic_default_domain>*); + sized_type<4>::type default_test(domain_<default_domain>*, domain_<default_domain>*); + sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<default_domain>*); + sized_type<4>::type default_test(domain_<default_domain>*, domain_<basic_default_domain>*); + sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<basic_default_domain>*); + + #ifdef BOOST_NO_DECLTYPE + template<int N, typename Domain> + struct nth_domain + : nth_domain<N - 1, typename Domain::base> + {}; + + template<typename Domain> + struct nth_domain<0, Domain> + : Domain + {}; + #endif + + template<typename D0> + struct common_domain1 + { + typedef D0 type; + }; + + template<typename E0> + struct deduce_domain1 + : domain_of<E0> + {}; + + template< + typename D0 + , typename D1 + , int DefaultCase = sizeof(proto::detail::default_test((domain_<D0>*)0, (domain_<D1>*)0)) + > + struct common_domain2 + { + #ifdef BOOST_NO_DECLTYPE + static int const index = domain_<D0>::index - sizeof(domain_<D0>::deduce98((domain_<D1>*)0)); + typedef typename nth_domain<index, domain_<D0> >::type type; + #else + typedef decltype(domain_<D0>::deduce0x((domain_<D1>*)0)) type; + #endif + }; + + template<typename D0, typename D1> + struct common_domain2<D0, D1, 2> + { + typedef D1 type; + }; + + template<typename D0, typename D1> + struct common_domain2<D0, D1, 3> + { + typedef D0 type; + }; + + template<typename D0> + struct common_domain2<D0, default_domain, 4> + { + typedef D0 type; + }; + + template<typename D0> + struct common_domain2<D0, basic_default_domain, 4> + { + typedef D0 type; + }; + + template<typename D1> + struct common_domain2<default_domain, D1, 4> + { + typedef D1 type; + }; + + template<typename D1> + struct common_domain2<basic_default_domain, D1, 4> + { + typedef D1 type; + }; + + template<> + struct common_domain2<default_domain, default_domain, 4> + { + typedef default_domain type; + }; + + template<> + struct common_domain2<basic_default_domain, default_domain, 4> + { + typedef default_domain type; + }; + + template<> + struct common_domain2<default_domain, basic_default_domain, 4> + { + typedef default_domain type; + }; + + template<> + struct common_domain2<basic_default_domain, basic_default_domain, 4> + { + typedef basic_default_domain type; + }; + + template<typename E0, typename E1> + struct deduce_domain2 + : common_domain2< + typename domain_of<E0>::type + , typename domain_of<E1>::type + > + {}; + + #include <boost/proto/detail/deduce_domain_n.hpp> + } + } +} + +#endif // BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 diff --git a/3rdParty/Boost/src/boost/proto/detail/deduce_domain_n.hpp b/3rdParty/Boost/src/boost/proto/detail/deduce_domain_n.hpp new file mode 100644 index 0000000..25595fe --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/deduce_domain_n.hpp @@ -0,0 +1,64 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/deduce_domain_n.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_COMMON_DOMAIN2(Z, N, DATA) \ + typedef \ + typename common_domain2<common ## N, A ## N>::type \ + BOOST_PP_CAT(common, BOOST_PP_INC(N)); \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/deduce_domain_n.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + // deduce_domain_n.hpp + // Definitions of common_domain[n] and deduce_domain[n] class templates. + // + // 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/detail/deduce_domain_n.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_COMMON_DOMAIN2 + +#else + + #define N BOOST_PP_ITERATION() + + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + struct BOOST_PP_CAT(common_domain, N) + { + typedef A0 common1; + BOOST_PP_REPEAT_FROM_TO(1, N, BOOST_PROTO_COMMON_DOMAIN2, ~) + typedef BOOST_PP_CAT(common, N) type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + + template<BOOST_PP_ENUM_PARAMS(N, typename E)> + struct BOOST_PP_CAT(deduce_domain, N) + : BOOST_PP_CAT(common_domain, N)< + BOOST_PP_ENUM_BINARY_PARAMS( + N + , typename domain_of<E, >::type BOOST_PP_INTERCEPT + ) + > + {}; + + #undef N + +#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES diff --git a/3rdParty/Boost/src/boost/proto/detail/deep_copy.hpp b/3rdParty/Boost/src/boost/proto/detail/deep_copy.hpp new file mode 100644 index 0000000..2e2011b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/deep_copy.hpp @@ -0,0 +1,79 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/deep_copy.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_DEFINE_DEEP_COPY_TYPE(Z, N, DATA) \ + typename deep_copy_impl< \ + typename remove_reference< \ + typename Expr::BOOST_PP_CAT(proto_child, N) \ + >::type::proto_derived_expr \ + >::result_type \ + /**/ + + #define BOOST_PROTO_DEFINE_DEEP_COPY_FUN(Z, N, DATA) \ + proto::deep_copy(e.proto_base().BOOST_PP_CAT(child, N)) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/deep_copy.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file deep_copy.hpp + /// Replace all nodes stored by reference by nodes stored by value. + // + // 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/detail/deep_copy.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_DEFINE_DEEP_COPY_FUN + #undef BOOST_PROTO_DEFINE_DEEP_COPY_TYPE + +#else + + #define N BOOST_PP_ITERATION() + + template<typename Expr> + struct deep_copy_impl<Expr, N> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , BOOST_PP_CAT(list, N)< + BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_TYPE, ~) + > + >::type + expr_type; + + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_FUN, ~) + }; + + return proto_generator()(that); + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/deprecated.hpp b/3rdParty/Boost/src/boost/proto/detail/deprecated.hpp new file mode 100644 index 0000000..d8dec6d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/deprecated.hpp @@ -0,0 +1,247 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file deprecated.hpp +/// Definition of the deprecated BOOST_PROTO_DEFINE_FUCTION_TEMPLATE and +/// BOOST_PROTO_DEFINE_VARARG_FUCTION_TEMPLATE macros +// +// 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_DETAIL_DEPRECATED_HPP_EAN_11_25_2008 +#define BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/punctuation/comma_if.hpp> +#include <boost/preprocessor/control/if.hpp> +#include <boost/preprocessor/control/expr_if.hpp> +#include <boost/preprocessor/comparison/greater.hpp> +#include <boost/preprocessor/tuple/elem.hpp> +#include <boost/preprocessor/tuple/to_list.hpp> +#include <boost/preprocessor/logical/and.hpp> +#include <boost/preprocessor/seq/size.hpp> +#include <boost/preprocessor/seq/enum.hpp> +#include <boost/preprocessor/seq/seq.hpp> +#include <boost/preprocessor/seq/to_tuple.hpp> +#include <boost/preprocessor/seq/for_each_i.hpp> +#include <boost/preprocessor/seq/pop_back.hpp> +#include <boost/preprocessor/seq/push_back.hpp> +#include <boost/preprocessor/seq/push_front.hpp> +#include <boost/preprocessor/list/for_each_i.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> +#include <boost/proto/proto_fwd.hpp> + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_TEMPLATE_AUX_(R, DATA, I, ELEM) \ + (ELEM BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I))) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_TEMPLATE_YES_(R, DATA, I, ELEM) \ + BOOST_PP_LIST_FOR_EACH_I_R( \ + R \ + , BOOST_PROTO_VARARG_TEMPLATE_AUX_ \ + , I \ + , BOOST_PP_TUPLE_TO_LIST( \ + BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ + , BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM)) \ + ) \ + ) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_TEMPLATE_NO_(R, DATA, I, ELEM) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_TEMPLATE_(R, DATA, I, ELEM) \ + BOOST_PP_IF( \ + BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ + , BOOST_PROTO_VARARG_TEMPLATE_YES_ \ + , BOOST_PROTO_VARARG_TEMPLATE_NO_ \ + )(R, DATA, I, ELEM) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_TYPE_AUX_(R, DATA, I, ELEM) \ + (BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I))) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_TEMPLATE_PARAMS_YES_(R, DATA, I, ELEM) \ + < \ + BOOST_PP_SEQ_ENUM( \ + BOOST_PP_LIST_FOR_EACH_I_R( \ + R \ + , BOOST_PROTO_VARARG_TYPE_AUX_ \ + , I \ + , BOOST_PP_TUPLE_TO_LIST( \ + BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ + , BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM)) \ + ) \ + ) \ + ) \ + > \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_TEMPLATE_PARAMS_NO_(R, DATA, I, ELEM) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_TYPE_(R, DATA, I, ELEM) \ + BOOST_PP_COMMA_IF(I) \ + BOOST_PP_SEQ_HEAD(ELEM) \ + BOOST_PP_IF( \ + BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ + , BOOST_PROTO_TEMPLATE_PARAMS_YES_ \ + , BOOST_PROTO_TEMPLATE_PARAMS_NO_ \ + )(R, DATA, I, ELEM) BOOST_PP_EXPR_IF(BOOST_PP_GREATER(I, 1), const) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_AS_EXPR_(R, DATA, I, ELEM) \ + BOOST_PP_EXPR_IF( \ + BOOST_PP_GREATER(I, 1) \ + , (( \ + BOOST_PP_SEQ_HEAD(ELEM) \ + BOOST_PP_IF( \ + BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM)) \ + , BOOST_PROTO_TEMPLATE_PARAMS_YES_ \ + , BOOST_PROTO_TEMPLATE_PARAMS_NO_ \ + )(R, DATA, I, ELEM)() \ + )) \ + ) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_AS_CHILD_(Z, N, DATA) \ + (BOOST_PP_CAT(DATA, N)) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_SEQ_PUSH_FRONT(SEQ, ELEM) \ + BOOST_PP_SEQ_POP_BACK(BOOST_PP_SEQ_PUSH_FRONT(BOOST_PP_SEQ_PUSH_BACK(SEQ, _dummy_), ELEM)) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_AS_PARAM_(Z, N, DATA) \ + (BOOST_PP_CAT(DATA, N)) \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_VARARG_FUN_(Z, N, DATA) \ + template< \ + BOOST_PP_SEQ_ENUM( \ + BOOST_PP_SEQ_FOR_EACH_I( \ + BOOST_PROTO_VARARG_TEMPLATE_, ~ \ + , BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PROTO_SEQ_PUSH_FRONT( \ + BOOST_PP_TUPLE_ELEM(4, 2, DATA) \ + , (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \ + ) \ + , BOOST_PP_TUPLE_ELEM(4, 1, DATA) \ + ) \ + ) \ + BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_PARAM_, typename A) \ + ) \ + > \ + typename boost::proto::result_of::make_expr< \ + BOOST_PP_SEQ_FOR_EACH_I( \ + BOOST_PROTO_VARARG_TYPE_, ~ \ + , BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PROTO_SEQ_PUSH_FRONT( \ + BOOST_PP_TUPLE_ELEM(4, 2, DATA) \ + , (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \ + ) \ + , BOOST_PP_TUPLE_ELEM(4, 1, DATA) \ + ) \ + ) \ + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \ + >::type const \ + BOOST_PP_TUPLE_ELEM(4, 0, DATA)(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) \ + { \ + return boost::proto::detail::make_expr_< \ + BOOST_PP_SEQ_FOR_EACH_I( \ + BOOST_PROTO_VARARG_TYPE_, ~ \ + , BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PROTO_SEQ_PUSH_FRONT( \ + BOOST_PP_TUPLE_ELEM(4, 2, DATA) \ + , (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \ + ) \ + , BOOST_PP_TUPLE_ELEM(4, 1, DATA) \ + ) \ + ) \ + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \ + >()( \ + BOOST_PP_SEQ_ENUM( \ + BOOST_PP_SEQ_FOR_EACH_I( \ + BOOST_PROTO_VARARG_AS_EXPR_, ~ \ + , BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PROTO_SEQ_PUSH_FRONT( \ + BOOST_PP_TUPLE_ELEM(4, 2, DATA) \ + , (BOOST_PP_TUPLE_ELEM(4, 3, DATA)) \ + ) \ + , BOOST_PP_TUPLE_ELEM(4, 1, DATA) \ + ) \ + ) \ + BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_CHILD_, a) \ + ) \ + ); \ + } \ + /**/ + +/// \code +/// BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE( +/// 1 +/// , construct +/// , boost::proto::default_domain +/// , (boost::proto::tag::function) +/// , ((op::construct)(typename)(int)) +/// ) +/// \endcode +#define BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(ARGCOUNT, NAME, DOMAIN, TAG, BOUNDARGS) \ + BOOST_PP_REPEAT_FROM_TO( \ + ARGCOUNT \ + , BOOST_PP_INC(ARGCOUNT) \ + , BOOST_PROTO_VARARG_FUN_ \ + , (NAME, TAG, BOUNDARGS, DOMAIN) \ + )\ + /**/ + +/// \code +/// BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE( +/// construct +/// , boost::proto::default_domain +/// , (boost::proto::tag::function) +/// , ((op::construct)(typename)(int)) +/// ) +/// \endcode +#define BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(NAME, DOMAIN, TAG, BOUNDARGS) \ + BOOST_PP_REPEAT( \ + BOOST_PP_SUB(BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), BOOST_PP_SEQ_SIZE(BOUNDARGS)) \ + , BOOST_PROTO_VARARG_FUN_ \ + , (NAME, TAG, BOUNDARGS, DOMAIN) \ + ) \ + /**/ + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/expr.hpp b/3rdParty/Boost/src/boost/proto/detail/expr.hpp new file mode 100644 index 0000000..3f3291b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/expr.hpp @@ -0,0 +1,474 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #ifndef BOOST_NO_VARIADIC_TEMPLATES + #include <boost/proto/detail/preprocessed/expr_variadic.hpp> + #else + #include <boost/proto/detail/preprocessed/expr.hpp> + #endif + +#elif !defined(BOOST_PP_IS_ITERATING) + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_CHILD(Z, N, DATA) \ + typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N); \ + BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N); \ + /**< INTERNAL ONLY */ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_VOID(Z, N, DATA) \ + typedef void BOOST_PP_CAT(proto_child, N); \ + /**< INTERNAL ONLY */ + + // Generate variadic versions of expr + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr_variadic.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file expr_variadic.hpp + /// Contains definition of expr\<\> 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 + + // The expr<> specializations are actually defined here. + #define BOOST_PROTO_DEFINE_TERMINAL + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (0, 0, <boost/proto/detail/expr.hpp>)) + #include BOOST_PP_ITERATE() + + #undef BOOST_PROTO_DEFINE_TERMINAL + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>)) + #include BOOST_PP_ITERATE() + + // Generate non-variadic versions of expr + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #define BOOST_NO_VARIADIC_TEMPLATES + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr.hpp") + + /////////////////////////////////////////////////////////////////////////////// + /// \file expr.hpp + /// Contains definition of expr\<\> 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) + + #pragma wave option(preserve: 1) + + // The expr<> specializations are actually defined here. + #define BOOST_PROTO_DEFINE_TERMINAL + #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/expr.hpp>)) + #include BOOST_PP_ITERATE() + + #undef BOOST_PROTO_DEFINE_TERMINAL + #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>)) + #include BOOST_PP_ITERATE() + + #pragma wave option(output: null) + #undef BOOST_NO_VARIADIC_TEMPLATES + #endif + + #undef BOOST_PROTO_CHILD + #undef BOOST_PROTO_VOID + +#else + + #define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION()) + + /// \brief Representation of a node in an expression tree. + /// + /// \c proto::expr\<\> is a node in an expression template tree. It + /// is a container for its child sub-trees. It also serves as + /// the terminal nodes of the tree. + /// + /// \c Tag is type that represents the operation encoded by + /// this expression. It is typically one of the structs + /// in the \c boost::proto::tag namespace, but it doesn't + /// have to be. + /// + /// \c Args is a type list representing the type of the children + /// of this expression. It is an instantiation of one + /// of \c proto::list1\<\>, \c proto::list2\<\>, etc. The + /// child types must all themselves be either \c expr\<\> + /// or <tt>proto::expr\<\>&</tt>. If \c Args is an + /// instantiation of \c proto::term\<\> then this + /// \c expr\<\> type represents a terminal expression; + /// the parameter to the \c proto::term\<\> template + /// represents the terminal's value type. + /// + /// \c Arity is an integral constant representing the number of child + /// nodes this node contains. If \c Arity is 0, then this + /// node is a terminal. + /// + /// \c proto::expr\<\> is a valid Fusion random-access sequence, where + /// the elements of the sequence are the child expressions. + #ifdef BOOST_PROTO_DEFINE_TERMINAL + template<typename Tag, typename Arg0> + struct expr<Tag, term<Arg0>, 0> + #else + template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)> + struct expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() > + #endif + { + typedef Tag proto_tag; + static const long proto_arity_c = BOOST_PP_ITERATION(); + typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity; + typedef expr proto_base_expr; + #ifdef BOOST_PROTO_DEFINE_TERMINAL + typedef term<Arg0> proto_args; + #else + typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args; + #endif + typedef basic_expr<Tag, proto_args, BOOST_PP_ITERATION() > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; /**< INTERNAL ONLY */ + + BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD, ~) + BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~) + + /// \return *this + /// + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + /// \overload + /// + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + #ifdef BOOST_PROTO_DEFINE_TERMINAL + /// \return A new \c expr\<\> object initialized with the specified + /// arguments. + /// + template<typename A0> + BOOST_FORCEINLINE + static expr const make(A0 &a0) + { + return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); + } + + /// \overload + /// + template<typename A0> + BOOST_FORCEINLINE + static expr const make(A0 const &a0) + { + return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); + } + #else + /// \return A new \c expr\<\> object initialized with the specified + /// arguments. + /// + template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)> + BOOST_FORCEINLINE + static expr const make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const &a)) + { + expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)}; + return that; + } + #endif + + #if 1 == BOOST_PP_ITERATION() + /// If \c Tag is \c boost::proto::tag::address_of and \c proto_child0 is + /// <tt>T&</tt>, then \c address_of_hack_type_ is <tt>T*</tt>. + /// Otherwise, it is some undefined type. + typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; + + /// \return The address of <tt>this->child0</tt> if \c Tag is + /// \c boost::proto::tag::address_of. Otherwise, this function will + /// fail to compile. + /// + /// \attention Proto overloads <tt>operator&</tt>, which means that + /// proto-ified objects cannot have their addresses taken, unless we use + /// the following hack to make \c &x implicitly convertible to \c X*. + BOOST_FORCEINLINE + operator address_of_hack_type_() const + { + return boost::addressof(this->child0); + } + #else + /// INTERNAL ONLY + /// + typedef detail::not_a_valid_type address_of_hack_type_; + #endif + + /// Assignment + /// + /// \param a The rhs. + /// \return A new \c expr\<\> node representing an assignment of \c that to \c *this. + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + /// Assignment + /// + /// \param a The rhs. + /// \return A new \c expr\<\> node representing an assignment of \c a to \c *this. + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + /// \overload + /// + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + #ifdef BOOST_PROTO_DEFINE_TERMINAL + /// \overload + /// + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + /// \overload + /// + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + #endif + + /// Subscript + /// + /// \param a The rhs. + /// \return A new \c expr\<\> node representing \c *this subscripted with \c a. + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + /// \overload + /// + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + #ifdef BOOST_PROTO_DEFINE_TERMINAL + /// \overload + /// + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) + { + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + /// \overload + /// + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) + { + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + #endif + + /// Encodes the return type of \c expr\<\>::operator(), for use with \c boost::result_of\<\> + /// + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + #ifndef BOOST_NO_VARIADIC_TEMPLATES + /// \overload + /// + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + + #ifdef BOOST_PROTO_DEFINE_TERMINAL + /// \overload + /// + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) + { + return result_of::funop< + expr(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + #endif + + #else // BOOST_NO_VARIADIC_TEMPLATES + + /// Function call + /// + /// \return A new \c expr\<\> node representing the function invocation of \c (*this)(). + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + #ifdef BOOST_PROTO_DEFINE_TERMINAL + /// \overload + /// + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr &>, 1> const + operator ()() + { + proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this}; + return that; + } + #endif + + #define BOOST_PP_ITERATION_PARAMS_2 \ + (3, (1, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/expr_funop.hpp>)) + #include BOOST_PP_ITERATE() + +#endif + }; + +#undef ARG_COUNT + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/expr_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/expr_funop.hpp new file mode 100644 index 0000000..b801fdd --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/expr_funop.hpp @@ -0,0 +1,45 @@ +/////////////////////////////////////////////////////////////////////////////// +// expr1.hpp +// Contains definition of expr\<\>::operator() overloads. +// +// 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) + +#define N BOOST_PP_ITERATION() + + /// \overload + /// + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + BOOST_FORCEINLINE + typename result_of::BOOST_PP_CAT(funop, N)< + expr const + , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) + >::type const + operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const + { + return result_of::BOOST_PP_CAT(funop, N)< + expr const + , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) + >::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a)); + } + + #ifdef BOOST_PROTO_DEFINE_TERMINAL + /// \overload + /// + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + BOOST_FORCEINLINE + typename result_of::BOOST_PP_CAT(funop, N)< + expr + , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) + >::type const + operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) + { + return result_of::BOOST_PP_CAT(funop, N)< + expr + , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) + >::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a)); + } + #endif + +#undef N diff --git a/3rdParty/Boost/src/boost/proto/detail/extends_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/extends_funop.hpp new file mode 100644 index 0000000..bb157c5 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/extends_funop.hpp @@ -0,0 +1,43 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #ifndef BOOST_NO_VARIADIC_TEMPLATES + BOOST_PROTO_EXTENDS_FUNCTION_() + BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) + BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) + #else + #include <boost/proto/detail/preprocessed/extends_funop.hpp> + #endif + +#else + + #define BOOST_PP_LOCAL_MACRO(N) \ + BOOST_PROTO_DEFINE_FUN_OP(1, N, ~) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file extends_funop.hpp + /// Definitions for extends\<\>::operator() + // + // 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) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT) + #pragma wave option(preserve: 1) + #endif + + BOOST_PROTO_EXTENDS_FUNCTION_() + + #define BOOST_PP_LOCAL_LIMITS \ + (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY)) + #include BOOST_PP_LOCAL_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT) + #pragma wave option(output: null) + #endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/extends_funop_const.hpp b/3rdParty/Boost/src/boost/proto/detail/extends_funop_const.hpp new file mode 100644 index 0000000..229a0f9 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/extends_funop_const.hpp @@ -0,0 +1,42 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #ifndef BOOST_NO_VARIADIC_TEMPLATES + BOOST_PROTO_EXTENDS_FUNCTION_() + BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) + #else + #include <boost/proto/detail/preprocessed/extends_funop_const.hpp> + #endif + +#else + + #define BOOST_PP_LOCAL_MACRO(N) \ + BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop_const.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file extends_funop_const.hpp + /// Definitions for extends\<\>::operator() + // + // 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 + + BOOST_PROTO_EXTENDS_FUNCTION_() + + #define BOOST_PP_LOCAL_LIMITS \ + (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY)) + #include BOOST_PP_LOCAL_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/funop.hpp b/3rdParty/Boost/src/boost/proto/detail/funop.hpp new file mode 100644 index 0000000..f447669 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/funop.hpp @@ -0,0 +1,87 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/funop.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA) \ + typename proto::result_of::as_child<BOOST_PP_CAT(A, N), Domain>::type \ + /**/ + + #define BOOST_PROTO_AS_CHILD(Z, N, DATA) \ + proto::as_child<Domain>(BOOST_PP_CAT(a, N)) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/funop.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + // funop.hpp + // Contains definition of funop[n]\<\> 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, (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/funop.hpp>)) + #include BOOST_PP_ITERATE() + + #undef BOOST_PROTO_AS_CHILD + #undef BOOST_PROTO_AS_CHILD_TYPE + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + /// \brief A helper metafunction for computing the + /// return type of \c proto::expr\<\>::operator(). + template<typename Expr, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A)> + struct BOOST_PP_CAT(funop, BOOST_PP_ITERATION()) + { + typedef typename proto::base_expr< + Domain + , tag::function + , BOOST_PP_CAT(list, BOOST_PP_INC(BOOST_PP_ITERATION()))< + Expr & + BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD_TYPE, ~) + > + >::type type; + + BOOST_FORCEINLINE + static type const call( + Expr &e + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a) + ) + { + type that = { + e + BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD, ~) + }; + return that; + } + }; + + /// \brief A helper metafunction for computing the + /// return type of \c proto::expr\<\>::operator(). + template<typename Expr BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A), typename This, typename Domain> + struct funop<Expr(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), This, Domain> + : BOOST_PP_CAT(funop, BOOST_PP_ITERATION())< + typename detail::same_cv<Expr, This>::type + , Domain + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( + BOOST_PP_ITERATION() + , typename remove_reference<A + , >::type BOOST_PP_INTERCEPT + ) + > + {}; + +#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES diff --git a/3rdParty/Boost/src/boost/proto/detail/generate_by_value.hpp b/3rdParty/Boost/src/boost/proto/detail/generate_by_value.hpp new file mode 100644 index 0000000..835642e --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/generate_by_value.hpp @@ -0,0 +1,93 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/generate_by_value.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/generate_by_value.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file generate_by_value.hpp + /// Contains definition of by_value_generator_\<\> 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/detail/generate_by_value.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) > + struct by_value_generator_< + proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>, N> + > + { + typedef + BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)> + src_args; + + typedef + BOOST_PP_CAT(list, N)< + BOOST_PP_ENUM_BINARY_PARAMS(N, typename uncvref<Arg, >::type BOOST_PP_INTERCEPT) + > + dst_args; + + typedef proto::expr<Tag, src_args, N> src_type; + typedef proto::expr<Tag, dst_args, N> type; + + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + BOOST_PP_ENUM_PARAMS(N, e.child) + }; + return that; + } + }; + + template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) > + struct by_value_generator_< + proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>, N> + > + { + typedef + BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)> + src_args; + + typedef + BOOST_PP_CAT(list, N)< + BOOST_PP_ENUM_BINARY_PARAMS(N, typename uncvref<Arg, >::type BOOST_PP_INTERCEPT) + > + dst_args; + + typedef proto::basic_expr<Tag, src_args, N> src_type; + typedef proto::basic_expr<Tag, dst_args, N> type; + + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + BOOST_PP_ENUM_PARAMS(N, e.child) + }; + return that; + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/ignore_unused.hpp b/3rdParty/Boost/src/boost/proto/detail/ignore_unused.hpp new file mode 100644 index 0000000..6004b83 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/ignore_unused.hpp @@ -0,0 +1,34 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file ignore_unused.hpp +/// Definintion of ignore_unused, a dummy function for suppressing compiler +/// warnings +// +// 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_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008 +#define BOOST_PROTO_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008 + +#include <boost/config.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template<typename T> + BOOST_FORCEINLINE void ignore_unused(T const &) + {} + } +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/is_noncopyable.hpp b/3rdParty/Boost/src/boost/proto/detail/is_noncopyable.hpp new file mode 100644 index 0000000..3e2da78 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/is_noncopyable.hpp @@ -0,0 +1,65 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file is_noncopyable.hpp +/// Utility for detecting when types are non-copyable +// +// 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_DETAIL_IS_NONCOPYABLE_HPP_EAN_19_07_2012 +#define BOOST_PROTO_DETAIL_IS_NONCOPYABLE_HPP_EAN_19_07_2012 + +#include <boost/noncopyable.hpp> +#include <boost/mpl/or.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/type_traits/is_base_of.hpp> +#include <boost/type_traits/is_abstract.hpp> +#include <boost/type_traits/is_function.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace detail +{ + // All classes derived from std::ios_base have these public nested types, + // and are non-copyable. This is an imperfect test, but it's the best we + // we can do. + template<typename T> + yes_type check_is_iostream( + typename T::failure * + , typename T::Init * + , typename T::fmtflags * + , typename T::iostate * + , typename T::openmode * + , typename T::seekdir * + ); + + template<typename T> + no_type check_is_iostream(...); + + template<typename T> + struct is_iostream + { + static bool const value = sizeof(yes_type) == sizeof(check_is_iostream<T>(0,0,0,0,0,0)); + typedef mpl::bool_<value> type; + }; + + /// INTERNAL ONLY + // This should be a customization point. And it serves the same purpose + // as the is_noncopyable trait in Boost.Foreach. + template<typename T> + struct is_noncopyable + : mpl::or_< + is_function<T> + , is_abstract<T> + , is_iostream<T> + , is_base_of<noncopyable, T> + > + {}; + + template<typename T, std::size_t N> + struct is_noncopyable<T[N]> + : mpl::true_ + {}; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/lambda_matches.hpp b/3rdParty/Boost/src/boost/proto/detail/lambda_matches.hpp new file mode 100644 index 0000000..9c4a992 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/lambda_matches.hpp @@ -0,0 +1,61 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/lambda_matches.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_DEFINE_LAMBDA_MATCHES(Z, N, DATA) \ + lambda_matches< \ + BOOST_PP_CAT(Expr, N) \ + , BOOST_PP_CAT(Grammar, N) \ + > + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/lambda_matches.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file lambda_matches.hpp + /// Specializations of the lambda_matches 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, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/lambda_matches.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_DEFINE_LAMBDA_MATCHES + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + template< + template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T + BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Expr) + BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Grammar) + > + struct lambda_matches< + T<BOOST_PP_ENUM_PARAMS(N, Expr)> + , T<BOOST_PP_ENUM_PARAMS(N, Grammar)> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(N) + > + : BOOST_PP_CAT(and_, N)< + BOOST_PROTO_DEFINE_LAMBDA_MATCHES(~, 0, ~)::value, + BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_LAMBDA_MATCHES, ~) + > + {}; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/local.hpp b/3rdParty/Boost/src/boost/proto/detail/local.hpp new file mode 100644 index 0000000..8886bbb --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/local.hpp @@ -0,0 +1,52 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file local.hpp +/// Contains macros to ease the generation of repetitious code constructs +// +// 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_LOCAL_MACRO +# error "local iteration target macro is not defined" +#endif + +#ifndef BOOST_PROTO_LOCAL_LIMITS +# define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PROTO_MAX_ARITY) +#endif + +#ifndef BOOST_PROTO_LOCAL_typename_A +# define BOOST_PROTO_LOCAL_typename_A BOOST_PROTO_typename_A +#endif + +#ifndef BOOST_PROTO_LOCAL_A +# define BOOST_PROTO_LOCAL_A BOOST_PROTO_A_const_ref +#endif + +#ifndef BOOST_PROTO_LOCAL_A_a +# define BOOST_PROTO_LOCAL_A_a BOOST_PROTO_A_const_ref_a +#endif + +#ifndef BOOST_PROTO_LOCAL_a +# define BOOST_PROTO_LOCAL_a BOOST_PROTO_ref_a +#endif + +#define BOOST_PP_LOCAL_LIMITS BOOST_PROTO_LOCAL_LIMITS + +#define BOOST_PP_LOCAL_MACRO(N) \ + BOOST_PROTO_LOCAL_MACRO( \ + N \ + , BOOST_PROTO_LOCAL_typename_A \ + , BOOST_PROTO_LOCAL_A \ + , BOOST_PROTO_LOCAL_A_a \ + , BOOST_PROTO_LOCAL_a \ + ) \ + /**/ + +#include BOOST_PP_LOCAL_ITERATE() + +#undef BOOST_PROTO_LOCAL_MACRO +#undef BOOST_PROTO_LOCAL_LIMITS +#undef BOOST_PROTO_LOCAL_typename_A +#undef BOOST_PROTO_LOCAL_A +#undef BOOST_PROTO_LOCAL_A_a +#undef BOOST_PROTO_LOCAL_a diff --git a/3rdParty/Boost/src/boost/proto/detail/make_expr.hpp b/3rdParty/Boost/src/boost/proto/detail/make_expr.hpp new file mode 100644 index 0000000..5556403 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/make_expr.hpp @@ -0,0 +1,75 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/make_expr.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file make_expr.hpp + /// Contains overloads of make_expr() free function. + // + // 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, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + /// \overload + /// + template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) + > + >::type const + make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a)) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) + >()(BOOST_PP_ENUM_PARAMS(N, a)); + } + + /// \overload + /// + template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename C)> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + BOOST_PP_ENUM_TRAILING_PARAMS(N, const C) + >::type const + make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const C, &c)) + { + return proto::detail::make_expr_< + Tag + , Domain + BOOST_PP_ENUM_TRAILING_PARAMS(N, const C) + >()(BOOST_PP_ENUM_PARAMS(N, c)); + } + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/make_expr_.hpp b/3rdParty/Boost/src/boost/proto/detail/make_expr_.hpp new file mode 100644 index 0000000..9e37649 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/make_expr_.hpp @@ -0,0 +1,105 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/make_expr_.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr_.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file make_expr_.hpp + /// Contains definition of make_expr_\<\> 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 + + template< + typename Tag + , typename Domain + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( + BOOST_PROTO_MAX_ARITY + , typename A + , = void BOOST_PP_INTERCEPT + ) + , typename _ = void + > + struct make_expr_ + {}; + + template<typename Domain, typename A> + struct make_expr_<tag::terminal, Domain, A + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)> + { + typedef typename proto::detail::protoify<A, Domain>::result_type result_type; + + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A>::type a) const + { + return proto::detail::protoify<A, Domain>()(a); + } + }; + + template<typename A> + struct make_expr_<tag::terminal, deduce_domain, A + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)> + : make_expr_<tag::terminal, default_domain, A> + {}; + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N) + + template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make_expr_<Tag, Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A) + BOOST_PP_ENUM_TRAILING_PARAMS(M, void BOOST_PP_INTERCEPT), void> + { + typedef + BOOST_PP_CAT(list, N)< + BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD_TYPE, (A, ~, Domain)) + > + proto_args; + + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + + BOOST_FORCEINLINE + result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a)) const + { + expr_type const that = { + BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD, (A, a, Domain)) + }; + return proto_generator()(that); + } + }; + + template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make_expr_<Tag, deduce_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A) + BOOST_PP_ENUM_TRAILING_PARAMS(M, void BOOST_PP_INTERCEPT), void> + : make_expr_< + Tag + , typename BOOST_PP_CAT(deduce_domain, N)<BOOST_PP_ENUM_PARAMS(N, A)>::type + BOOST_PP_ENUM_TRAILING_PARAMS(N, A) + > + {}; + + #undef N + #undef M + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/make_expr_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/make_expr_funop.hpp new file mode 100644 index 0000000..fa5e7f1 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/make_expr_funop.hpp @@ -0,0 +1,67 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/make_expr_funop.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr_funop.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file make_expr_funop.hpp + /// Contains definition of make_expr\<\>::operator() member functions. + // + // 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, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_funop.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct result<This(BOOST_PP_ENUM_PARAMS(N, A))> + { + typedef + typename result_of::make_expr< + Tag + , Domain + BOOST_PP_ENUM_TRAILING_PARAMS(N, A) + >::type + type; + }; + + /// \overload + /// + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) + >::type const + operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a)) const + { + return proto::detail::make_expr_< + Tag + , Domain + BOOST_PP_ENUM_TRAILING_PARAMS(N, const A) + >()(BOOST_PP_ENUM_PARAMS(N, a)); + } + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/matches_.hpp b/3rdParty/Boost/src/boost/proto/detail/matches_.hpp new file mode 100644 index 0000000..d55ddc7 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/matches_.hpp @@ -0,0 +1,96 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/matches_.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_MATCHES_N_FUN(Z, N, DATA) \ + matches_< \ + typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_derived_expr \ + , typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_grammar \ + , typename Args2::BOOST_PP_CAT(child, N)::proto_grammar \ + > + + #define BOOST_PROTO_DEFINE_MATCHES(Z, N, DATA) \ + matches_< \ + Expr \ + , BasicExpr \ + , typename BOOST_PP_CAT(G, N)::proto_grammar \ + > + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/matches_.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file matches_.hpp + /// Definitions of matches_ specializations + // + // 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, (2, BOOST_PP_MAX(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_MAX_LOGICAL_ARITY), <boost/proto/detail/matches_.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_DEFINE_MATCHES + #undef BOOST_PROTO_MATCHES_N_FUN + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + #if N <= BOOST_PROTO_MAX_LOGICAL_ARITY + + // handle proto::or_ + template<typename Expr, typename BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)> + struct matches_<Expr, BasicExpr, proto::or_<BOOST_PP_ENUM_PARAMS(N, G)> > + : BOOST_PP_CAT(or_, N)< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, G) + > + {}; + + // handle proto::and_ + template<typename Expr, typename BasicExpr, BOOST_PP_ENUM_PARAMS(N, typename G)> + struct matches_<Expr, BasicExpr, proto::and_<BOOST_PP_ENUM_PARAMS(N, G)> > + : detail::BOOST_PP_CAT(and_, N)< + BOOST_PROTO_DEFINE_MATCHES(~, 0, ~)::value, + BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_MATCHES, ~) + > + {}; + + #endif + + #if N <= BOOST_PROTO_MAX_ARITY + + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, N>, proto::basic_expr<Tag, Args2, N> > + : BOOST_PP_CAT(and_, N)< + BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value, + BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~) + > + {}; + + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, N>, proto::basic_expr<proto::_, Args2, N> > + : BOOST_PP_CAT(and_, N)< + BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value, + BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~) + > + {}; + + #endif + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/memfun_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/memfun_funop.hpp new file mode 100644 index 0000000..8a63a9f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/memfun_funop.hpp @@ -0,0 +1,45 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/memfun_funop.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/memfun_funop.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + // memfun_funop.hpp + // Contains overloads of memfun::operator(). + // + // 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/detail/memfun_funop.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + #define N BOOST_PP_ITERATION() + + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + BOOST_FORCEINLINE + result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(BOOST_PP_ENUM_PARAMS(N, a)); + } + + #undef N + +#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES diff --git a/3rdParty/Boost/src/boost/proto/detail/or_n.hpp b/3rdParty/Boost/src/boost/proto/detail/or_n.hpp new file mode 100644 index 0000000..514cd72 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/or_n.hpp @@ -0,0 +1,59 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/or_n.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/or_n.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file or_n.hpp + /// Definitions of or_N + // + // 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, (2, BOOST_PROTO_MAX_LOGICAL_ARITY, <boost/proto/detail/or_n.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + template<bool B, typename Expr, typename BasicExpr, BOOST_PP_ENUM_PARAMS(N, typename G)> + struct BOOST_PP_CAT(or_, N) + #if 2 == N + : mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value> + { + typedef G1 which; + }; + #else + : BOOST_PP_CAT(or_, BOOST_PP_DEC(N))< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, BOOST_PP_ENUM_SHIFTED_PARAMS(N, G) + > + {}; + #endif + + template<typename Expr, typename BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)> + struct BOOST_PP_CAT(or_, N)<true, Expr, BasicExpr, BOOST_PP_ENUM_PARAMS(N, G)> + : mpl::true_ + { + typedef G0 which; + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/poly_function.hpp b/3rdParty/Boost/src/boost/proto/detail/poly_function.hpp new file mode 100644 index 0000000..2bde53b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/poly_function.hpp @@ -0,0 +1,234 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file poly_function.hpp +/// A wrapper that makes a tr1-style function object that handles const +/// and non-const refs and reference_wrapper arguments, too, and forwards +/// the arguments on to the specified implementation. +// +// 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_DETAIL_POLY_FUNCTION_EAN_2008_05_02 +#define BOOST_PROTO_DETAIL_POLY_FUNCTION_EAN_2008_05_02 + +#include <boost/ref.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/void.hpp> +#include <boost/mpl/size_t.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/detail/is_noncopyable.hpp> + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4181) // const applied to reference type +#endif + +namespace boost { namespace proto { namespace detail +{ + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct normalize_arg + { + typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type type; + typedef T &reference; + }; + + template<typename T> + struct normalize_arg<T const> + { + typedef typename mpl::if_c<is_noncopyable<T>::value, T const &, T>::type type; + typedef T const &reference; + }; + + template<typename T> + struct normalize_arg<T &> + { + typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type type; + typedef T &reference; + }; + + template<typename T> + struct normalize_arg<T const &> + { + typedef typename mpl::if_c<is_noncopyable<T>::value, T const &, T>::type type; + typedef T const &reference; + }; + + template<typename T> + struct normalize_arg<boost::reference_wrapper<T> > + { + typedef T &type; + typedef T &reference; + }; + + template<typename T> + struct normalize_arg<boost::reference_wrapper<T> const> + { + typedef T &type; + typedef T &reference; + }; + + template<typename T> + struct normalize_arg<boost::reference_wrapper<T> &> + { + typedef T &type; + typedef T &reference; + }; + + template<typename T> + struct normalize_arg<boost::reference_wrapper<T> const &> + { + typedef T &type; + typedef T &reference; + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T> + struct arg + { + typedef T const &type; + + arg(type t) + : value(t) + {} + + operator type() const + { + return this->value; + } + + type operator()() const + { + return this->value; + } + + private: + arg &operator =(arg const &); + type value; + }; + + template<typename T> + struct arg<T &> + { + typedef T &type; + + arg(type t) + : value(t) + {} + + operator type() const + { + return this->value; + } + + type operator()() const + { + return this->value; + } + + private: + arg &operator =(arg const &); + type value; + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename T, typename Void = void> + struct is_poly_function + : mpl::false_ + {}; + + template<typename T> + struct is_poly_function<T, typename T::is_poly_function_base_> + : mpl::true_ + {}; + + //////////////////////////////////////////////////////////////////////////////////////////////// + #define BOOST_PROTO_POLY_FUNCTION() \ + typedef void is_poly_function_base_; \ + /**/ + + //////////////////////////////////////////////////////////////////////////////////////////////// + struct poly_function_base + { + /// INTERNAL ONLY + BOOST_PROTO_POLY_FUNCTION() + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename Derived, typename NullaryResult = void> + struct poly_function + : poly_function_base + { + template<typename Sig> + struct result; + + template<typename This> + struct result<This()> + : Derived::template impl<> + { + typedef typename result::result_type type; + }; + + NullaryResult operator()() const + { + result<Derived const()> impl; + return impl(); + } + + #include <boost/proto/detail/poly_function_funop.hpp> + }; + + template<typename T> + struct wrap_t; + + typedef char poly_function_t; + typedef char (&mono_function_t)[2]; + typedef char (&unknown_function_t)[3]; + + template<typename T> poly_function_t test_poly_function(T *, wrap_t<typename T::is_poly_function_base_> * = 0); + template<typename T> mono_function_t test_poly_function(T *, wrap_t<typename T::result_type> * = 0); + template<typename T> unknown_function_t test_poly_function(T *, ...); + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename Fun, typename Sig, typename Switch = mpl::size_t<sizeof(test_poly_function<Fun>(0,0))> > + struct poly_function_traits + { + typedef typename Fun::template result<Sig>::type result_type; + typedef Fun function_type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename Fun, typename Sig> + struct poly_function_traits<Fun, Sig, mpl::size_t<sizeof(mono_function_t)> > + { + typedef typename Fun::result_type result_type; + typedef Fun function_type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename PolyFunSig, bool IsPolyFunction> + struct as_mono_function_impl; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename PolyFunSig> + struct as_mono_function; + + #include <boost/proto/detail/poly_function_traits.hpp> + +}}} // namespace boost::proto::detail + +#ifdef _MSC_VER +# pragma warning(pop) +#endif + +#endif + diff --git a/3rdParty/Boost/src/boost/proto/detail/poly_function_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/poly_function_funop.hpp new file mode 100644 index 0000000..d0f0d2a --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/poly_function_funop.hpp @@ -0,0 +1,74 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/poly_function_funop.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_NORMALIZE_ARG(Z, N, DATA) \ + static_cast<typename normalize_arg<BOOST_PP_CAT(A, N) const &> \ + ::reference>(BOOST_PP_CAT(a, N)) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/poly_function_funop.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + // poly_function_funop.hpp + // Contains overloads of poly_function\<\>::operator() + // + // 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/detail/poly_function_funop.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_NORMALIZE_ARG + +#else + + #define N BOOST_PP_ITERATION() + + template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct result<This(BOOST_PP_ENUM_PARAMS(N, A))> + : Derived::template impl< + BOOST_PP_ENUM_BINARY_PARAMS( + N + , typename normalize_arg<A + , >::type BOOST_PP_INTERCEPT + ) + > + { + typedef typename result::result_type type; + }; + + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + typename result< + Derived const( + BOOST_PP_ENUM_BINARY_PARAMS(N, A, const & BOOST_PP_INTERCEPT) + ) + >::type + operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const + { + result< + Derived const( + BOOST_PP_ENUM_BINARY_PARAMS(N, A, const & BOOST_PP_INTERCEPT) + ) + > impl; + + return impl(BOOST_PP_ENUM(N, BOOST_PROTO_NORMALIZE_ARG, ~)); + } + + #undef N + +#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES diff --git a/3rdParty/Boost/src/boost/proto/detail/poly_function_traits.hpp b/3rdParty/Boost/src/boost/proto/detail/poly_function_traits.hpp new file mode 100644 index 0000000..188d4a4 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/poly_function_traits.hpp @@ -0,0 +1,65 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/poly_function_traits.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/poly_function_traits.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + // poly_function_traits.hpp + // Contains specializations of poly_function_traits and as_mono_function + // + // 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/detail/poly_function_traits.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + #define N BOOST_PP_ITERATION() + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct poly_function_traits<PolyFun, PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> function_type; + typedef typename function_type::result_type result_type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), true> + { + typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), false> + { + typedef PolyFun type; + }; + + //////////////////////////////////////////////////////////////////////////////////////////////// + template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct as_mono_function<PolyFun(BOOST_PP_ENUM_PARAMS(N, A))> + : as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), is_poly_function<PolyFun>::value> + {}; + + #undef N + +#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/and_n.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/and_n.hpp new file mode 100644 index 0000000..b6eedcb --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/and_n.hpp @@ -0,0 +1,310 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file and_n.hpp + /// Definitions of and_N, and_impl + // + // 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<bool B, typename P0> + struct and_2 + : mpl::bool_<P0::value> + {}; + template<typename P0> + struct and_2<false, P0> + : mpl::false_ + {}; + template<typename G0 , typename G1, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; + typedef typename Gimpl1::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); + return Gimpl1()(e,s,d); + } + }; + + + + template<bool B, typename P0 , typename P1> + struct and_3 + : and_2< + P0::value , + P1 + > + {}; + template<typename P0 , typename P1> + struct and_3<false, P0 , P1> + : mpl::false_ + {}; + template<typename G0 , typename G1 , typename G2, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1 , G2>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; + typedef typename Gimpl2::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); Gimpl1()(e,s,d); + return Gimpl2()(e,s,d); + } + }; + + + + template<bool B, typename P0 , typename P1 , typename P2> + struct and_4 + : and_3< + P0::value , + P1 , P2 + > + {}; + template<typename P0 , typename P1 , typename P2> + struct and_4<false, P0 , P1 , P2> + : mpl::false_ + {}; + template<typename G0 , typename G1 , typename G2 , typename G3, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1 , G2 , G3>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; + typedef typename Gimpl3::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); + return Gimpl3()(e,s,d); + } + }; + + + + template<bool B, typename P0 , typename P1 , typename P2 , typename P3> + struct and_5 + : and_4< + P0::value , + P1 , P2 , P3 + > + {}; + template<typename P0 , typename P1 , typename P2 , typename P3> + struct and_5<false, P0 , P1 , P2 , P3> + : mpl::false_ + {}; + template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; + typedef typename Gimpl4::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); + return Gimpl4()(e,s,d); + } + }; + + + + template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4> + struct and_6 + : and_5< + P0::value , + P1 , P2 , P3 , P4 + > + {}; + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4> + struct and_6<false, P0 , P1 , P2 , P3 , P4> + : mpl::false_ + {}; + template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; + typedef typename Gimpl5::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); + return Gimpl5()(e,s,d); + } + }; + + + + template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> + struct and_7 + : and_6< + P0::value , + P1 , P2 , P3 , P4 , P5 + > + {}; + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> + struct and_7<false, P0 , P1 , P2 , P3 , P4 , P5> + : mpl::false_ + {}; + template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; + typedef typename Gimpl6::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); + return Gimpl6()(e,s,d); + } + }; + + + + template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> + struct and_8 + : and_7< + P0::value , + P1 , P2 , P3 , P4 , P5 , P6 + > + {}; + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> + struct and_8<false, P0 , P1 , P2 , P3 , P4 , P5 , P6> + : mpl::false_ + {}; + template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; + typedef typename Gimpl7::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); + return Gimpl7()(e,s,d); + } + }; + + + + template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> + struct and_9 + : and_8< + P0::value , + P1 , P2 , P3 , P4 , P5 , P6 , P7 + > + {}; + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> + struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7> + : mpl::false_ + {}; + template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; + typedef typename Gimpl8::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); + return Gimpl8()(e,s,d); + } + }; + + + + template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> + struct and_10 + : and_9< + P0::value , + P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 + > + {}; + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> + struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8> + : mpl::false_ + {}; + template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data> + : proto::transform_impl<Expr, State, Data> + { + typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename proto::when<proto::_, G9> ::template impl<Expr, State, Data> Gimpl9; + typedef typename Gimpl9::result_type result_type; + result_type operator()( + typename _and_impl::expr_param e + , typename _and_impl::state_param s + , typename _and_impl::data_param d + ) const + { + + + + + Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); Gimpl8()(e,s,d); + return Gimpl9()(e,s,d); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/args.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/args.hpp new file mode 100644 index 0000000..dccec14 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/args.hpp @@ -0,0 +1,162 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file args.hpp + /// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ... + /// class templates. + // + // 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 Arg0 > + struct term + { + static const long arity = 0; + typedef Arg0 child0; + typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg0 back_; + }; + + + + + template< typename Arg0 > + struct list1 + { + static const long arity = 1; + typedef Arg0 child0; + typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg0 back_; + }; + + + + + template< typename Arg0 , typename Arg1 > + struct list2 + { + static const long arity = 2; + typedef Arg0 child0; typedef Arg1 child1; + typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg1 back_; + }; + + + + + template< typename Arg0 , typename Arg1 , typename Arg2 > + struct list3 + { + static const long arity = 3; + typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; + typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg2 back_; + }; + + + + + template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 > + struct list4 + { + static const long arity = 4; + typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; + typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg3 back_; + }; + + + + + template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 > + struct list5 + { + static const long arity = 5; + typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; + typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg4 back_; + }; + + + + + template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 > + struct list6 + { + static const long arity = 6; + typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; + typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg5 back_; + }; + + + + + template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 > + struct list7 + { + static const long arity = 7; + typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; + typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg6 back_; + }; + + + + + template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 > + struct list8 + { + static const long arity = 8; + typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; + typedef mpl::void_ child8; typedef mpl::void_ child9; + + + typedef Arg7 back_; + }; + + + + + template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 > + struct list9 + { + static const long arity = 9; + typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8; + typedef mpl::void_ child9; + + + typedef Arg8 back_; + }; + + + + + template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 > + struct list10 + { + static const long arity = 10; + typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8; typedef Arg9 child9; + + + + typedef Arg9 back_; + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/basic_expr.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/basic_expr.hpp new file mode 100644 index 0000000..c28708f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/basic_expr.hpp @@ -0,0 +1,809 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file basic_expr.hpp + /// Contains definition of basic_expr\<\> 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 Tag, typename Arg0> + struct basic_expr<Tag, term<Arg0>, 0> + { + typedef Tag proto_tag; + static const long proto_arity_c = 0; + typedef mpl::long_<0 > proto_arity; + typedef basic_expr proto_base_expr; + typedef term<Arg0> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; + typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0> + BOOST_FORCEINLINE + static basic_expr const make(A0 &a0) + { + return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0)); + } + + + template<typename A0> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0) + { + return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0)); + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0> + struct basic_expr<Tag, list1<Arg0>, 1 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 1; + typedef mpl::long_<1 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list1<Arg0> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; + typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0) + { + basic_expr that = {a0}; + return that; + } + + + + typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; + + + + + + + + BOOST_FORCEINLINE + operator address_of_hack_type_() const + { + return boost::addressof(this->child0); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1> + struct basic_expr<Tag, list2<Arg0 , Arg1>, 2 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 2; + typedef mpl::long_<2 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list2<Arg0 , Arg1> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; + typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1) + { + basic_expr that = {a0 , a1}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2> + struct basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 3; + typedef mpl::long_<3 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list3<Arg0 , Arg1 , Arg2> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; + typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2) + { + basic_expr that = {a0 , a1 , a2}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3> + struct basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 4; + typedef mpl::long_<4 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; + typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) + { + basic_expr that = {a0 , a1 , a2 , a3}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4> + struct basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 5; + typedef mpl::long_<5 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; + typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) + { + basic_expr that = {a0 , a1 , a2 , a3 , a4}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5> + struct basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 6; + typedef mpl::long_<6 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; + typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) + { + basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6> + struct basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 7; + typedef mpl::long_<7 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; + typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) + { + basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7> + struct basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 8; + typedef mpl::long_<8 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; + typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) + { + basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8> + struct basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 9; + typedef mpl::long_<9 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; + typedef void proto_child9; + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) + { + basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9> + struct basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 10; + typedef mpl::long_<10 > proto_arity; + typedef basic_expr proto_base_expr; + typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args; + typedef basic_expr proto_grammar; + typedef basic_default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef basic_expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9; + + + + BOOST_FORCEINLINE + basic_expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + basic_expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) + { + basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/class_member_traits.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/class_member_traits.hpp new file mode 100644 index 0000000..418957a --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/class_member_traits.hpp @@ -0,0 +1,139 @@ + /////////////////////////////////////////////////////////////////////////////// + // class_member_traits.hpp + // Contains specializations of the class_member_traits\<\> 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 T, typename U > + struct class_member_traits<T (U::*)()> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U > + struct class_member_traits<T (U::*)() const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0> + struct class_member_traits<T (U::*)(A0)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0> + struct class_member_traits<T (U::*)(A0) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1> + struct class_member_traits<T (U::*)(A0 , A1)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1> + struct class_member_traits<T (U::*)(A0 , A1) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2> + struct class_member_traits<T (U::*)(A0 , A1 , A2)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2> + struct class_member_traits<T (U::*)(A0 , A1 , A2) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + { + typedef U class_type; + typedef T result_type; + }; + template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const> + { + typedef U class_type; + typedef T result_type; + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/deduce_domain_n.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/deduce_domain_n.hpp new file mode 100644 index 0000000..2a00035 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/deduce_domain_n.hpp @@ -0,0 +1,119 @@ + /////////////////////////////////////////////////////////////////////////////// + // deduce_domain_n.hpp + // Definitions of common_domain[n] and deduce_domain[n] class templates. + // + // 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 A0 , typename A1 , typename A2> + struct common_domain3 + { + typedef A0 common1; + typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; + typedef common3 type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + template<typename E0 , typename E1 , typename E2> + struct deduce_domain3 + : common_domain3< + typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type + > + {}; + template<typename A0 , typename A1 , typename A2 , typename A3> + struct common_domain4 + { + typedef A0 common1; + typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; + typedef common4 type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + template<typename E0 , typename E1 , typename E2 , typename E3> + struct deduce_domain4 + : common_domain4< + typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type + > + {}; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct common_domain5 + { + typedef A0 common1; + typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; + typedef common5 type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4> + struct deduce_domain5 + : common_domain5< + typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type + > + {}; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct common_domain6 + { + typedef A0 common1; + typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; + typedef common6 type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5> + struct deduce_domain6 + : common_domain6< + typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type + > + {}; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct common_domain7 + { + typedef A0 common1; + typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; + typedef common7 type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6> + struct deduce_domain7 + : common_domain7< + typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type + > + {}; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct common_domain8 + { + typedef A0 common1; + typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; + typedef common8 type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7> + struct deduce_domain8 + : common_domain8< + typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type + > + {}; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct common_domain9 + { + typedef A0 common1; + typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9; + typedef common9 type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8> + struct deduce_domain9 + : common_domain9< + typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type + > + {}; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct common_domain10 + { + typedef A0 common1; + typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9; typedef typename common_domain2<common9, A9>::type common10; + typedef common10 type; + BOOST_PROTO_ASSERT_VALID_DOMAIN(type); + }; + template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8 , typename E9> + struct deduce_domain10 + : common_domain10< + typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type , typename domain_of<E9 >::type + > + {}; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/deep_copy.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/deep_copy.hpp new file mode 100644 index 0000000..4028609 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/deep_copy.hpp @@ -0,0 +1,237 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file deep_copy.hpp + /// Replace all nodes stored by reference by nodes stored by value. + // + // 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> + struct deep_copy_impl<Expr, 1> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list1< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 2> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list2< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 3> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list3< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 4> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list4< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 5> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list5< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 6> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list6< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 7> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list7< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 8> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list8< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 9> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list9< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8) + }; + return proto_generator()(that); + } + }; + template<typename Expr> + struct deep_copy_impl<Expr, 10> + { + typedef + typename base_expr< + typename Expr::proto_domain + , typename Expr::proto_tag + , list10< + typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child9 >::type::proto_derived_expr >::result_type + > + >::type + expr_type; + typedef typename Expr::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + template<typename Expr2, typename S, typename D> + result_type operator()(Expr2 const &e, S const &, D const &) const + { + expr_type const that = { + proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8) , proto::deep_copy(e.proto_base().child9) + }; + return proto_generator()(that); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/expr.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/expr.hpp new file mode 100644 index 0000000..645bb5a --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/expr.hpp @@ -0,0 +1,3742 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file expr.hpp + /// Contains definition of expr\<\> 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 Tag, typename Arg0> + struct expr<Tag, term<Arg0>, 0> + { + typedef Tag proto_tag; + static const long proto_arity_c = 0; + typedef mpl::long_<0 > proto_arity; + typedef expr proto_base_expr; + typedef term<Arg0> proto_args; + typedef basic_expr<Tag, proto_args, 0 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; + typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0> + BOOST_FORCEINLINE + static expr const make(A0 &a0) + { + return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); + } + + + template<typename A0> + BOOST_FORCEINLINE + static expr const make(A0 const &a0) + { + return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) + { + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) + { + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr &>, 1> const + operator ()() + { + proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) + { + return result_of::funop1< + expr + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) + { + return result_of::funop2< + expr + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) + { + return result_of::funop3< + expr + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) + { + return result_of::funop4< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) + { + return result_of::funop5< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) + { + return result_of::funop6< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) + { + return result_of::funop7< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) + { + return result_of::funop8< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) + { + return result_of::funop9< + expr + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0> + struct expr<Tag, list1<Arg0>, 1 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 1; + typedef mpl::long_<1 > proto_arity; + typedef expr proto_base_expr; + typedef list1<Arg0> proto_args; + typedef basic_expr<Tag, proto_args, 1 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; + typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0> + BOOST_FORCEINLINE + static expr const make(A0 const &a0) + { + expr that = {a0}; + return that; + } + + + + typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; + + + + + + + + BOOST_FORCEINLINE + operator address_of_hack_type_() const + { + return boost::addressof(this->child0); + } + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1> + struct expr<Tag, list2<Arg0 , Arg1>, 2 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 2; + typedef mpl::long_<2 > proto_arity; + typedef expr proto_base_expr; + typedef list2<Arg0 , Arg1> proto_args; + typedef basic_expr<Tag, proto_args, 2 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; + typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1) + { + expr that = {a0 , a1}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2> + struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 3; + typedef mpl::long_<3 > proto_arity; + typedef expr proto_base_expr; + typedef list3<Arg0 , Arg1 , Arg2> proto_args; + typedef basic_expr<Tag, proto_args, 3 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; + typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2) + { + expr that = {a0 , a1 , a2}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3> + struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 4; + typedef mpl::long_<4 > proto_arity; + typedef expr proto_base_expr; + typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args; + typedef basic_expr<Tag, proto_args, 4 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; + typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) + { + expr that = {a0 , a1 , a2 , a3}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4> + struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 5; + typedef mpl::long_<5 > proto_arity; + typedef expr proto_base_expr; + typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args; + typedef basic_expr<Tag, proto_args, 5 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; + typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) + { + expr that = {a0 , a1 , a2 , a3 , a4}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5> + struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 6; + typedef mpl::long_<6 > proto_arity; + typedef expr proto_base_expr; + typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args; + typedef basic_expr<Tag, proto_args, 6 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; + typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6> + struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 7; + typedef mpl::long_<7 > proto_arity; + typedef expr proto_base_expr; + typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args; + typedef basic_expr<Tag, proto_args, 7 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; + typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7> + struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 8; + typedef mpl::long_<8 > proto_arity; + typedef expr proto_base_expr; + typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args; + typedef basic_expr<Tag, proto_args, 8 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; + typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8> + struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 9; + typedef mpl::long_<9 > proto_arity; + typedef expr proto_base_expr; + typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args; + typedef basic_expr<Tag, proto_args, 9 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; + typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9> + struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 10; + typedef mpl::long_<10 > proto_arity; + typedef expr proto_base_expr; + typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args; + typedef basic_expr<Tag, proto_args, 10 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9; + + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + + BOOST_FORCEINLINE + proto::expr<proto::tag::function, list1<expr const &>, 1> const + operator ()() const + { + proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; + return that; + } + + + template<typename A0> + BOOST_FORCEINLINE + typename result_of::funop1< + expr const + , default_domain , const A0 + >::type const + operator ()(A0 const &a0) const + { + return result_of::funop1< + expr const + , default_domain , const A0 + >::call(*this , a0); + } + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::type const + operator ()(A0 const &a0 , A1 const &a1) const + { + return result_of::funop2< + expr const + , default_domain , const A0 , const A1 + >::call(*this , a0 , a1); + } + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + return result_of::funop3< + expr const + , default_domain , const A0 , const A1 , const A2 + >::call(*this , a0 , a1 , a2); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + return result_of::funop4< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 + >::call(*this , a0 , a1 , a2 , a3); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + return result_of::funop5< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 + >::call(*this , a0 , a1 , a2 , a3 , a4); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + return result_of::funop6< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + return result_of::funop7< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + return result_of::funop8< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + return result_of::funop9< + expr const + , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/expr_variadic.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/expr_variadic.hpp new file mode 100644 index 0000000..2ab633b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/expr_variadic.hpp @@ -0,0 +1,2208 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file expr_variadic.hpp + /// Contains definition of expr\<\> 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 Tag, typename Arg0> + struct expr<Tag, term<Arg0>, 0> + { + typedef Tag proto_tag; + static const long proto_arity_c = 0; + typedef mpl::long_<0 > proto_arity; + typedef expr proto_base_expr; + typedef term<Arg0> proto_args; + typedef basic_expr<Tag, proto_args, 0 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; + typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0> + BOOST_FORCEINLINE + static expr const make(A0 &a0) + { + return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); + } + + + template<typename A0> + BOOST_FORCEINLINE + static expr const make(A0 const &a0) + { + return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0)); + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) + { + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) + { + proto::expr< + proto::tag::subscript + , list2<expr &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) + { + return result_of::funop< + expr(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0> + struct expr<Tag, list1<Arg0>, 1 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 1; + typedef mpl::long_<1 > proto_arity; + typedef expr proto_base_expr; + typedef list1<Arg0> proto_args; + typedef basic_expr<Tag, proto_args, 1 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; + typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0> + BOOST_FORCEINLINE + static expr const make(A0 const &a0) + { + expr that = {a0}; + return that; + } + + + + typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_; + + + + + + + + BOOST_FORCEINLINE + operator address_of_hack_type_() const + { + return boost::addressof(this->child0); + } + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1> + struct expr<Tag, list2<Arg0 , Arg1>, 2 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 2; + typedef mpl::long_<2 > proto_arity; + typedef expr proto_base_expr; + typedef list2<Arg0 , Arg1> proto_args; + typedef basic_expr<Tag, proto_args, 2 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; + typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1) + { + expr that = {a0 , a1}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2> + struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 3; + typedef mpl::long_<3 > proto_arity; + typedef expr proto_base_expr; + typedef list3<Arg0 , Arg1 , Arg2> proto_args; + typedef basic_expr<Tag, proto_args, 3 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; + typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2) + { + expr that = {a0 , a1 , a2}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3> + struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 4; + typedef mpl::long_<4 > proto_arity; + typedef expr proto_base_expr; + typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args; + typedef basic_expr<Tag, proto_args, 4 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; + typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) + { + expr that = {a0 , a1 , a2 , a3}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4> + struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 5; + typedef mpl::long_<5 > proto_arity; + typedef expr proto_base_expr; + typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args; + typedef basic_expr<Tag, proto_args, 5 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; + typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) + { + expr that = {a0 , a1 , a2 , a3 , a4}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5> + struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 6; + typedef mpl::long_<6 > proto_arity; + typedef expr proto_base_expr; + typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args; + typedef basic_expr<Tag, proto_args, 6 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; + typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6> + struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 7; + typedef mpl::long_<7 > proto_arity; + typedef expr proto_base_expr; + typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args; + typedef basic_expr<Tag, proto_args, 7 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; + typedef void proto_child7; typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7> + struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 8; + typedef mpl::long_<8 > proto_arity; + typedef expr proto_base_expr; + typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args; + typedef basic_expr<Tag, proto_args, 8 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; + typedef void proto_child8; typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8> + struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 9; + typedef mpl::long_<9 > proto_arity; + typedef expr proto_base_expr; + typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args; + typedef basic_expr<Tag, proto_args, 9 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; + typedef void proto_child9; + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9> + struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 > + { + typedef Tag proto_tag; + static const long proto_arity_c = 10; + typedef mpl::long_<10 > proto_arity; + typedef expr proto_base_expr; + typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args; + typedef basic_expr<Tag, proto_args, 10 > proto_grammar; + typedef default_domain proto_domain; + typedef default_generator proto_generator; + typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag; + typedef expr proto_derived_expr; + typedef void proto_is_expr_; + typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9; + + + + BOOST_FORCEINLINE + expr const &proto_base() const + { + return *this; + } + + + BOOST_FORCEINLINE + expr &proto_base() + { + return *this; + } + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) + { + expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; + return that; + } + + + typedef detail::not_a_valid_type address_of_hack_type_; + + + + + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > const + operator =(expr const &a) + { + proto::expr< + proto::tag::assign + , list2<expr &, expr const &> + , 2 + > that = {*this, a}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator =(A &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator =(A const &a) const + { + proto::expr< + proto::tag::assign + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > const + operator [](A &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename A> + BOOST_FORCEINLINE + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > const + operator [](A const &a) const + { + proto::expr< + proto::tag::subscript + , list2<expr const &, typename result_of::as_child<A const>::type> + , 2 + > that = {*this, proto::as_child(a)}; + return that; + } + + + template<typename Sig> + struct result + { + typedef typename result_of::funop<Sig, expr, default_domain>::type const type; + }; + + + template<typename ...A> + BOOST_FORCEINLINE + typename result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::type const + operator ()(A const &... a) const + { + return result_of::funop< + expr const(A const &...) + , expr + , default_domain + >::call(*this, a...); + } + }; + diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/extends_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/extends_funop.hpp new file mode 100644 index 0000000..b74cacf --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/extends_funop.hpp @@ -0,0 +1,18 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file extends_funop.hpp + /// Definitions for extends\<\>::operator() + // + // 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 Sig> struct result { typedef typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; }; + BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); } BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr , proto_domain >::type ) >::type const operator ()() { typedef boost::proto::result_of::funop0< proto_derived_expr , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) ) ); } + template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); } template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) { typedef boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 ) ); } + template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) { typedef boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 ) ); } + template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) { typedef boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { typedef boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { typedef boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { typedef boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { typedef boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { typedef boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { typedef boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/extends_funop_const.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/extends_funop_const.hpp new file mode 100644 index 0000000..e576c9e --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/extends_funop_const.hpp @@ -0,0 +1,18 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file extends_funop_const.hpp + /// Definitions for extends\<\>::operator() + // + // 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 Sig> struct result { typedef typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; }; + BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); } + template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); } + template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } + template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/funop.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/funop.hpp new file mode 100644 index 0000000..8eb8298 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/funop.hpp @@ -0,0 +1,367 @@ + /////////////////////////////////////////////////////////////////////////////// + // funop.hpp + // Contains definition of funop[n]\<\> 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 Domain > + struct funop0 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list1< + Expr & + + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + + ) + { + type that = { + e + + }; + return that; + } + }; + + + template<typename Expr , typename This, typename Domain> + struct funop<Expr(), This, Domain> + : funop0< + typename detail::same_cv<Expr, This>::type + , Domain + + > + {}; + + + template<typename Expr, typename Domain , typename A0> + struct funop1 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list2< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) + }; + return that; + } + }; + + + template<typename Expr , typename A0, typename This, typename Domain> + struct funop<Expr(A0), This, Domain> + : funop1< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type + > + {}; + + + template<typename Expr, typename Domain , typename A0 , typename A1> + struct funop2 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list3< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 , A1 &a1 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) + }; + return that; + } + }; + + + template<typename Expr , typename A0 , typename A1, typename This, typename Domain> + struct funop<Expr(A0 , A1), This, Domain> + : funop2< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type + > + {}; + + + template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2> + struct funop3 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list4< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 , A1 &a1 , A2 &a2 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) + }; + return that; + } + }; + + + template<typename Expr , typename A0 , typename A1 , typename A2, typename This, typename Domain> + struct funop<Expr(A0 , A1 , A2), This, Domain> + : funop3< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type + > + {}; + + + template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3> + struct funop4 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list5< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) + }; + return that; + } + }; + + + template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3, typename This, typename Domain> + struct funop<Expr(A0 , A1 , A2 , A3), This, Domain> + : funop4< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type + > + {}; + + + template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct funop5 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list6< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) + }; + return that; + } + }; + + + template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename This, typename Domain> + struct funop<Expr(A0 , A1 , A2 , A3 , A4), This, Domain> + : funop5< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type + > + {}; + + + template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct funop6 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list7< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) + }; + return that; + } + }; + + + template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename This, typename Domain> + struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5), This, Domain> + : funop6< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type + > + {}; + + + template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct funop7 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list8< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) + }; + return that; + } + }; + + + template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename This, typename Domain> + struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6), This, Domain> + : funop7< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type + > + {}; + + + template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct funop8 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list9< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) + }; + return that; + } + }; + + + template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename This, typename Domain> + struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), This, Domain> + : funop8< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type + > + {}; + + + template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct funop9 + { + typedef typename proto::base_expr< + Domain + , tag::function + , list10< + Expr & + , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type , typename proto::result_of::as_child<A8, Domain>::type + > + >::type type; + BOOST_FORCEINLINE + static type const call( + Expr &e + , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 + ) + { + type that = { + e + , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) , proto::as_child<Domain>(a8) + }; + return that; + } + }; + + + template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename This, typename Domain> + struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), This, Domain> + : funop9< + typename detail::same_cv<Expr, This>::type + , Domain + , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type + > + {}; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/generate_by_value.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/generate_by_value.hpp new file mode 100644 index 0000000..4494ba1 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/generate_by_value.hpp @@ -0,0 +1,487 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file generate_by_value.hpp + /// Contains definition of by_value_generator_\<\> 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 Tag , typename Arg0 > + struct by_value_generator_< + proto::expr<Tag, list1<Arg0>, 1> + > + { + typedef + list1<Arg0> + src_args; + typedef + list1< + typename uncvref<Arg0 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 1> src_type; + typedef proto::expr<Tag, dst_args, 1> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 + }; + return that; + } + }; + template<typename Tag , typename Arg0 > + struct by_value_generator_< + proto::basic_expr<Tag, list1<Arg0>, 1> + > + { + typedef + list1<Arg0> + src_args; + typedef + list1< + typename uncvref<Arg0 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 1> src_type; + typedef proto::basic_expr<Tag, dst_args, 1> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 > + struct by_value_generator_< + proto::expr<Tag, list2<Arg0 , Arg1>, 2> + > + { + typedef + list2<Arg0 , Arg1> + src_args; + typedef + list2< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 2> src_type; + typedef proto::expr<Tag, dst_args, 2> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 > + struct by_value_generator_< + proto::basic_expr<Tag, list2<Arg0 , Arg1>, 2> + > + { + typedef + list2<Arg0 , Arg1> + src_args; + typedef + list2< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 2> src_type; + typedef proto::basic_expr<Tag, dst_args, 2> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 > + struct by_value_generator_< + proto::expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3> + > + { + typedef + list3<Arg0 , Arg1 , Arg2> + src_args; + typedef + list3< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 3> src_type; + typedef proto::expr<Tag, dst_args, 3> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 > + struct by_value_generator_< + proto::basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3> + > + { + typedef + list3<Arg0 , Arg1 , Arg2> + src_args; + typedef + list3< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 3> src_type; + typedef proto::basic_expr<Tag, dst_args, 3> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 > + struct by_value_generator_< + proto::expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4> + > + { + typedef + list4<Arg0 , Arg1 , Arg2 , Arg3> + src_args; + typedef + list4< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 4> src_type; + typedef proto::expr<Tag, dst_args, 4> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 > + struct by_value_generator_< + proto::basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4> + > + { + typedef + list4<Arg0 , Arg1 , Arg2 , Arg3> + src_args; + typedef + list4< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 4> src_type; + typedef proto::basic_expr<Tag, dst_args, 4> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 > + struct by_value_generator_< + proto::expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5> + > + { + typedef + list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> + src_args; + typedef + list5< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 5> src_type; + typedef proto::expr<Tag, dst_args, 5> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 > + struct by_value_generator_< + proto::basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5> + > + { + typedef + list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> + src_args; + typedef + list5< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 5> src_type; + typedef proto::basic_expr<Tag, dst_args, 5> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 > + struct by_value_generator_< + proto::expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6> + > + { + typedef + list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> + src_args; + typedef + list6< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 6> src_type; + typedef proto::expr<Tag, dst_args, 6> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 > + struct by_value_generator_< + proto::basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6> + > + { + typedef + list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> + src_args; + typedef + list6< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 6> src_type; + typedef proto::basic_expr<Tag, dst_args, 6> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 > + struct by_value_generator_< + proto::expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7> + > + { + typedef + list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> + src_args; + typedef + list7< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 7> src_type; + typedef proto::expr<Tag, dst_args, 7> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 > + struct by_value_generator_< + proto::basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7> + > + { + typedef + list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> + src_args; + typedef + list7< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 7> src_type; + typedef proto::basic_expr<Tag, dst_args, 7> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 > + struct by_value_generator_< + proto::expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8> + > + { + typedef + list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> + src_args; + typedef + list8< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 8> src_type; + typedef proto::expr<Tag, dst_args, 8> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 > + struct by_value_generator_< + proto::basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8> + > + { + typedef + list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> + src_args; + typedef + list8< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 8> src_type; + typedef proto::basic_expr<Tag, dst_args, 8> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 > + struct by_value_generator_< + proto::expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9> + > + { + typedef + list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> + src_args; + typedef + list9< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 9> src_type; + typedef proto::expr<Tag, dst_args, 9> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 > + struct by_value_generator_< + proto::basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9> + > + { + typedef + list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> + src_args; + typedef + list9< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 9> src_type; + typedef proto::basic_expr<Tag, dst_args, 9> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 > + struct by_value_generator_< + proto::expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10> + > + { + typedef + list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> + src_args; + typedef + list10< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type + > + dst_args; + typedef proto::expr<Tag, src_args, 10> src_type; + typedef proto::expr<Tag, dst_args, 10> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9 + }; + return that; + } + }; + template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 > + struct by_value_generator_< + proto::basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10> + > + { + typedef + list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> + src_args; + typedef + list10< + typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type + > + dst_args; + typedef proto::basic_expr<Tag, src_args, 10> src_type; + typedef proto::basic_expr<Tag, dst_args, 10> type; + BOOST_FORCEINLINE + static type const call(src_type const &e) + { + type that = { + e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9 + }; + return that; + } + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/lambda_matches.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/lambda_matches.hpp new file mode 100644 index 0000000..e9b166d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/lambda_matches.hpp @@ -0,0 +1,142 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file lambda_matches.hpp + /// Specializations of the lambda_matches 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< + template<typename , typename> class T + , typename Expr0 , typename Expr1 + , typename Grammar0 , typename Grammar1 + > + struct lambda_matches< + T<Expr0 , Expr1> + , T<Grammar0 , Grammar1> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(2) + > + : and_2< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > + > + {}; + template< + template<typename , typename , typename> class T + , typename Expr0 , typename Expr1 , typename Expr2 + , typename Grammar0 , typename Grammar1 , typename Grammar2 + > + struct lambda_matches< + T<Expr0 , Expr1 , Expr2> + , T<Grammar0 , Grammar1 , Grammar2> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(3) + > + : and_3< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > + > + {}; + template< + template<typename , typename , typename , typename> class T + , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 + , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 + > + struct lambda_matches< + T<Expr0 , Expr1 , Expr2 , Expr3> + , T<Grammar0 , Grammar1 , Grammar2 , Grammar3> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(4) + > + : and_4< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > + > + {}; + template< + template<typename , typename , typename , typename , typename> class T + , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 + , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 + > + struct lambda_matches< + T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4> + , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(5) + > + : and_5< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > + > + {}; + template< + template<typename , typename , typename , typename , typename , typename> class T + , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 + , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 + > + struct lambda_matches< + T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5> + , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(6) + > + : and_6< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename> class T + , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 + , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 + > + struct lambda_matches< + T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6> + , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(7) + > + : and_7< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename> class T + , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 + , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 + > + struct lambda_matches< + T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7> + , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(8) + > + : and_8< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T + , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8 + , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8 + > + struct lambda_matches< + T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8> + , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(9) + > + : and_9< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 > + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T + , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8 , typename Expr9 + , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8 , typename Grammar9 + > + struct lambda_matches< + T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8 , Expr9> + , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8 , Grammar9> + BOOST_PROTO_TEMPLATE_ARITY_PARAM(10) + > + : and_10< + lambda_matches< Expr0 , Grammar0 >::value, + lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 > , lambda_matches< Expr9 , Grammar9 > + > + {}; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr.hpp new file mode 100644 index 0000000..aeccb3d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr.hpp @@ -0,0 +1,331 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file make_expr.hpp + /// Contains overloads of make_expr() free function. + // + // 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 Tag , typename A0 , typename A1> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 + >()(a0 , a1); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 + >::type const + make_expr(const C0 &c0 , const C1 &c1) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 + >()(c0 , c1); + } + + + template<typename Tag , typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 , const A2 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 , const A2 + >()(a0 , a1 , a2); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 , const C2 + >::type const + make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 , const C2 + >()(c0 , c1 , c2); + } + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 , const A2 , const A3 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 , const A2 , const A3 + >()(a0 , a1 , a2 , a3); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 + >::type const + make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 + >()(c0 , c1 , c2 , c3); + } + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 , const A2 , const A3 , const A4 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 , const A2 , const A3 , const A4 + >()(a0 , a1 , a2 , a3 , a4); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 + >::type const + make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 + >()(c0 , c1 , c2 , c3 , c4); + } + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >()(a0 , a1 , a2 , a3 , a4 , a5); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 + >::type const + make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 + >()(c0 , c1 , c2 , c3 , c4 , c5); + } + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >()(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 + >::type const + make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 + >()(c0 , c1 , c2 , c3 , c4 , c5 , c6); + } + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 + >::type const + make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 + >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7); + } + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 + >::type const + make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 + >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8); + } + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9 + > + >::type const + make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9 + >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } + + + template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9 + >::type const + make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8 , const C9 &c9) + { + return proto::detail::make_expr_< + Tag + , Domain + , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9 + >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9); + } diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr_.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr_.hpp new file mode 100644 index 0000000..7349cc9 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr_.hpp @@ -0,0 +1,331 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file make_expr_.hpp + /// Contains definition of make_expr_\<\> 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 Tag + , typename Domain + , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void + , typename _ = void + > + struct make_expr_ + {}; + template<typename Domain, typename A> + struct make_expr_<tag::terminal, Domain, A + , void , void , void , void , void , void , void , void , void , void> + { + typedef typename proto::detail::protoify<A, Domain>::result_type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A>::type a) const + { + return proto::detail::protoify<A, Domain>()(a); + } + }; + template<typename A> + struct make_expr_<tag::terminal, deduce_domain, A + , void , void , void , void , void , void , void , void , void , void> + : make_expr_<tag::terminal, default_domain, A> + {}; + template<typename Tag, typename Domain , typename A0> + struct make_expr_<Tag, Domain , A0 + , void , void , void , void , void , void , void , void , void, void> + { + typedef + list1< + typename boost::proto::detail::protoify< A0 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0> + struct make_expr_<Tag, deduce_domain , A0 + , void , void , void , void , void , void , void , void , void, void> + : make_expr_< + Tag + , typename deduce_domain1<A0>::type + , A0 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1> + struct make_expr_<Tag, Domain , A0 , A1 + , void , void , void , void , void , void , void , void, void> + { + typedef + list2< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1> + struct make_expr_<Tag, deduce_domain , A0 , A1 + , void , void , void , void , void , void , void , void, void> + : make_expr_< + Tag + , typename deduce_domain2<A0 , A1>::type + , A0 , A1 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2> + struct make_expr_<Tag, Domain , A0 , A1 , A2 + , void , void , void , void , void , void , void, void> + { + typedef + list3< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1 , typename A2> + struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 + , void , void , void , void , void , void , void, void> + : make_expr_< + Tag + , typename deduce_domain3<A0 , A1 , A2>::type + , A0 , A1 , A2 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3> + struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 + , void , void , void , void , void , void, void> + { + typedef + list4< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3> + struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 + , void , void , void , void , void , void, void> + : make_expr_< + Tag + , typename deduce_domain4<A0 , A1 , A2 , A3>::type + , A0 , A1 , A2 , A3 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 + , void , void , void , void , void, void> + { + typedef + list5< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 + , void , void , void , void , void, void> + : make_expr_< + Tag + , typename deduce_domain5<A0 , A1 , A2 , A3 , A4>::type + , A0 , A1 , A2 , A3 , A4 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 + , void , void , void , void, void> + { + typedef + list6< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 + , void , void , void , void, void> + : make_expr_< + Tag + , typename deduce_domain6<A0 , A1 , A2 , A3 , A4 , A5>::type + , A0 , A1 , A2 , A3 , A4 , A5 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 + , void , void , void, void> + { + typedef + list7< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 + , void , void , void, void> + : make_expr_< + Tag + , typename deduce_domain7<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + , void , void, void> + { + typedef + list8< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + , void , void, void> + : make_expr_< + Tag + , typename deduce_domain8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + , void, void> + { + typedef + list9< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + , void, void> + : make_expr_< + Tag + , typename deduce_domain9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + > + {}; + template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 + , void> + { + typedef + list10< + typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type , typename boost::proto::detail::protoify< A9 , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8 , typename add_reference<A9 >::type a9) const + { + expr_type const that = { + boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) , boost::proto::detail::protoify< A9 , Domain >()(a9) + }; + return proto_generator()(that); + } + }; + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 + , void> + : make_expr_< + Tag + , typename deduce_domain10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 + > + {}; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr_funop.hpp new file mode 100644 index 0000000..0f87a15 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/make_expr_funop.hpp @@ -0,0 +1,259 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file make_expr_funop.hpp + /// Contains definition of make_expr\<\>::operator() member functions. + // + // 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 This , typename A0 , typename A1> + struct result<This(A0 , A1)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 + >::type + type; + }; + + + template<typename A0 , typename A1> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 + >::type const + operator ()(const A0 &a0 , const A1 &a1) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 + >()(a0 , a1); + } + template<typename This , typename A0 , typename A1 , typename A2> + struct result<This(A0 , A1 , A2)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 , A2 + >::type + type; + }; + + + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 , const A2 + >::type const + operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 , const A2 + >()(a0 , a1 , a2); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3> + struct result<This(A0 , A1 , A2 , A3)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 , A2 , A3 + >::type + type; + }; + + + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 + >::type const + operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 + >()(a0 , a1 , a2 , a3); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct result<This(A0 , A1 , A2 , A3 , A4)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 , A2 , A3 , A4 + >::type + type; + }; + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 + >::type const + operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 + >()(a0 , a1 , a2 , a3 , a4); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 , A2 , A3 , A4 , A5 + >::type + type; + }; + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >::type const + operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 + >()(a0 , a1 , a2 , a3 , a4 , a5); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + >::type + type; + }; + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >::type const + operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 + >()(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + >::type + type; + }; + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >::type const + operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 + >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + >::type + type; + }; + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >::type const + operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 + >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 + >::type + type; + }; + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9 + >::type const + operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9) const + { + return proto::detail::make_expr_< + Tag + , Domain + , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9 + >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/matches_.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/matches_.hpp new file mode 100644 index 0000000..5fa273f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/matches_.hpp @@ -0,0 +1,277 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file matches_.hpp + /// Definitions of matches_ specializations + // + // 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 BasicExpr , typename G0 , typename G1> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1> > + : or_2< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1> > + : detail::and_2< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<Tag, Args2, 2> > + : and_2< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<proto::_, Args2, 2> > + : and_2< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > + > + {}; + + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2> > + : or_3< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 , G2 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2> > + : detail::and_3< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<Tag, Args2, 3> > + : and_3< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<proto::_, Args2, 3> > + : and_3< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > + > + {}; + + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3> > + : or_4< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 , G2 , G3 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3> > + : detail::and_4< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<Tag, Args2, 4> > + : and_4< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<proto::_, Args2, 4> > + : and_4< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > + > + {}; + + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4> > + : or_5< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4> > + : detail::and_5< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<Tag, Args2, 5> > + : and_5< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<proto::_, Args2, 5> > + : and_5< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > + > + {}; + + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5> > + : or_6< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5> > + : detail::and_6< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<Tag, Args2, 6> > + : and_6< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<proto::_, Args2, 6> > + : and_6< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > + > + {}; + + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6> > + : or_7< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6> > + : detail::and_7< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<Tag, Args2, 7> > + : and_7< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<proto::_, Args2, 7> > + : and_7< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > + > + {}; + + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> > + : or_8< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> > + : detail::and_8< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<Tag, Args2, 8> > + : and_8< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<proto::_, Args2, 8> > + : and_8< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > + > + {}; + + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> > + : or_9< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> > + : detail::and_9< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<Tag, Args2, 9> > + : and_9< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<proto::_, Args2, 9> > + : and_9< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > + > + {}; + + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9> + struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> > + : or_10< + matches_<Expr, BasicExpr, typename G0::proto_grammar>::value, + Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9 + > + {}; + + template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9> + struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> > + : detail::and_10< + matches_< Expr , BasicExpr , typename G0::proto_grammar >::value, + matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar > , matches_< Expr , BasicExpr , typename G9::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<Tag, Args2, 10> > + : and_10< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar > + > + {}; + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<proto::_, Args2, 10> > + : and_10< + matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value, + matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar > + > + {}; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/memfun_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/memfun_funop.hpp new file mode 100644 index 0000000..3449160 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/memfun_funop.hpp @@ -0,0 +1,77 @@ + /////////////////////////////////////////////////////////////////////////////// + // memfun_funop.hpp + // Contains overloads of memfun::operator(). + // + // 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 A0> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0); + } + template<typename A0 , typename A1> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1); + } + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2); + } + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const + { + BOOST_PROTO_USE_GET_POINTER(); + return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/or_n.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/or_n.hpp new file mode 100644 index 0000000..c0cd7c3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/or_n.hpp @@ -0,0 +1,123 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file or_n.hpp + /// Definitions of or_N + // + // 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<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1> + struct or_2 + : mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value> + { + typedef G1 which; + }; + template<typename Expr, typename BasicExpr , typename G0 , typename G1> + struct or_2<true, Expr, BasicExpr, G0 , G1> + : mpl::true_ + { + typedef G0 which; + }; + template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2> + struct or_3 + : or_2< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, G1 , G2 + > + {}; + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2> + struct or_3<true, Expr, BasicExpr, G0 , G1 , G2> + : mpl::true_ + { + typedef G0 which; + }; + template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3> + struct or_4 + : or_3< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, G1 , G2 , G3 + > + {}; + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3> + struct or_4<true, Expr, BasicExpr, G0 , G1 , G2 , G3> + : mpl::true_ + { + typedef G0 which; + }; + template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4> + struct or_5 + : or_4< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, G1 , G2 , G3 , G4 + > + {}; + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4> + struct or_5<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4> + : mpl::true_ + { + typedef G0 which; + }; + template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5> + struct or_6 + : or_5< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 + > + {}; + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5> + struct or_6<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5> + : mpl::true_ + { + typedef G0 which; + }; + template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6> + struct or_7 + : or_6< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 + > + {}; + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6> + struct or_7<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6> + : mpl::true_ + { + typedef G0 which; + }; + template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7> + struct or_8 + : or_7< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 + > + {}; + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7> + struct or_8<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> + : mpl::true_ + { + typedef G0 which; + }; + template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8> + struct or_9 + : or_8< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 + > + {}; + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8> + struct or_9<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> + : mpl::true_ + { + typedef G0 which; + }; + template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9> + struct or_10 + : or_9< + matches_<Expr, BasicExpr, typename G1::proto_grammar>::value + , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9 + > + {}; + template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9> + struct or_10<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> + : mpl::true_ + { + typedef G0 which; + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/poly_function_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/poly_function_funop.hpp new file mode 100644 index 0000000..9c476ce --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/poly_function_funop.hpp @@ -0,0 +1,237 @@ + /////////////////////////////////////////////////////////////////////////////// + // poly_function_funop.hpp + // Contains overloads of poly_function\<\>::operator() + // + // 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 This , typename A0> + struct result<This(A0)> + : Derived::template impl< + typename normalize_arg<A0 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0> + typename result< + Derived const( + A0 const & + ) + >::type + operator ()(A0 const &a0) const + { + result< + Derived const( + A0 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0)); + } + template<typename This , typename A0 , typename A1> + struct result<This(A0 , A1)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1> + typename result< + Derived const( + A0 const & , A1 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1) const + { + result< + Derived const( + A0 const & , A1 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1)); + } + template<typename This , typename A0 , typename A1 , typename A2> + struct result<This(A0 , A1 , A2)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1 , typename A2> + typename result< + Derived const( + A0 const & , A1 const & , A2 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const + { + result< + Derived const( + A0 const & , A1 const & , A2 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2)); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3> + struct result<This(A0 , A1 , A2 , A3)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1 , typename A2 , typename A3> + typename result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const + { + result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3)); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct result<This(A0 , A1 , A2 , A3 , A4)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + typename result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const + { + result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4)); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + typename result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const + { + result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5)); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + typename result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const + { + result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6)); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + typename result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const + { + result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7)); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + typename result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const + { + result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8)); + } + template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : Derived::template impl< + typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type , typename normalize_arg<A9 >::type + > + { + typedef typename result::result_type type; + }; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + typename result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const & + ) + >::type + operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const + { + result< + Derived const( + A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const & + ) + > impl; + return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8) , static_cast<typename normalize_arg<A9 const &> ::reference>(a9)); + } diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/poly_function_traits.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/poly_function_traits.hpp new file mode 100644 index 0000000..1ef1c36 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/poly_function_traits.hpp @@ -0,0 +1,247 @@ + /////////////////////////////////////////////////////////////////////////////// + // poly_function_traits.hpp + // Contains specializations of poly_function_traits and as_mono_function + // + // 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 PolyFun , typename A0> + struct poly_function_traits<PolyFun, PolyFun(A0), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0> + struct as_mono_function_impl<PolyFun(A0), true> + { + typedef typename PolyFun::template impl<const A0> type; + }; + + template<typename PolyFun , typename A0> + struct as_mono_function_impl<PolyFun(A0), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0> + struct as_mono_function<PolyFun(A0)> + : as_mono_function_impl<PolyFun(A0), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1> + struct as_mono_function_impl<PolyFun(A0 , A1), true> + { + typedef typename PolyFun::template impl<const A0 , const A1> type; + }; + + template<typename PolyFun , typename A0 , typename A1> + struct as_mono_function_impl<PolyFun(A0 , A1), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1> + struct as_mono_function<PolyFun(A0 , A1)> + : as_mono_function_impl<PolyFun(A0 , A1), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1 , typename A2> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2), true> + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2> type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2> + struct as_mono_function<PolyFun(A0 , A1 , A2)> + : as_mono_function_impl<PolyFun(A0 , A1 , A2), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), true> + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3> + struct as_mono_function<PolyFun(A0 , A1 , A2 , A3)> + : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), true> + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4)> + : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), true> + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5)> + : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), true> + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), true> + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), true> + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), is_poly_function<PolyFun>::value> + {}; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), mpl::size_t<sizeof(poly_function_t)> > + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> function_type; + typedef typename function_type::result_type result_type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), true> + { + typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), false> + { + typedef PolyFun type; + }; + + template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), is_poly_function<PolyFun>::value> + {}; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/template_arity_helper.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/template_arity_helper.hpp new file mode 100644 index 0000000..d295c66 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/template_arity_helper.hpp @@ -0,0 +1,67 @@ + /////////////////////////////////////////////////////////////////////////////// + // template_arity_helper.hpp + // Overloads of template_arity_helper, used by the template_arity\<\> 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< + template<typename P0> class F + , typename T0 + > + sized_type<2>::type + template_arity_helper(F<T0> **, mpl::int_<1> *); + template< + template<typename P0 , typename P1> class F + , typename T0 , typename T1 + > + sized_type<3>::type + template_arity_helper(F<T0 , T1> **, mpl::int_<2> *); + template< + template<typename P0 , typename P1 , typename P2> class F + , typename T0 , typename T1 , typename T2 + > + sized_type<4>::type + template_arity_helper(F<T0 , T1 , T2> **, mpl::int_<3> *); + template< + template<typename P0 , typename P1 , typename P2 , typename P3> class F + , typename T0 , typename T1 , typename T2 , typename T3 + > + sized_type<5>::type + template_arity_helper(F<T0 , T1 , T2 , T3> **, mpl::int_<4> *); + template< + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4> class F + , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 + > + sized_type<6>::type + template_arity_helper(F<T0 , T1 , T2 , T3 , T4> **, mpl::int_<5> *); + template< + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> class F + , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 + > + sized_type<7>::type + template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5> **, mpl::int_<6> *); + template< + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> class F + , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 + > + sized_type<8>::type + template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6> **, mpl::int_<7> *); + template< + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> class F + , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 + > + sized_type<9>::type + template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> **, mpl::int_<8> *); + template< + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> class F + , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 + > + sized_type<10>::type + template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> **, mpl::int_<9> *); + template< + template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8 , typename P9> class F + , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 + > + sized_type<11>::type + template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> **, mpl::int_<10> *); diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/traits.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/traits.hpp new file mode 100644 index 0000000..abbb5a7 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/traits.hpp @@ -0,0 +1,1486 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file traits.hpp + /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c + // + // 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 result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 0> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child0 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child0>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 0> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child0 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child0>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child0; + } + }; + template<typename Expr> + struct child_c<Expr const &, 0> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child0 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child0>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child0; + } + }; + } + + + + + template<typename A0> + struct function + < + A0 + , void , void , void , void , void , void , void , void , void + > + : proto::transform< + function< + A0 + , void , void , void , void , void , void , void , void , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list1<A0>, 1> type; + typedef proto::basic_expr<proto::tag::function, list1<A0>, 1> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; + typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0> + struct nary_expr + < + Tag + , A0 + , void , void , void , void , void , void , void , void , void + > + : proto::transform< + nary_expr< + Tag + , A0 + , void , void , void , void , void , void , void , void , void + > + , int + > + { + typedef proto::expr<Tag, list1<A0>, 1> type; + typedef proto::basic_expr<Tag, list1<A0>, 1> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; + typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9; + }; + namespace detail + { + template< + template<typename> class T + , typename A0 + > + struct is_callable_<T<A0> BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)> + : is_same<A0, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 1> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child1 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child1>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 1> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child1 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child1>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child1; + } + }; + template<typename Expr> + struct child_c<Expr const &, 1> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child1 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child1>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child1; + } + }; + } + + + + + template<typename A0 , typename A1> + struct function + < + A0 , A1 + , void , void , void , void , void , void , void , void + > + : proto::transform< + function< + A0 , A1 + , void , void , void , void , void , void , void , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list2<A0 , A1>, 2> type; + typedef proto::basic_expr<proto::tag::function, list2<A0 , A1>, 2> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; + typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1> + struct nary_expr + < + Tag + , A0 , A1 + , void , void , void , void , void , void , void , void + > + : proto::transform< + nary_expr< + Tag + , A0 , A1 + , void , void , void , void , void , void , void , void + > + , int + > + { + typedef proto::expr<Tag, list2<A0 , A1>, 2> type; + typedef proto::basic_expr<Tag, list2<A0 , A1>, 2> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; + typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9; + }; + namespace detail + { + template< + template<typename , typename> class T + , typename A0 , typename A1 + > + struct is_callable_<T<A0 , A1> BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)> + : is_same<A1, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 2> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child2 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child2>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 2> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child2 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child2>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child2; + } + }; + template<typename Expr> + struct child_c<Expr const &, 2> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child2 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child2>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child2; + } + }; + } + + + + + template<typename A0 , typename A1 , typename A2> + struct function + < + A0 , A1 , A2 + , void , void , void , void , void , void , void + > + : proto::transform< + function< + A0 , A1 , A2 + , void , void , void , void , void , void , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list3<A0 , A1 , A2>, 3> type; + typedef proto::basic_expr<proto::tag::function, list3<A0 , A1 , A2>, 3> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; + typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1 , typename A2> + struct nary_expr + < + Tag + , A0 , A1 , A2 + , void , void , void , void , void , void , void + > + : proto::transform< + nary_expr< + Tag + , A0 , A1 , A2 + , void , void , void , void , void , void , void + > + , int + > + { + typedef proto::expr<Tag, list3<A0 , A1 , A2>, 3> type; + typedef proto::basic_expr<Tag, list3<A0 , A1 , A2>, 3> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; + typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9; + }; + namespace detail + { + template< + template<typename , typename , typename> class T + , typename A0 , typename A1 , typename A2 + > + struct is_callable_<T<A0 , A1 , A2> BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)> + : is_same<A2, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 3> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child3 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child3>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 3> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child3 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child3>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child3; + } + }; + template<typename Expr> + struct child_c<Expr const &, 3> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child3 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child3>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child3; + } + }; + } + + + + + template<typename A0 , typename A1 , typename A2 , typename A3> + struct function + < + A0 , A1 , A2 , A3 + , void , void , void , void , void , void + > + : proto::transform< + function< + A0 , A1 , A2 , A3 + , void , void , void , void , void , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> type; + typedef proto::basic_expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; + typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3> + struct nary_expr + < + Tag + , A0 , A1 , A2 , A3 + , void , void , void , void , void , void + > + : proto::transform< + nary_expr< + Tag + , A0 , A1 , A2 , A3 + , void , void , void , void , void , void + > + , int + > + { + typedef proto::expr<Tag, list4<A0 , A1 , A2 , A3>, 4> type; + typedef proto::basic_expr<Tag, list4<A0 , A1 , A2 , A3>, 4> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; + typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9; + }; + namespace detail + { + template< + template<typename , typename , typename , typename> class T + , typename A0 , typename A1 , typename A2 , typename A3 + > + struct is_callable_<T<A0 , A1 , A2 , A3> BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)> + : is_same<A3, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 4> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child4 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child4>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 4> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child4 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child4>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child4; + } + }; + template<typename Expr> + struct child_c<Expr const &, 4> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child4 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child4>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child4; + } + }; + } + + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct function + < + A0 , A1 , A2 , A3 , A4 + , void , void , void , void , void + > + : proto::transform< + function< + A0 , A1 , A2 , A3 , A4 + , void , void , void , void , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> type; + typedef proto::basic_expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; + typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct nary_expr + < + Tag + , A0 , A1 , A2 , A3 , A4 + , void , void , void , void , void + > + : proto::transform< + nary_expr< + Tag + , A0 , A1 , A2 , A3 , A4 + , void , void , void , void , void + > + , int + > + { + typedef proto::expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> type; + typedef proto::basic_expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; + typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename> class T + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 + > + struct is_callable_<T<A0 , A1 , A2 , A3 , A4> BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)> + : is_same<A4, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 5> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child5 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child5>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 5> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child5 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child5>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child5; + } + }; + template<typename Expr> + struct child_c<Expr const &, 5> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child5 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child5>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child5; + } + }; + } + + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct function + < + A0 , A1 , A2 , A3 , A4 , A5 + , void , void , void , void + > + : proto::transform< + function< + A0 , A1 , A2 , A3 , A4 , A5 + , void , void , void , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type; + typedef proto::basic_expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; + typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct nary_expr + < + Tag + , A0 , A1 , A2 , A3 , A4 , A5 + , void , void , void , void + > + : proto::transform< + nary_expr< + Tag + , A0 , A1 , A2 , A3 , A4 , A5 + , void , void , void , void + > + , int + > + { + typedef proto::expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type; + typedef proto::basic_expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; + typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename> class T + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 + > + struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5> BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)> + : is_same<A5, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 6> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child6 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child6>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 6> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child6 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child6>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child6; + } + }; + template<typename Expr> + struct child_c<Expr const &, 6> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child6 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child6>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child6; + } + }; + } + + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct function + < + A0 , A1 , A2 , A3 , A4 , A5 , A6 + , void , void , void + > + : proto::transform< + function< + A0 , A1 , A2 , A3 , A4 , A5 , A6 + , void , void , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type; + typedef proto::basic_expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; + typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct nary_expr + < + Tag + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + , void , void , void + > + : proto::transform< + nary_expr< + Tag + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + , void , void , void + > + , int + > + { + typedef proto::expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type; + typedef proto::basic_expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; + typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename> class T + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 + > + struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6> BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)> + : is_same<A6, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 7> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child7 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child7>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 7> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child7 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child7>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child7; + } + }; + template<typename Expr> + struct child_c<Expr const &, 7> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child7 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child7>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child7; + } + }; + } + + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct function + < + A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + , void , void + > + : proto::transform< + function< + A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + , void , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type; + typedef proto::basic_expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; + typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct nary_expr + < + Tag + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + , void , void + > + : proto::transform< + nary_expr< + Tag + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + , void , void + > + , int + > + { + typedef proto::expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type; + typedef proto::basic_expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; + typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename> class T + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 + > + struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)> + : is_same<A7, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 8> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child8 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child8>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 8> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child8 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child8>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child8; + } + }; + template<typename Expr> + struct child_c<Expr const &, 8> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child8 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child8>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child8; + } + }; + } + + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct function + < + A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + , void + > + : proto::transform< + function< + A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + , void + > + , int + > + { + typedef proto::expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type; + typedef proto::basic_expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; + typedef detail::if_vararg<A8> proto_child9; + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct nary_expr + < + Tag + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + , void + > + : proto::transform< + nary_expr< + Tag + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + , void + > + , int + > + { + typedef proto::expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type; + typedef proto::basic_expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; + typedef detail::if_vararg<A8> proto_child9; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 + > + struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)> + : is_same<A8, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 9> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child9 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child9>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 9> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child9 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child9>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child9; + } + }; + template<typename Expr> + struct child_c<Expr const &, 9> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child9 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child9>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child9; + } + }; + } + + + + + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct function + : proto::transform< + function< + A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 + + > + , int + > + { + typedef proto::expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type; + typedef proto::basic_expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + typedef proto::tag::function proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9; + + }; + + + + + + + + + template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct nary_expr + : proto::transform< + nary_expr< + Tag + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 + + > + , int + > + { + typedef proto::expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type; + typedef proto::basic_expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar; + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + typedef Tag proto_tag; + typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9; + + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 + > + struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)> + : is_same<A9, callable> + {}; + } + namespace result_of + { + + + + + + + template<typename Expr> + struct child_c<Expr, 10> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child10 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child10>::value_type type; + }; + template<typename Expr> + struct child_c<Expr &, 10> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child10 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child10>::reference type; + + + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().child10; + } + }; + template<typename Expr> + struct child_c<Expr const &, 10> + { + + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + + typedef typename Expr::proto_child10 value_type; + + + + + + typedef typename detail::expr_traits<typename Expr::proto_child10>::const_reference type; + + + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().child10; + } + }; + } diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/unpack_expr_.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/unpack_expr_.hpp new file mode 100644 index 0000000..68b4bf4 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/unpack_expr_.hpp @@ -0,0 +1,466 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file make_expr_.hpp + /// Contains definition of make_expr_\<\> 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 Tag, typename Domain, typename Sequence, std::size_t Size> + struct unpack_expr_ + {}; + template<typename Domain, typename Sequence> + struct unpack_expr_<tag::terminal, Domain, Sequence, 1u> + { + typedef + typename add_const< + typename fusion::result_of::value_of< + typename fusion::result_of::begin<Sequence>::type + >::type + >::type + terminal_type; + typedef + typename proto::detail::protoify< + terminal_type + , Domain + >::result_type + type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence)); + } + }; + template<typename Sequence> + struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u> + : unpack_expr_<tag::terminal, default_domain, Sequence, 1u> + {}; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 1> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; + typedef + list1< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 1> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; + typedef + unpack_expr_< + Tag + , typename deduce_domain1< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type + >::type + , Sequence + , 1 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 2> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; + typedef + list2< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 2> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; + typedef + unpack_expr_< + Tag + , typename deduce_domain2< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type + >::type + , Sequence + , 2 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 3> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; + typedef + list3< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 3> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; + typedef + unpack_expr_< + Tag + , typename deduce_domain3< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type + >::type + , Sequence + , 3 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 4> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; + typedef + list4< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 4> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; + typedef + unpack_expr_< + Tag + , typename deduce_domain4< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type + >::type + , Sequence + , 4 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 5> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; + typedef + list5< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 5> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; + typedef + unpack_expr_< + Tag + , typename deduce_domain5< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type + >::type + , Sequence + , 5 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 6> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; + typedef + list6< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 6> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; + typedef + unpack_expr_< + Tag + , typename deduce_domain6< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type + >::type + , Sequence + , 6 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 7> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; + typedef + list7< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 7> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; + typedef + unpack_expr_< + Tag + , typename deduce_domain7< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type + >::type + , Sequence + , 7 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 8> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; + typedef + list8< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 8> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; + typedef + unpack_expr_< + Tag + , typename deduce_domain8< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type + >::type + , Sequence + , 8 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 9> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; + typedef + list9< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 9> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; + typedef + unpack_expr_< + Tag + , typename deduce_domain9< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type + >::type + , Sequence + , 9 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, 10> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9; + typedef + list10< + typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >::result_type + > + proto_args; + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7); fusion_iterator9 it9 = fusion::next(it8); + expr_type const that = { + detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >()(*it9) + }; + return proto_generator()(that); + } + }; + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, 10> + { + typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9; + typedef + unpack_expr_< + Tag + , typename deduce_domain10< + typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type + >::type + , Sequence + , 10 + > + other; + typedef typename other::type type; + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/detail/preprocessed/vararg_matches_impl.hpp b/3rdParty/Boost/src/boost/proto/detail/preprocessed/vararg_matches_impl.hpp new file mode 100644 index 0000000..294a4c2 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/preprocessed/vararg_matches_impl.hpp @@ -0,0 +1,178 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file vararg_matches_impl.hpp + /// Specializations of the vararg_matches_impl 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 Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 2, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 2 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 2, 2> + : matches_< + typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar + , Back + > + {}; + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 3, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 3 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 3, 3> + : matches_< + typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar + , Back + > + {}; + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 4, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 4 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 4, 4> + : matches_< + typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar + , Back + > + {}; + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 5, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 5 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 5, 5> + : matches_< + typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar + , Back + > + {}; + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 6, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 6 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 6, 6> + : matches_< + typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar + , Back + > + {}; + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 7, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 7 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 7, 7> + : matches_< + typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar + , Back + > + {}; + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 8, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 8 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 8, 8> + : matches_< + typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar + , Back + > + {}; + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 9, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 9 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 9, 9> + : matches_< + typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar + , Back + > + {}; + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, 10, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, 10 + 1, To> + > + {}; + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, 10, 10> + : matches_< + typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar + , Back + > + {}; diff --git a/3rdParty/Boost/src/boost/proto/detail/remove_typename.hpp b/3rdParty/Boost/src/boost/proto/detail/remove_typename.hpp new file mode 100644 index 0000000..fdbe98e --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/remove_typename.hpp @@ -0,0 +1,82 @@ +//============================================================================== +// Copyright 2003 - 2011 LASMEA UMR 6602 CNRS/Univ. Clermont II +// Copyright 2009 - 2011 LRI UMR 8623 CNRS/Univ Paris Sud XI +// Copyright 2011 Eric Niebler +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +//============================================================================== +#ifndef BOOST_PROTO_PREPROCESSOR_REMOVE_TYPENAME_HPP_INCLUDED +#define BOOST_PROTO_PREPROCESSOR_REMOVE_TYPENAME_HPP_INCLUDED + +/*! + * \file + * \brief Defines the BOOST_PROTO_REMOVE_TYPENAME macro + */ +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/expand.hpp> +#include <boost/preprocessor/tuple/eat.hpp> +#include <boost/preprocessor/control/iif.hpp> +#include <boost/preprocessor/detail/is_unary.hpp> + +//============================================================================== +// Boost.Preprocessor author P. Mensodines confirmed on an Boost email thread +// (subject ``check if a token is a keyword (was "BOOST_PP_IS_UNARY()")'') +// that it is OK to used `PP_IS_UNARY()` to check if tokens match predefined +// "keyword" as it is done by the macros below (even if `PP_IS_UNARY()` is +// technically only part of Boost.Preprocessor private API). +//============================================================================== + +//============================================================================== +// `checking_prefix ## tokens` expand to unary (e.g., `(1)`) iff `tokens` start +// with keyword to check. +//============================================================================== +#define BOOST_PROTO_DETAILS_KEYWORD_FACILITY_IS_FRONT(T, CHECKING_PREFIX) \ + BOOST_PP_IS_UNARY(BOOST_PP_CAT(CHECKING_PREFIX, T)) \ + /**/ + +//============================================================================== +// `is_front_macro(tokens)` is 1 iff `tokens` start with keyword to remove. +// `removing_prefix ## <keyword-to-remove>` must expand to nothing. +//============================================================================== +#define BOOST_PROTO_DETAILS_KEYWORD_FACILITY_REMOVE_FRONT(TOKENS, IS_FRONT_MACRO, REMOVING_PREFIX) \ + BOOST_PP_EXPAND( /* without EXPAND doesn't expand on MSVC */ \ + BOOST_PP_IIF( \ + IS_FRONT_MACRO(TOKENS) \ + , BOOST_PP_CAT \ + , TOKENS BOOST_PP_TUPLE_EAT(2) \ + )(REMOVING_PREFIX, TOKENS) \ + ) \ + /**/ + +#define BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS_typename (1) /* unary */ +#define typename_BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS (1) /* unary */ +#define BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE_typename /* nothing */ +#define typename_BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE /* nothing */ + +#define BOOST_PROTO_DETAILS_KEYWORD_IS_TYPENAME_FRONT(TOKENS) \ + BOOST_PROTO_DETAILS_KEYWORD_FACILITY_IS_FRONT(TOKENS, BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS_) \ + /**/ + +//============================================================================== +/*! + * \ingroup preprocessor + * For any symbol \c X, this macro returns the same symbol from which a potential + * leading \c typename keyword has been removed. If no typename keyword is present, + * this macros evaluates to \c X itself without error. + * + * The original implementation of this macro is from Lorenzo Caminiti. + * + * \param X Symbol to remove \c typename from + */ +//============================================================================== +#define BOOST_PROTO_REMOVE_TYPENAME(X) \ + BOOST_PROTO_DETAILS_KEYWORD_FACILITY_REMOVE_FRONT( \ + X \ + , BOOST_PROTO_DETAILS_KEYWORD_IS_TYPENAME_FRONT \ + , BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE_ \ + ) \ + /**/ + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/static_const.hpp b/3rdParty/Boost/src/boost/proto/detail/static_const.hpp new file mode 100644 index 0000000..0dfdbc6 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/static_const.hpp @@ -0,0 +1,27 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file static_const.hpp +/// Contains definition of static_const for declaring static constants that +// +// 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_DETAIL_STATIC_CONST_HPP_EAN_20_07_2012 +#define BOOST_PROTO_DETAIL_STATIC_CONST_HPP_EAN_20_07_2012 + +namespace boost { namespace proto +{ + namespace detail + { + template<typename T> + struct static_const + { + static T const value; + }; + + template<typename T> + T const static_const<T>::value = {}; + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/template_arity.hpp b/3rdParty/Boost/src/boost/proto/detail/template_arity.hpp new file mode 100644 index 0000000..b39f7d5 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/template_arity.hpp @@ -0,0 +1,67 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file template_arity.hpp +/// Replace all nodes stored by reference by nodes stored by value. +// +// Copyright 2011 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) +// +// This file is based on a similar one in MPL from Aleksey Gurtovoy. + +#ifndef BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07 +#define BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07 + +// Somewhat indirect definition of BOOST_PROTO_TEMPLATE_ARITY_PARAM is +// to overcome a shortcoming of the Wave tool used to generate the +// pre-preprocessed headers. +#define BOOST_PROTO_TEMPLATE_ARITY_PARAM BOOST_PROTO_TEMPLATE_ARITY_PARAM2 +#define BOOST_PROTO_TEMPLATE_ARITY_PARAM2(param) + +#if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) || \ + (defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)) + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/inc.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/mpl/int.hpp> +#include <boost/proto/proto_fwd.hpp> + +#undef BOOST_PROTO_TEMPLATE_ARITY_PARAM2 +#define BOOST_PROTO_TEMPLATE_ARITY_PARAM2(param) , param + +namespace boost { namespace proto { namespace detail +{ + sized_type<1>::type template_arity_helper(...); + + // Other overloads generated by the preprocessor + #include <boost/proto/detail/template_arity_helper.hpp> + + template<typename F, int N, int Size> + struct template_arity_impl2 + : mpl::int_<Size - 1> + {}; + + template<typename F, int N = BOOST_PROTO_MAX_ARITY> + struct template_arity + : template_arity_impl2< + F + , N + , sizeof(detail::template_arity_helper((F **)0, (mpl::int_<N> *)0)) + > + {}; + + template<typename F, int N> + struct template_arity_impl2<F, N, 1> + : template_arity<F, N-1> + {}; + + template<typename F> + struct template_arity_impl2<F, 0, 1> + : mpl::int_<-1> + {}; + +}}} + +#endif // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING +#endif // BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07 diff --git a/3rdParty/Boost/src/boost/proto/detail/template_arity_helper.hpp b/3rdParty/Boost/src/boost/proto/detail/template_arity_helper.hpp new file mode 100644 index 0000000..ade9c60 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/template_arity_helper.hpp @@ -0,0 +1,44 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/template_arity_helper.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/template_arity_helper.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + // template_arity_helper.hpp + // Overloads of template_arity_helper, used by the template_arity\<\> 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/detail/template_arity_helper.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + #define N BOOST_PP_ITERATION() + + template< + template<BOOST_PP_ENUM_PARAMS(N, typename P)> class F + , BOOST_PP_ENUM_PARAMS(N, typename T) + > + sized_type<BOOST_PP_INC(N)>::type + template_arity_helper(F<BOOST_PP_ENUM_PARAMS(N, T)> **, mpl::int_<N> *); + + #undef N + +#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES diff --git a/3rdParty/Boost/src/boost/proto/detail/traits.hpp b/3rdParty/Boost/src/boost/proto/detail/traits.hpp new file mode 100644 index 0000000..d4fd2bc --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/traits.hpp @@ -0,0 +1,221 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/traits.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_CHILD(Z, N, DATA) \ + /** INTERNAL ONLY */ \ + typedef BOOST_PP_CAT(DATA, N) BOOST_PP_CAT(proto_child, N); \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/traits.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file traits.hpp + /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c + // + // 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, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/traits.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_CHILD + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + #if N > 0 + /// \brief A metafunction for generating function-call expression types, + /// a grammar element for matching function-call expressions, and a + /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> + /// transform. + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + struct function + #if N != BOOST_PROTO_MAX_ARITY + < + BOOST_PP_ENUM_PARAMS(N, A) + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) + > + #endif + : proto::transform< + function< + BOOST_PP_ENUM_PARAMS(N, A) + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) + > + , int + > + { + typedef proto::expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type; + typedef proto::basic_expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<function, deduce_domain, Expr, State, Data> + {}; + + /// INTERNAL ONLY + typedef proto::tag::function proto_tag; + BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A) + BOOST_PP_REPEAT_FROM_TO( + N + , BOOST_PROTO_MAX_ARITY + , BOOST_PROTO_CHILD + , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT + ) + }; + + /// \brief A metafunction for generating n-ary expression types with a + /// specified tag type, + /// a grammar element for matching n-ary expressions, and a + /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> + /// transform. + /// + /// Use <tt>nary_expr\<_, vararg\<_\> \></tt> as a grammar element to match any + /// n-ary expression; that is, any non-terminal. + template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct nary_expr + #if N != BOOST_PROTO_MAX_ARITY + < + Tag + BOOST_PP_ENUM_TRAILING_PARAMS(N, A) + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) + > + #endif + : proto::transform< + nary_expr< + Tag + BOOST_PP_ENUM_TRAILING_PARAMS(N, A) + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT) + > + , int + > + { + typedef proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type; + typedef proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data> + {}; + + /// INTERNAL ONLY + typedef Tag proto_tag; + BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A) + BOOST_PP_REPEAT_FROM_TO( + N + , BOOST_PROTO_MAX_ARITY + , BOOST_PROTO_CHILD + , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT + ) + }; + + namespace detail + { + template< + template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T + , BOOST_PP_ENUM_PARAMS(N, typename A) + > + struct is_callable_<T<BOOST_PP_ENUM_PARAMS(N, A)> BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)> + : is_same<BOOST_PP_CAT(A, BOOST_PP_DEC(N)), callable> + {}; + } + + #endif + + namespace result_of + { + /// \brief A metafunction that returns the type of the Nth child + /// of a Proto expression. + /// + /// A metafunction that returns the type of the Nth child + /// of a Proto expression. \c N must be less than + /// \c Expr::proto_arity::value. + template<typename Expr> + struct child_c<Expr, N> + { + /// Verify that we are not operating on a terminal + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + /// The raw type of the Nth child as it is stored within + /// \c Expr. This may be a value or a reference + typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; + + /// The "value" type of the child, suitable for return by value, + /// computed as follows: + /// \li <tt>T const &</tt> becomes <tt>T</tt> + /// \li <tt>T &</tt> becomes <tt>T</tt> + /// \li <tt>T</tt> becomes <tt>T</tt> + typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::value_type type; + }; + + template<typename Expr> + struct child_c<Expr &, N> + { + /// Verify that we are not operating on a terminal + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + /// The raw type of the Nth child as it is stored within + /// \c Expr. This may be a value or a reference + typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; + + /// The "reference" type of the child, suitable for return by + /// reference, computed as follows: + /// \li <tt>T const &</tt> becomes <tt>T const &</tt> + /// \li <tt>T &</tt> becomes <tt>T &</tt> + /// \li <tt>T</tt> becomes <tt>T &</tt> + typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::reference type; + + /// INTERNAL ONLY + /// + BOOST_FORCEINLINE + static type call(Expr &e) + { + return e.proto_base().BOOST_PP_CAT(child, N); + } + }; + + template<typename Expr> + struct child_c<Expr const &, N> + { + /// Verify that we are not operating on a terminal + BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c); + + /// The raw type of the Nth child as it is stored within + /// \c Expr. This may be a value or a reference + typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type; + + /// The "const reference" type of the child, suitable for return by + /// const reference, computed as follows: + /// \li <tt>T const &</tt> becomes <tt>T const &</tt> + /// \li <tt>T &</tt> becomes <tt>T &</tt> + /// \li <tt>T</tt> becomes <tt>T const &</tt> + typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::const_reference type; + + /// INTERNAL ONLY + /// + BOOST_FORCEINLINE + static type call(Expr const &e) + { + return e.proto_base().BOOST_PP_CAT(child, N); + } + }; + } + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/unpack_expr_.hpp b/3rdParty/Boost/src/boost/proto/detail/unpack_expr_.hpp new file mode 100644 index 0000000..7f398fb --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/unpack_expr_.hpp @@ -0,0 +1,198 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/unpack_expr_.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE(Z, N, DATA) \ + typedef typename fusion::result_of::next< \ + BOOST_PP_CAT(fusion_iterator, N)>::type \ + BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)); \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_FUSION_ITERATORS_TYPE(N) \ + typedef \ + typename fusion::result_of::begin<Sequence const>::type \ + fusion_iterator0; \ + BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE, fusion_iterator) \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \ + typename add_const< \ + typename fusion::result_of::value_of< \ + BOOST_PP_CAT(fusion_iterator, N) \ + >::type \ + >::type \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_FUSION_NEXT_ITERATOR(Z, N, DATA) \ + BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)) BOOST_PP_CAT(it, BOOST_PP_INC(N)) = \ + fusion::next(BOOST_PP_CAT(it, N)); \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_FUSION_ITERATORS(N) \ + fusion_iterator0 it0 = fusion::begin(sequence); \ + BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR, fusion_iterator) \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_FUSION_AT(Z, N, DATA) \ + *BOOST_PP_CAT(it, N) \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE(Z, N, DATA) \ + typename detail::protoify< \ + BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \ + , Domain \ + >::result_type \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_FUSION_AS_CHILD_AT(Z, N, DATA) \ + detail::protoify< \ + BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \ + , Domain \ + >()(BOOST_PROTO_FUSION_AT(Z, N, DATA)) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/unpack_expr_.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file make_expr_.hpp + /// Contains definition of make_expr_\<\> 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 + + template<typename Tag, typename Domain, typename Sequence, std::size_t Size> + struct unpack_expr_ + {}; + + template<typename Domain, typename Sequence> + struct unpack_expr_<tag::terminal, Domain, Sequence, 1u> + { + typedef + typename add_const< + typename fusion::result_of::value_of< + typename fusion::result_of::begin<Sequence>::type + >::type + >::type + terminal_type; + + typedef + typename proto::detail::protoify< + terminal_type + , Domain + >::result_type + type; + + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence)); + } + }; + + template<typename Sequence> + struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u> + : unpack_expr_<tag::terminal, default_domain, Sequence, 1u> + {}; + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/unpack_expr_.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_FUSION_AT + #undef BOOST_PROTO_FUSION_AT_TYPE + #undef BOOST_PROTO_FUSION_AS_CHILD_AT + #undef BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE + #undef BOOST_PROTO_FUSION_NEXT_ITERATOR + #undef BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE + #undef BOOST_PROTO_FUSION_ITERATORS + #undef BOOST_PROTO_FUSION_ITERATORS_TYPE + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N) + + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr_<Tag, Domain, Sequence, N> + { + BOOST_PROTO_FUSION_ITERATORS_TYPE(N) + + typedef + BOOST_PP_CAT(list, N)< + BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE, ~) + > + proto_args; + + typedef typename base_expr<Domain, Tag, proto_args>::type expr_type; + typedef typename Domain::proto_generator proto_generator; + typedef typename proto_generator::template result<proto_generator(expr_type)>::type type; + + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + BOOST_PROTO_FUSION_ITERATORS(N) + expr_type const that = { + BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT, ~) + }; + return proto_generator()(that); + } + }; + + template<typename Tag, typename Sequence> + struct unpack_expr_<Tag, deduce_domain, Sequence, N> + { + BOOST_PROTO_FUSION_ITERATORS_TYPE(N) + + typedef + unpack_expr_< + Tag + , typename BOOST_PP_CAT(deduce_domain, N)< + BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AT_TYPE, ~) + >::type + , Sequence + , N + > + other; + + typedef typename other::type type; + + BOOST_FORCEINLINE + static type const call(Sequence const &sequence) + { + return other::call(sequence); + } + }; + + #undef N + #undef M + +#endif diff --git a/3rdParty/Boost/src/boost/proto/detail/vararg_matches_impl.hpp b/3rdParty/Boost/src/boost/proto/detail/vararg_matches_impl.hpp new file mode 100644 index 0000000..d794258 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/detail/vararg_matches_impl.hpp @@ -0,0 +1,58 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/detail/preprocessed/vararg_matches_impl.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/vararg_matches_impl.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file vararg_matches_impl.hpp + /// Specializations of the vararg_matches_impl 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, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/vararg_matches_impl.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else // BOOST_PP_IS_ITERATING + + #define N BOOST_PP_ITERATION() + + template<typename Args, typename Back, long To> + struct vararg_matches_impl<Args, Back, N, To> + : and_2< + matches_< + typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar + , Back + >::value + , vararg_matches_impl<Args, Back, N + 1, To> + > + {}; + + template<typename Args, typename Back> + struct vararg_matches_impl<Args, Back, N, N> + : matches_< + typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar + , Back + > + {}; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/domain.hpp b/3rdParty/Boost/src/boost/proto/domain.hpp new file mode 100644 index 0000000..44bc45d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/domain.hpp @@ -0,0 +1,337 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file domain.hpp +/// Contains definition of domain\<\> class template and helpers for +/// defining domains with a generator and a grammar for controlling +/// operator overloading. +// +// 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_DOMAIN_HPP_EAN_02_13_2007 +#define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007 + +#include <boost/ref.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/generate.hpp> +#include <boost/proto/detail/as_expr.hpp> +#include <boost/proto/detail/deduce_domain.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + + namespace detail + { + struct not_a_generator + {}; + + struct not_a_grammar + {}; + + struct not_a_domain + {}; + } + + namespace domainns_ + { + /// \brief For use in defining domain tags to be used + /// with \c proto::extends\<\>. A \e Domain associates + /// an expression type with a \e Generator, and optionally + /// a \e Grammar. + /// + /// The Generator determines how new expressions in the + /// domain are constructed. Typically, a generator wraps + /// all new expressions in a wrapper that imparts + /// domain-specific behaviors to expressions within its + /// domain. (See \c proto::extends\<\>.) + /// + /// The Grammar determines whether a given expression is + /// valid within the domain, and automatically disables + /// any operator overloads which would cause an invalid + /// expression to be created. By default, the Grammar + /// parameter defaults to the wildcard, \c proto::_, which + /// makes all expressions valid within the domain. + /// + /// The Super declares the domain currently being defined + /// to be a sub-domain of Super. Expressions in sub-domains + /// can be freely combined with expressions in its super- + /// domain (and <I>its</I> super-domain, etc.). + /// + /// Example: + /// \code + /// template<typename Expr> + /// struct MyExpr; + /// + /// struct MyGrammar + /// : or_< terminal<_>, plus<MyGrammar, MyGrammar> > + /// {}; + /// + /// // Define MyDomain, in which all expressions are + /// // wrapped in MyExpr<> and only expressions that + /// // conform to MyGrammar are allowed. + /// struct MyDomain + /// : domain<generator<MyExpr>, MyGrammar> + /// {}; + /// + /// // Use MyDomain to define MyExpr + /// template<typename Expr> + /// struct MyExpr + /// : extends<Expr, MyExpr<Expr>, MyDomain> + /// { + /// // ... + /// }; + /// \endcode + /// + template< + typename Generator // = default_generator + , typename Grammar // = proto::_ + , typename Super // = no_super_domain + > + struct domain + : Generator + { + typedef Generator proto_generator; + typedef Grammar proto_grammar; + typedef Super proto_super_domain; + typedef domain proto_base_domain; + + /// INTERNAL ONLY + typedef void proto_is_domain_; + + /// \brief A unary MonomorphicFunctionObject that turns objects into Proto + /// expression objects in this domain. + /// + /// The <tt>as_expr\<\></tt> function object turns objects into Proto expressions, if + /// they are not already, by making them Proto terminals held by value if + /// possible. Objects that are already Proto expressions are left alone. + /// + /// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr; + /// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T: + /// + /// If \c T is not a Proto expression type the resulting terminal is + /// calculated as follows: + /// + /// If \c T is a function type, an abstract type, or a type derived from + /// \c std::ios_base, let \c A be <tt>T &</tt>. + /// Otherwise, let \c A be the type \c T stripped of cv-qualifiers. + /// Then, the result of applying <tt>as_expr\<T\>()(t)</tt> is + /// <tt>Generator()(E\<tag::terminal, term\<A\> \>::make(t))</tt>. + /// + /// If \c T is a Proto expression type and its generator type is different from + /// \c Generator, the result is <tt>Generator()(t)</tt>. + /// + /// Otherwise, the result is \c t converted to an (un-const) rvalue. + /// + template<typename T, typename IsExpr = void, typename Callable = proto::callable> + struct as_expr + : detail::as_expr< + T + , typename detail::base_generator<Generator>::type + , wants_basic_expr<Generator>::value + > + { + BOOST_PROTO_CALLABLE() + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct as_expr<T, typename T::proto_is_expr_, proto::callable> + { + BOOST_PROTO_CALLABLE() + typedef typename remove_const<T>::type result_type; + + BOOST_FORCEINLINE + result_type operator()(T &e) const + { + return e; + } + }; + + /// \brief A unary MonomorphicFunctionObject that turns objects into Proto + /// expression objects in this domain. + /// + /// The <tt>as_child\<\></tt> function object turns objects into Proto expressions, if + /// they are not already, by making them Proto terminals held by reference. + /// Objects that are already Proto expressions are simply returned by reference. + /// + /// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr; + /// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T: + /// + /// If \c T is not a Proto expression type the resulting terminal is + /// <tt>Generator()(E\<tag::terminal, term\<T &\> \>::make(t))</tt>. + /// + /// If \c T is a Proto expression type and its generator type is different from + /// \c Generator, the result is <tt>Generator()(t)</tt>. + /// + /// Otherwise, the result is the lvalue \c t. + /// + template<typename T, typename IsExpr = void, typename Callable = proto::callable> + struct as_child + : detail::as_child< + T + , typename detail::base_generator<Generator>::type + , wants_basic_expr<Generator>::value + > + { + BOOST_PROTO_CALLABLE() + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct as_child<T, typename T::proto_is_expr_, proto::callable> + { + BOOST_PROTO_CALLABLE() + typedef T &result_type; + + BOOST_FORCEINLINE + result_type operator()(T &e) const + { + return e; + } + }; + }; + + /// \brief The domain expressions have by default, if + /// \c proto::extends\<\> has not been used to associate + /// a domain with an expression. + /// + struct default_domain + : domain<> + {}; + + /// \brief A domain to use when you prefer the use of + /// \c proto::basic_expr\<\> over \c proto::expr\<\>. + /// + struct basic_default_domain + : domain<basic_default_generator> + {}; + + /// \brief A pseudo-domain for use in functions and + /// metafunctions that require a domain parameter. It + /// indicates that the domain of the parent node should + /// be inferred from the domains of the child nodes. + /// + /// \attention \c deduce_domain is not itself a valid domain. + /// + struct deduce_domain + : domain<detail::not_a_generator, detail::not_a_grammar, detail::not_a_domain> + {}; + + /// \brief Given a domain, a tag type and an argument list, + /// compute the type of the expression to generate. This is + /// either an instance of \c proto::expr\<\> or + /// \c proto::basic_expr\<\>. + /// + template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr> + struct base_expr + { + typedef proto::expr<Tag, Args, Args::arity> type; + }; + + /// INTERNAL ONLY + /// + template<typename Domain, typename Tag, typename Args> + struct base_expr<Domain, Tag, Args, true> + { + typedef proto::basic_expr<Tag, Args, Args::arity> type; + }; + + } + + /// A metafunction that returns \c mpl::true_ + /// if the type \c T is the type of a Proto domain; + /// \c mpl::false_ otherwise. If \c T inherits from + /// \c proto::domain\<\>, \c is_domain\<T\> is + /// \c mpl::true_. + template<typename T, typename Void /* = void*/> + struct is_domain + : mpl::false_ + {}; + + /// INTERNAL ONLY + /// + template<typename T> + struct is_domain<T, typename T::proto_is_domain_> + : mpl::true_ + {}; + + /// A metafunction that returns the domain of + /// a given type. If \c T is a Proto expression + /// type, it returns that expression's associated + /// domain. If not, it returns + /// \c proto::default_domain. + template<typename T, typename Void /* = void*/> + struct domain_of + { + typedef default_domain type; + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct domain_of<T, typename T::proto_is_expr_> + { + typedef typename T::proto_domain type; + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct domain_of<T &, void> + { + typedef typename domain_of<T>::type type; + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct domain_of<boost::reference_wrapper<T>, void> + { + typedef typename domain_of<T>::type type; + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct domain_of<boost::reference_wrapper<T> const, void> + { + typedef typename domain_of<T>::type type; + }; + + /// A metafunction that returns \c mpl::true_ + /// if the type \c SubDomain is a sub-domain of + /// \c SuperDomain; \c mpl::false_ otherwise. + template<typename SubDomain, typename SuperDomain> + struct is_sub_domain_of + : is_sub_domain_of<typename SubDomain::proto_super_domain, SuperDomain> + {}; + + /// INTERNAL ONLY + /// + template<typename SuperDomain> + struct is_sub_domain_of<proto::no_super_domain, SuperDomain> + : mpl::false_ + {}; + + /// INTERNAL ONLY + /// + template<typename SuperDomain> + struct is_sub_domain_of<SuperDomain, SuperDomain> + : mpl::true_ + {}; + +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/eval.hpp b/3rdParty/Boost/src/boost/proto/eval.hpp new file mode 100644 index 0000000..25a91aa --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/eval.hpp @@ -0,0 +1,140 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file eval.hpp +/// Contains the eval() expression evaluator. +// +// 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_EVAL_HPP_EAN_03_29_2007 +#define BOOST_PROTO_EVAL_HPP_EAN_03_29_2007 + +#include <boost/proto/proto_fwd.hpp> // BOOST_PROTO_CALLABLE +#include <boost/type_traits/remove_reference.hpp> + +namespace boost { namespace proto +{ + + namespace result_of + { + /// \brief A metafunction for calculating the return type + /// of \c proto::eval() given a certain \c Expr and \c Context + /// types. + /// + /// \note The types \c Expr and \c Context should not be + /// reference types. They may be cv-qualified, but the + /// cv-qualification on the \c Context parameter is ignored. + template<typename Expr, typename Context> + struct eval + { + typedef typename Context::template eval<Expr>::result_type type; + }; + } + + namespace functional + { + /// \brief A PolymorphicFunctionObject type for + /// evaluating a given Proto expression with a given + /// context. + struct eval + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr, typename Context> + struct result<This(Expr, Context)> + { + typedef + typename proto::result_of::eval< + typename remove_reference<Expr>::type + , typename remove_reference<Context>::type + >::type + type; + }; + + /// \brief Evaluate a given Proto expression with a given + /// context. + /// \param expr The Proto expression to evaluate + /// \param context The context in which the expression should be + /// evaluated. + /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt> + template<typename Expr, typename Context> + typename proto::result_of::eval<Expr, Context>::type + operator ()(Expr &e, Context &ctx) const + { + return typename Context::template eval<Expr>()(e, ctx); + } + + /// \overload + /// + template<typename Expr, typename Context> + typename proto::result_of::eval<Expr, Context>::type + operator ()(Expr &e, Context const &ctx) const + { + return typename Context::template eval<Expr>()(e, ctx); + } + + /// \overload + /// + template<typename Expr, typename Context> + typename proto::result_of::eval<Expr const, Context>::type + operator ()(Expr const &e, Context &ctx) const + { + return typename Context::template eval<Expr const>()(e, ctx); + } + + /// \overload + /// + template<typename Expr, typename Context> + typename proto::result_of::eval<Expr const, Context>::type + operator ()(Expr const &e, Context const &ctx) const + { + return typename Context::template eval<Expr const>()(e, ctx); + } + }; + } + + /// \brief Evaluate a given Proto expression with a given + /// context. + /// \param expr The Proto expression to evaluate + /// \param context The context in which the expression should be + /// evaluated. + /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt> + template<typename Expr, typename Context> + typename proto::result_of::eval<Expr, Context>::type + eval(Expr &e, Context &ctx) + { + return typename Context::template eval<Expr>()(e, ctx); + } + + /// \overload + /// + template<typename Expr, typename Context> + typename proto::result_of::eval<Expr, Context>::type + eval(Expr &e, Context const &ctx) + { + return typename Context::template eval<Expr>()(e, ctx); + } + + /// \overload + /// + template<typename Expr, typename Context> + typename proto::result_of::eval<Expr const, Context>::type + eval(Expr const &e, Context &ctx) + { + return typename Context::template eval<Expr const>()(e, ctx); + } + + /// \overload + /// + template<typename Expr, typename Context> + typename proto::result_of::eval<Expr const, Context>::type + eval(Expr const &e, Context const &ctx) + { + return typename Context::template eval<Expr const>()(e, ctx); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/expr.hpp b/3rdParty/Boost/src/boost/proto/expr.hpp new file mode 100644 index 0000000..e75ee16 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/expr.hpp @@ -0,0 +1,163 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file expr.hpp +/// Contains definition of expr\<\> 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) + +#ifndef BOOST_PROTO_EXPR_HPP_EAN_04_01_2005 +#define BOOST_PROTO_EXPR_HPP_EAN_04_01_2005 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/selection/max.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/preprocessor/repetition/enum_trailing.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> +#include <boost/utility/addressof.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/args.hpp> +#include <boost/proto/traits.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4510) // default constructor could not be generated +# pragma warning(disable : 4512) // assignment operator could not be generated +# pragma warning(disable : 4610) // user defined constructor required +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + + namespace detail + { + struct not_a_valid_type + { + private: + not_a_valid_type() + {} + }; + + template<typename Tag, typename Arg> + struct address_of_hack + { + typedef not_a_valid_type type; + }; + + template<typename Expr> + struct address_of_hack<proto::tag::address_of, Expr &> + { + typedef Expr *type; + }; + + template<typename T, typename Expr, typename Arg0> + BOOST_FORCEINLINE + Expr make_terminal(T &t, Expr *, proto::term<Arg0> *) + { + Expr that = {t}; + return that; + } + + template<typename T, typename Expr, typename Arg0, std::size_t N> + BOOST_FORCEINLINE + Expr make_terminal(T (&t)[N], Expr *, proto::term<Arg0[N]> *) + { + Expr that; + for(std::size_t i = 0; i < N; ++i) + { + that.child0[i] = t[i]; + } + return that; + } + + template<typename T, typename Expr, typename Arg0, std::size_t N> + BOOST_FORCEINLINE + Expr make_terminal(T const(&t)[N], Expr *, proto::term<Arg0[N]> *) + { + Expr that; + for(std::size_t i = 0; i < N; ++i) + { + that.child0[i] = t[i]; + } + return that; + } + + // Work-around for: + // https://connect.microsoft.com/VisualStudio/feedback/details/765449/codegen-stack-corruption-using-runtime-checks-when-aggregate-initializing-struct + #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700)) + template<typename T, typename Expr, typename C, typename U> + BOOST_FORCEINLINE + Expr make_terminal(T &t, Expr *, proto::term<U C::*> *) + { + Expr that; + that.child0 = t; + return that; + } + #endif + + template<typename T, typename U> + struct same_cv + { + typedef U type; + }; + + template<typename T, typename U> + struct same_cv<T const, U> + { + typedef U const type; + }; + } + + namespace result_of + { + /// \brief A helper metafunction for computing the + /// return type of \c proto::expr\<\>::operator(). + template<typename Sig, typename This, typename Domain> + struct funop; + + #include <boost/proto/detail/funop.hpp> + } + + namespace exprns_ + { + // This is where the basic_expr specializations are + // actually defined: + #include <boost/proto/detail/basic_expr.hpp> + + // This is where the expr specialization are + // actually defined: + #include <boost/proto/detail/expr.hpp> + } + + /// \brief Lets you inherit the interface of an expression + /// while hiding from Proto the fact that the type is a Proto + /// expression. + template<typename Expr> + struct unexpr + : Expr + { + BOOST_PROTO_UNEXPR() + + BOOST_FORCEINLINE + explicit unexpr(Expr const &e) + : Expr(e) + {} + + using Expr::operator =; + }; + +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif // BOOST_PROTO_EXPR_HPP_EAN_04_01_2005 diff --git a/3rdParty/Boost/src/boost/proto/extends.hpp b/3rdParty/Boost/src/boost/proto/extends.hpp new file mode 100644 index 0000000..47dca11 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/extends.hpp @@ -0,0 +1,647 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file extends.hpp +/// Macros and a base class for defining end-user expression types +// +// 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_EXTENDS_HPP_EAN_11_1_2006 +#define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006 + +#include <cstddef> // for offsetof +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/preprocessor/facilities/empty.hpp> +#include <boost/preprocessor/tuple/elem.hpp> +#include <boost/preprocessor/control/if.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/iteration/local.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> +#include <boost/preprocessor/seq/for_each.hpp> +#include <boost/utility/addressof.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/expr.hpp> +#include <boost/proto/args.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/generate.hpp> +#include <boost/proto/detail/remove_typename.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + #ifdef __GNUC__ + /// INTERNAL ONLY + /// + # define BOOST_PROTO_ADDROF(x) ((char const volatile*)boost::addressof(x)) + /// INTERNAL ONLY + /// + # define BOOST_PROTO_OFFSETOF(s,m) (BOOST_PROTO_ADDROF((((s *)this)->m)) - BOOST_PROTO_ADDROF(*((s *)this))) + #else + /// INTERNAL ONLY + /// + # define BOOST_PROTO_OFFSETOF offsetof + #endif + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_CONST() const + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_TYPENAME() typename + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_TEMPLATE_NO_(Z, N) + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, Const) \ + BOOST_PP_IF(N, BOOST_PROTO_TEMPLATE_YES_, BOOST_PROTO_TEMPLATE_NO_)(Z, N) \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename BOOST_PROTO_RESULT_OF< \ + proto_generator( \ + typename boost::proto::result_of::BOOST_PP_CAT(funop, N)< \ + proto_derived_expr Const() \ + , proto_domain \ + BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \ + >::type \ + ) \ + >::type const \ + operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) Const() \ + { \ + typedef boost::proto::result_of::BOOST_PP_CAT(funop, N)< \ + proto_derived_expr Const() \ + , proto_domain \ + BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \ + > funop; \ + return proto_generator()( \ + funop::call( \ + *static_cast<proto_derived_expr Const() *>(this) \ + BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a) \ + ) \ + ); \ + } \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(Const) \ + template<typename... A> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename BOOST_PROTO_RESULT_OF< \ + proto_generator( \ + typename boost::proto::result_of::funop< \ + proto_derived_expr Const()(A const &...) \ + , proto_derived_expr \ + , proto_domain \ + >::type \ + ) \ + >::type const \ + operator ()(A const &...a) Const() \ + { \ + typedef boost::proto::result_of::funop< \ + proto_derived_expr Const()(A const &...) \ + , proto_derived_expr \ + , proto_domain \ + > funop; \ + return proto_generator()( \ + funop::call( \ + *static_cast<proto_derived_expr Const() *>(this) \ + , a... \ + ) \ + ); \ + } \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \ + BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PROTO_CONST) \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \ + BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PP_EMPTY) \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_DEFINE_FUN_OP(Z, N, DATA) \ + BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \ + BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_EXTENDS_CHILD(Z, N, DATA) \ + typedef \ + typename proto_base_expr::BOOST_PP_CAT(proto_child, N) \ + BOOST_PP_CAT(proto_child, N); \ + /**/ + + #define BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \ + Expr proto_expr_; \ + \ + typedef Expr proto_base_expr_; /**< INTERNAL ONLY */ \ + typedef typename proto_base_expr_::proto_base_expr proto_base_expr; \ + typedef BOOST_PROTO_REMOVE_TYPENAME(Domain) proto_domain; \ + typedef Derived proto_derived_expr; \ + typedef Domain::proto_generator proto_generator; \ + typedef typename proto_base_expr::proto_tag proto_tag; \ + typedef typename proto_base_expr::proto_args proto_args; \ + typedef typename proto_base_expr::proto_arity proto_arity; \ + typedef typename proto_base_expr::proto_grammar proto_grammar; \ + typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; \ + typedef void proto_is_expr_; /**< INTERNAL ONLY */ \ + static const long proto_arity_c = proto_base_expr::proto_arity_c; \ + typedef boost::proto::tag::proto_expr<proto_tag, proto_domain> fusion_tag; \ + BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \ + \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + static proto_derived_expr const make(Expr const &e) \ + { \ + proto_derived_expr that = {e}; \ + return that; \ + } \ + \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + proto_base_expr &proto_base() \ + { \ + return this->proto_expr_.proto_base(); \ + } \ + \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + proto_base_expr const &proto_base() const \ + { \ + return this->proto_expr_.proto_base(); \ + } \ + \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + operator proto_address_of_hack_type_() const \ + { \ + return boost::addressof(this->proto_base().child0); \ + } \ + /**/ + + #define BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \ + BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \ + typedef void proto_is_aggregate_; \ + /**< INTERNAL ONLY */ + + #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, Const, Typename) \ + BOOST_PROTO_DISABLE_MSVC_C4522 \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + Typename() BOOST_PROTO_RESULT_OF< \ + Typename() This::proto_generator( \ + Typename() boost::proto::base_expr< \ + Typename() This::proto_domain \ + , boost::proto::tag::assign \ + , boost::proto::list2< \ + This & \ + , This Const() & \ + > \ + >::type \ + ) \ + >::type const \ + operator =(This Const() &a) \ + { \ + typedef \ + Typename() boost::proto::base_expr< \ + Typename() This::proto_domain \ + , boost::proto::tag::assign \ + , boost::proto::list2< \ + This & \ + , This Const() & \ + > \ + >::type \ + that_type; \ + that_type const that = { \ + *this \ + , a \ + }; \ + return Typename() This::proto_generator()(that); \ + } \ + /**/ + + // MSVC 8.0 and higher seem to need copy-assignment operator to be overloaded on *both* + // const and non-const rhs arguments. + #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) && (BOOST_MSVC > 1310) + #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \ + BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PP_EMPTY, Typename) \ + BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \ + /**/ + #else + #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \ + BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \ + /**/ + #endif + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(ThisConst, ThatConst) \ + template<typename A> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename BOOST_PROTO_RESULT_OF< \ + proto_generator( \ + typename boost::proto::base_expr< \ + proto_domain \ + , boost::proto::tag::assign \ + , boost::proto::list2< \ + proto_derived_expr ThisConst() & \ + , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \ + > \ + >::type \ + ) \ + >::type const \ + operator =(A ThatConst() &a) ThisConst() \ + { \ + typedef \ + typename boost::proto::base_expr< \ + proto_domain \ + , boost::proto::tag::assign \ + , boost::proto::list2< \ + proto_derived_expr ThisConst() & \ + , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \ + > \ + >::type \ + that_type; \ + that_type const that = { \ + *static_cast<proto_derived_expr ThisConst() *>(this) \ + , boost::proto::as_child<proto_domain>(a) \ + }; \ + return proto_generator()(that); \ + } \ + /**/ + + #define BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \ + BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \ + BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \ + /**/ + + #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \ + BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \ + BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \ + /**/ + + #define BOOST_PROTO_EXTENDS_ASSIGN_() \ + BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \ + BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \ + /**/ + + #define BOOST_PROTO_EXTENDS_ASSIGN_CONST() \ + BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \ + BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \ + /**/ + + #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST() \ + BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \ + BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \ + /**/ + + #define BOOST_PROTO_EXTENDS_ASSIGN() \ + BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \ + BOOST_PROTO_EXTENDS_ASSIGN_() \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(ThisConst, ThatConst) \ + template<typename A> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename BOOST_PROTO_RESULT_OF< \ + proto_generator( \ + typename boost::proto::base_expr< \ + proto_domain \ + , boost::proto::tag::subscript \ + , boost::proto::list2< \ + proto_derived_expr ThisConst() & \ + , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \ + > \ + >::type \ + ) \ + >::type const \ + operator [](A ThatConst() &a) ThisConst() \ + { \ + typedef \ + typename boost::proto::base_expr< \ + proto_domain \ + , boost::proto::tag::subscript \ + , boost::proto::list2< \ + proto_derived_expr ThisConst() & \ + , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \ + > \ + >::type \ + that_type; \ + that_type const that = { \ + *static_cast<proto_derived_expr ThisConst() *>(this) \ + , boost::proto::as_child<proto_domain>(a) \ + }; \ + return proto_generator()(that); \ + } \ + /**/ + + #define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \ + BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \ + BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \ + /**/ + + #define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \ + BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \ + BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \ + /**/ + + #define BOOST_PROTO_EXTENDS_SUBSCRIPT() \ + BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \ + BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \ + /**/ + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_EXTENDS_FUNCTION_() \ + template<typename Sig> \ + struct result \ + { \ + typedef \ + typename BOOST_PROTO_RESULT_OF< \ + proto_generator( \ + typename boost::proto::result_of::funop< \ + Sig \ + , proto_derived_expr \ + , proto_domain \ + >::type \ + ) \ + >::type const \ + type; \ + }; \ + /**/ + + #ifndef BOOST_NO_VARIADIC_TEMPLATES + #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \ + BOOST_PROTO_EXTENDS_FUNCTION_() \ + BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \ + /**/ + + #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \ + BOOST_PROTO_EXTENDS_FUNCTION_() \ + BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \ + /**/ + + #define BOOST_PROTO_EXTENDS_FUNCTION() \ + BOOST_PROTO_EXTENDS_FUNCTION_() \ + BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \ + BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \ + /**/ + #else + #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \ + BOOST_PROTO_EXTENDS_FUNCTION_() \ + BOOST_PP_REPEAT_FROM_TO( \ + 0 \ + , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \ + , BOOST_PROTO_DEFINE_FUN_OP_CONST \ + , ~ \ + ) \ + /**/ + + #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \ + BOOST_PROTO_EXTENDS_FUNCTION_() \ + BOOST_PP_REPEAT_FROM_TO( \ + 0 \ + , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \ + , BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \ + , ~ \ + ) \ + /**/ + + #define BOOST_PROTO_EXTENDS_FUNCTION() \ + BOOST_PROTO_EXTENDS_FUNCTION_() \ + BOOST_PP_REPEAT_FROM_TO( \ + 0 \ + , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \ + , BOOST_PROTO_DEFINE_FUN_OP \ + , ~ \ + ) \ + /**/ + #endif + + #define BOOST_PROTO_EXTENDS(Expr, Derived, Domain) \ + BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \ + BOOST_PROTO_EXTENDS_ASSIGN() \ + BOOST_PROTO_EXTENDS_SUBSCRIPT() \ + BOOST_PROTO_EXTENDS_FUNCTION() \ + /**/ + + #define BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived) \ + typedef typename Derived::proto_extends proto_extends; \ + using proto_extends::operator =; \ + BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PROTO_TYPENAME) \ + /**/ + + #define BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived) \ + typedef Derived::proto_extends proto_extends; \ + using proto_extends::operator =; \ + BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PP_EMPTY) \ + /**/ + + namespace exprns_ + { + /// \brief Empty type to be used as a dummy template parameter of + /// POD expression wrappers. It allows argument-dependent lookup + /// to find Proto's operator overloads. + /// + /// \c proto::is_proto_expr allows argument-dependent lookup + /// to find Proto's operator overloads. For example: + /// + /// \code + /// template<typename T, typename Dummy = proto::is_proto_expr> + /// struct my_terminal + /// { + /// BOOST_PROTO_BASIC_EXTENDS( + /// typename proto::terminal<T>::type + /// , my_terminal<T> + /// , default_domain + /// ) + /// }; + /// + /// // ... + /// my_terminal<int> _1, _2; + /// _1 + _2; // OK, uses proto::operator+ + /// \endcode + /// + /// Without the second \c Dummy template parameter, Proto's operator + /// overloads would not be considered by name lookup. + struct is_proto_expr + {}; + + /// \brief extends\<\> class template for adding behaviors to a Proto expression template + /// + template< + typename Expr + , typename Derived + , typename Domain // = proto::default_domain + , long Arity // = Expr::proto_arity_c + > + struct extends + { + BOOST_FORCEINLINE + extends() + : proto_expr_() + {} + + BOOST_FORCEINLINE + extends(extends const &that) + : proto_expr_(that.proto_expr_) + {} + + BOOST_FORCEINLINE + extends(Expr const &expr_) + : proto_expr_(expr_) + {} + + typedef extends proto_extends; + BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain) + BOOST_PROTO_EXTENDS_ASSIGN_CONST_() + BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() + + // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses + // nested preprocessor loops, use file iteration here to generate + // the operator() overloads, which is more efficient. + #include <boost/proto/detail/extends_funop_const.hpp> + }; + + /// \brief extends\<\> class template for adding behaviors to a Proto expression template + /// + template<typename Expr, typename Derived, typename Domain> + struct extends<Expr, Derived, Domain, 0> + { + BOOST_FORCEINLINE + extends() + : proto_expr_() + {} + + BOOST_FORCEINLINE + extends(extends const &that) + : proto_expr_(that.proto_expr_) + {} + + BOOST_FORCEINLINE + extends(Expr const &expr_) + : proto_expr_(expr_) + {} + + typedef extends proto_extends; + BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain) + BOOST_PROTO_EXTENDS_ASSIGN_() + BOOST_PROTO_EXTENDS_SUBSCRIPT() + + // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses + // nested preprocessor loops, use file iteration here to generate + // the operator() overloads, which is more efficient. + #include <boost/proto/detail/extends_funop.hpp> + }; + + /// INTERNAL ONLY + /// + template<typename This, typename Fun, typename Domain> + struct virtual_member + { + typedef Domain proto_domain; + typedef typename Domain::proto_generator proto_generator; + typedef virtual_member<This, Fun, Domain> proto_derived_expr; + typedef tag::member proto_tag; + typedef list2<This &, expr<tag::terminal, term<Fun> > const &> proto_args; + typedef mpl::long_<2> proto_arity; + typedef detail::not_a_valid_type proto_address_of_hack_type_; + typedef void proto_is_expr_; /**< INTERNAL ONLY */ + static const long proto_arity_c = 2; + typedef boost::proto::tag::proto_expr<proto_tag, Domain> fusion_tag; + typedef This &proto_child0; + typedef expr<tag::terminal, term<Fun> > const &proto_child1; + typedef expr<proto_tag, proto_args, proto_arity_c> proto_base_expr; + typedef basic_expr<proto_tag, proto_args, proto_arity_c> proto_grammar; + typedef void proto_is_aggregate_; /**< INTERNAL ONLY */ + + BOOST_PROTO_EXTENDS_ASSIGN_() + BOOST_PROTO_EXTENDS_SUBSCRIPT() + + // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses + // nested preprocessor loops, use file iteration here to generate + // the operator() overloads, which is more efficient. + #define BOOST_PROTO_NO_WAVE_OUTPUT + #include <boost/proto/detail/extends_funop.hpp> + #undef BOOST_PROTO_NO_WAVE_OUTPUT + + BOOST_FORCEINLINE + proto_base_expr const proto_base() const + { + proto_base_expr that = {this->child0(), this->child1()}; + return that; + } + + BOOST_FORCEINLINE + proto_child0 child0() const + { + using std::size_t; + return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_)); + } + + BOOST_FORCEINLINE + proto_child1 child1() const + { + static expr<tag::terminal, term<Fun>, 0> const that = {Fun()}; + return that; + } + }; + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM) \ + boost::proto::exprns_::virtual_member< \ + proto_derived_expr \ + , BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \ + , DOMAIN \ + > BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \ + /**/ + + /// \brief For declaring virtual data members in an extension class. + /// + #define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN) \ + union \ + { \ + char proto_member_union_start_; \ + BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ) \ + }; \ + /**/ + + /// \brief For declaring virtual data members in an extension class. + /// + #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \ + BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain) \ + /**/ + + } + +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional.hpp b/3rdParty/Boost/src/boost/proto/functional.hpp new file mode 100644 index 0000000..a8577d7 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional.hpp @@ -0,0 +1,16 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file functional.hpp +/// Proto callables for various things +// +// Copyright 2010 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_FUNCTIONAL_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_HPP_EAN_11_27_2010 + +#include <boost/proto/functional/std.hpp> +#include <boost/proto/functional/fusion.hpp> +#include <boost/proto/functional/range.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion.hpp new file mode 100644 index 0000000..8aaf4ea --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion.hpp @@ -0,0 +1,19 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file fusion.hpp +/// Proto callables for things found in the Fusion library +// +// Copyright 2010 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_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010 + +#include <boost/proto/functional/fusion/at.hpp> +#include <boost/proto/functional/fusion/pop_back.hpp> +#include <boost/proto/functional/fusion/pop_front.hpp> +#include <boost/proto/functional/fusion/push_back.hpp> +#include <boost/proto/functional/fusion/push_front.hpp> +#include <boost/proto/functional/fusion/reverse.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/at.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/at.hpp new file mode 100644 index 0000000..328ac13 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/at.hpp @@ -0,0 +1,56 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file at.hpp +/// Proto callables Fusion at +// +// Copyright 2010 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_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010 + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/fusion/include/at.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::at() accessor on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::at() accessor on its argument. + struct at + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq, typename N> + struct result<This(Seq, N)> + : fusion::result_of::at< + typename boost::remove_reference<Seq>::type + , typename boost::remove_const<typename boost::remove_reference<N>::type>::type + > + {}; + + template<typename Seq, typename N> + typename fusion::result_of::at<Seq, N>::type + operator ()(Seq &seq, N const & BOOST_PROTO_DISABLE_IF_IS_CONST(Seq)) const + { + return fusion::at<N>(seq); + } + + template<typename Seq, typename N> + typename fusion::result_of::at<Seq const, N>::type + operator ()(Seq const &seq, N const &) const + { + return fusion::at<N>(seq); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/pop_back.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/pop_back.hpp new file mode 100644 index 0000000..f3ebeb8 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/pop_back.hpp @@ -0,0 +1,60 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file pop_back.hpp +/// Proto callables Fusion pop_back +// +// Copyright 2010 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_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010 + +#include <boost/fusion/include/begin.hpp> +#include <boost/fusion/include/end.hpp> +#include <boost/fusion/include/prior.hpp> +#include <boost/fusion/include/pop_back.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::pop_back() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::pop_back() algorithm on its argument. + struct pop_back + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq> + struct result<This(Seq)> + : result<This(Seq const &)> + {}; + + template<typename This, typename Seq> + struct result<This(Seq &)> + : fusion::result_of::pop_back<Seq> + {}; + + template<typename Seq> + typename fusion::result_of::pop_back<Seq>::type + operator ()(Seq &seq) const + { + // Work around a const-correctness issue in Fusion + typedef typename fusion::result_of::pop_back<Seq>::type result_type; + return result_type(fusion::begin(seq), fusion::prior(fusion::end(seq))); + } + + template<typename Seq> + typename fusion::result_of::pop_back<Seq const>::type + operator ()(Seq const &seq) const + { + return fusion::pop_back(seq); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/pop_front.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/pop_front.hpp new file mode 100644 index 0000000..9586f4d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/pop_front.hpp @@ -0,0 +1,65 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file pop_front.hpp +/// Proto callables Fusion pop_front +// +// Copyright 2010 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_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010 + +#include <boost/fusion/include/begin.hpp> +#include <boost/fusion/include/end.hpp> +#include <boost/fusion/include/next.hpp> +#include <boost/fusion/include/pop_front.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::pop_front() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::pop_front() algorithm on its argument. This is + /// useful for defining a CallableTransform like \c pop_front(_) + /// which removes the first child from a Proto expression node. + /// Such a transform might be used as the first argument to the + /// \c proto::fold\<\> transform; that is, fold all but + /// the first child. + struct pop_front + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq> + struct result<This(Seq)> + : result<This(Seq const &)> + {}; + + template<typename This, typename Seq> + struct result<This(Seq &)> + : fusion::result_of::pop_front<Seq> + {}; + + template<typename Seq> + typename fusion::result_of::pop_front<Seq>::type + operator ()(Seq &seq) const + { + // Work around a const-correctness issue in Fusion + typedef typename fusion::result_of::pop_front<Seq>::type result_type; + return result_type(fusion::next(fusion::begin(seq)), fusion::end(seq)); + } + + template<typename Seq> + typename fusion::result_of::pop_front<Seq const>::type + operator ()(Seq const &seq) const + { + return fusion::pop_front(seq); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/push_back.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/push_back.hpp new file mode 100644 index 0000000..8a427ae --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/push_back.hpp @@ -0,0 +1,49 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file push_back.hpp +/// Proto callables Fusion push_back +// +// Copyright 2010 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_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010 + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/fusion/include/push_back.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::push_back() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::push_back() algorithm on its argument. + struct push_back + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq, typename T> + struct result<This(Seq, T)> + : fusion::result_of::push_back< + typename boost::add_const<typename boost::remove_reference<Seq>::type>::type + , typename boost::remove_const<typename boost::remove_reference<T>::type>::type + > + {}; + + template<typename Seq, typename T> + typename fusion::result_of::push_back<Seq const, T>::type + operator ()(Seq const &seq, T const &t) const + { + return fusion::push_back(seq, t); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/push_front.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/push_front.hpp new file mode 100644 index 0000000..d17f509 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/push_front.hpp @@ -0,0 +1,49 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file push_front.hpp +/// Proto callables Fusion push_front +// +// Copyright 2010 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_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010 + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/fusion/include/push_front.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::push_front() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::push_front() algorithm on its argument. + struct push_front + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq, typename T> + struct result<This(Seq, T)> + : fusion::result_of::push_front< + typename boost::add_const<typename boost::remove_reference<Seq>::type>::type + , typename boost::remove_const<typename boost::remove_reference<T>::type>::type + > + {}; + + template<typename Seq, typename T> + typename fusion::result_of::push_front<Seq const, T>::type + operator ()(Seq const &seq, T const &t) const + { + return fusion::push_front(seq, t); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/reverse.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/reverse.hpp new file mode 100644 index 0000000..3ed154b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/reverse.hpp @@ -0,0 +1,60 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file reverse.hpp +/// Proto callables Fusion reverse +// +// Copyright 2010 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_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010 + +#include <boost/fusion/include/reverse.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::reverse() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::reverse() algorithm on its argument. This is + /// useful for defining a CallableTransform like \c reverse(_) + /// which reverses the order of the children of a Proto + /// expression node. + struct reverse + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq> + struct result<This(Seq)> + : result<This(Seq const &)> + {}; + + template<typename This, typename Seq> + struct result<This(Seq &)> + : fusion::result_of::reverse<Seq> + {}; + + template<typename Seq> + typename fusion::result_of::reverse<Seq>::type + operator ()(Seq &seq) const + { + // Work around a const-correctness issue in Fusion + typedef typename fusion::result_of::reverse<Seq>::type result_type; + return result_type(seq); + } + + template<typename Seq> + typename fusion::result_of::reverse<Seq const>::type + operator ()(Seq const &seq) const + { + return fusion::reverse(seq); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range.hpp b/3rdParty/Boost/src/boost/proto/functional/range.hpp new file mode 100644 index 0000000..e83c853 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range.hpp @@ -0,0 +1,19 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file range.hpp +/// Proto callables for things found in the boost range library +// +// Copyright 2012 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_FUNCTIONAL_RANGE_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_HPP_EAN_27_08_2012 + +#include <boost/proto/functional/range/begin.hpp> +#include <boost/proto/functional/range/empty.hpp> +#include <boost/proto/functional/range/end.hpp> +#include <boost/proto/functional/range/rbegin.hpp> +#include <boost/proto/functional/range/rend.hpp> +#include <boost/proto/functional/range/size.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/begin.hpp b/3rdParty/Boost/src/boost/proto/functional/range/begin.hpp new file mode 100644 index 0000000..c425a41 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/begin.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file begin.hpp +/// Proto callables for boost::begin() +// +// Copyright 2012 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_FUNCTIONAL_RANGE_BEGIN_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_BEGIN_HPP_EAN_27_08_2012 + +#include <boost/range/begin.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::begin() + struct begin + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_iterator<Rng const> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_iterator<Rng> + {}; + + template<typename Rng> + typename boost::range_iterator<Rng>::type operator()(Rng &rng) const + { + return boost::begin(rng); + } + + template<typename Rng> + typename boost::range_iterator<Rng const>::type operator()(Rng const &rng) const + { + return boost::begin(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/empty.hpp b/3rdParty/Boost/src/boost/proto/functional/range/empty.hpp new file mode 100644 index 0000000..debb82d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/empty.hpp @@ -0,0 +1,34 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file empty.hpp +/// Proto callables for boost::empty() +// +// Copyright 2012 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_FUNCTIONAL_RANGE_EMPTY_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_EMPTY_HPP_EAN_27_08_2012 + +#include <boost/range/empty.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::empty() + struct empty + { + BOOST_PROTO_CALLABLE() + + typedef bool result_type; + + template<typename Rng> + bool operator()(Rng const &rng) const + { + return boost::empty(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/end.hpp b/3rdParty/Boost/src/boost/proto/functional/range/end.hpp new file mode 100644 index 0000000..f7506fd --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/end.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file end.hpp +/// Proto callables for boost::end() +// +// Copyright 2012 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_FUNCTIONAL_RANGE_END_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_END_HPP_EAN_27_08_2012 + +#include <boost/range/end.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::end() + struct end + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_iterator<Rng const> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_iterator<Rng> + {}; + + template<typename Rng> + typename boost::range_iterator<Rng>::type operator()(Rng &rng) const + { + return boost::end(rng); + } + + template<typename Rng> + typename boost::range_iterator<Rng const>::type operator()(Rng const &rng) const + { + return boost::end(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/rbegin.hpp b/3rdParty/Boost/src/boost/proto/functional/range/rbegin.hpp new file mode 100644 index 0000000..ecb7db9 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/rbegin.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file rbegin.hpp +/// Proto callables for boost::rbegin() +// +// Copyright 2012 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_FUNCTIONAL_RANGE_RBEGIN_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_RBEGIN_HPP_EAN_27_08_2012 + +#include <boost/range/rbegin.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::rbegin() + struct rbegin + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_reverse_iterator<Rng const> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_reverse_iterator<Rng> + {}; + + template<typename Rng> + typename boost::range_reverse_iterator<Rng>::type operator()(Rng &rng) const + { + return boost::rbegin(rng); + } + + template<typename Rng> + typename boost::range_reverse_iterator<Rng const>::type operator()(Rng const &rng) const + { + return boost::rbegin(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/rend.hpp b/3rdParty/Boost/src/boost/proto/functional/range/rend.hpp new file mode 100644 index 0000000..5b37782 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/rend.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file rend.hpp +/// Proto callables for boost::rend() +// +// Copyright 2012 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_FUNCTIONAL_RANGE_REND_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_REND_HPP_EAN_27_08_2012 + +#include <boost/range/rend.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::rend() + struct rend + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_reverse_iterator<Rng const> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_reverse_iterator<Rng> + {}; + + template<typename Rng> + typename boost::range_reverse_iterator<Rng>::type operator()(Rng &rng) const + { + return boost::rend(rng); + } + + template<typename Rng> + typename boost::range_reverse_iterator<Rng const>::type operator()(Rng const &rng) const + { + return boost::rend(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/size.hpp b/3rdParty/Boost/src/boost/proto/functional/range/size.hpp new file mode 100644 index 0000000..3fcdda1 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/size.hpp @@ -0,0 +1,45 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file size.hpp +/// Proto callables for boost::size() +// +// Copyright 2012 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_FUNCTIONAL_RANGE_SIZE_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_SIZE_HPP_EAN_27_08_2012 + +#include <boost/range/size.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::size() + struct size + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_size<Rng> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_size<Rng> + {}; + + template<typename Rng> + typename boost::range_size<Rng>::type operator()(Rng const &rng) const + { + return boost::size(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/std.hpp b/3rdParty/Boost/src/boost/proto/functional/std.hpp new file mode 100644 index 0000000..3875860 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/std.hpp @@ -0,0 +1,15 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file std.hpp +/// Proto callables for things found in the std library +// +// Copyright 2010 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_FUNCTIONAL_STD_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_STD_HPP_EAN_11_27_2010 + +#include <boost/proto/functional/std/utility.hpp> +#include <boost/proto/functional/std/iterator.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/std/iterator.hpp b/3rdParty/Boost/src/boost/proto/functional/std/iterator.hpp new file mode 100644 index 0000000..3ee2c25 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/std/iterator.hpp @@ -0,0 +1,158 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file iterator.hpp +/// Proto callables for std functions found in \<iterator\> +// +// Copyright 2012 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_FUNCTIONAL_STD_ITERATOR_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_STD_ITERATOR_HPP_EAN_27_08_2012 + +#include <iterator> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject wrapping std::advance + struct advance + { + BOOST_PROTO_CALLABLE() + + typedef void result_type; + + template<typename InputIterator, typename Distance> + void operator()(InputIterator &x, Distance n) const + { + std::advance(x, n); + } + }; + + // A PolymorphicFunctionObject wrapping std::distance + struct distance + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename InputIter1, typename InputIter2> + struct result<This(InputIter1, InputIter2)> + { + typedef + typename std::iterator_traits< + typename boost::remove_const< + typename boost::remove_reference<InputIter1>::type + >::type + >::difference_type + type; + }; + + template<typename InputIterator> + typename std::iterator_traits<InputIterator>::difference_type + operator()(InputIterator first, InputIterator last) const + { + return std::distance(first, last); + } + }; + + // A PolymorphicFunctionObject wrapping std::next + struct next + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename ForwardIterator> + struct result<This(ForwardIterator)> + { + typedef + typename boost::remove_const< + typename boost::remove_reference<ForwardIterator>::type + >::type + type; + }; + + template<typename This, typename ForwardIterator, typename Distance> + struct result<This(ForwardIterator, Distance)> + { + typedef + typename boost::remove_const< + typename boost::remove_reference<ForwardIterator>::type + >::type + type; + }; + + template<typename ForwardIterator> + ForwardIterator operator()(ForwardIterator x) const + { + return std::advance( + x + , static_cast<typename std::iterator_traits<ForwardIterator>::difference_type>(1) + ); + } + + template<typename ForwardIterator> + ForwardIterator operator()( + ForwardIterator x + , typename std::iterator_traits<ForwardIterator>::difference_type n + ) const + { + return std::advance(x, n); + } + }; + + // A PolymorphicFunctionObject wrapping std::prior + struct prior + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename BidirectionalIterator> + struct result<This(BidirectionalIterator)> + { + typedef + typename boost::remove_const< + typename boost::remove_reference<BidirectionalIterator>::type + >::type + type; + }; + + template<typename This, typename BidirectionalIterator, typename Distance> + struct result<This(BidirectionalIterator, Distance)> + { + typedef + typename boost::remove_const< + typename boost::remove_reference<BidirectionalIterator>::type + >::type + type; + }; + + template<typename BidirectionalIterator> + BidirectionalIterator operator()(BidirectionalIterator x) const + { + return std::advance( + x + , -static_cast<typename std::iterator_traits<BidirectionalIterator>::difference_type>(1) + ); + } + + template<typename BidirectionalIterator> + BidirectionalIterator operator()( + BidirectionalIterator x + , typename std::iterator_traits<BidirectionalIterator>::difference_type n + ) const + { + return std::advance(x, -n); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/std/utility.hpp b/3rdParty/Boost/src/boost/proto/functional/std/utility.hpp new file mode 100644 index 0000000..c1270d3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/std/utility.hpp @@ -0,0 +1,137 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file utility.hpp +/// Proto callables for things found in the std \<utility\> header +// +// Copyright 2010 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_FUNCTIONAL_STD_UTILITY_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_STD_UTILITY_HPP_EAN_11_27_2010 + +#include <utility> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c std::make_pair() algorithm on its arguments. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c std::make_pair() algorithm on its arguments. + struct make_pair + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename First, typename Second> + struct result<This(First, Second)> + { + typedef + std::pair< + typename remove_const<typename remove_reference<First>::type>::type + , typename remove_const<typename remove_reference<Second>::type>::type + > + type; + }; + + template<typename First, typename Second> + std::pair<First, Second> operator()(First const &first, Second const &second) const + { + return std::make_pair(first, second); + } + }; + + /// \brief A PolymorphicFunctionObject type that returns + /// the first element of a std::pair. + /// + /// A PolymorphicFunctionObject type that returns + /// the first element of a std::pair.. + struct first + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Pair> + struct result<This(Pair)> + { + typedef typename Pair::first_type type; + }; + + template<typename This, typename Pair> + struct result<This(Pair &)> + { + typedef typename Pair::first_type &type; + }; + + template<typename This, typename Pair> + struct result<This(Pair const &)> + { + typedef typename Pair::first_type const &type; + }; + + template<typename Pair> + typename Pair::first_type &operator()(Pair &pair) const + { + return pair.first; + } + + template<typename Pair> + typename Pair::first_type const &operator()(Pair const &pair) const + { + return pair.first; + } + }; + + /// \brief A PolymorphicFunctionObject type that returns + /// the second element of a std::pair. + /// + /// A PolymorphicFunctionObject type that returns + /// the second element of a std::pair.. + struct second + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Pair> + struct result<This(Pair)> + { + typedef typename Pair::second_type type; + }; + + template<typename This, typename Pair> + struct result<This(Pair &)> + { + typedef typename Pair::second_type &type; + }; + + template<typename This, typename Pair> + struct result<This(Pair const &)> + { + typedef typename Pair::second_type const &type; + }; + + template<typename Pair> + typename Pair::second_type &operator()(Pair &pair) const + { + return pair.second; + } + + template<typename Pair> + typename Pair::second_type const &operator()(Pair const &pair) const + { + return pair.second; + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/fusion.hpp b/3rdParty/Boost/src/boost/proto/fusion.hpp new file mode 100644 index 0000000..21763d3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/fusion.hpp @@ -0,0 +1,720 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file fusion.hpp +/// Make any Proto expression a valid Fusion sequence +// +// 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_FUSION_HPP_EAN_11_04_2006 +#define BOOST_PROTO_FUSION_HPP_EAN_11_04_2006 + +#include <boost/config.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/long.hpp> +#include <boost/mpl/sequence_tag_fwd.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/fusion/include/is_view.hpp> +#include <boost/fusion/include/tag_of_fwd.hpp> +#include <boost/fusion/include/category_of.hpp> +#include <boost/fusion/include/iterator_base.hpp> +#include <boost/fusion/include/intrinsic.hpp> +#include <boost/fusion/include/single_view.hpp> +#include <boost/fusion/include/transform.hpp> +#include <boost/fusion/include/as_list.hpp> +#include <boost/fusion/include/is_segmented.hpp> +#include <boost/fusion/sequence/comparison/enable_comparison.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/eval.hpp> +#include <boost/proto/make_expr.hpp> + +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable : 4510) // default constructor could not be generated +#pragma warning(disable : 4512) // assignment operator could not be generated +#pragma warning(disable : 4610) // can never be instantiated - user defined constructor required +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template<typename Expr, long Pos> + struct expr_iterator + : fusion::iterator_base<expr_iterator<Expr, Pos> > + { + typedef Expr expr_type; + static const long index = Pos; + typedef fusion::random_access_traversal_tag category; + typedef + tag::proto_expr_iterator< + typename Expr::proto_tag + , typename Expr::proto_domain + > + fusion_tag; + + explicit expr_iterator(Expr &e) + : expr(e) + {} + + Expr &expr; + }; + + template<typename Tag> + struct as_element + { + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + : result<This(Expr const &)> + {}; + + template<typename This, typename Expr> + struct result<This(Expr &)> + : mpl::if_c< + is_same<Tag, typename Expr::proto_tag>::value + , flat_view<Expr> + , fusion::single_view<Expr &> + > + {}; + + template<typename Expr> + typename result<as_element(Expr &)>::type const + operator ()(Expr &e) const + { + return typename result<as_element(Expr &)>::type(e); + } + + template<typename Expr> + typename result<as_element(Expr const &)>::type const + operator ()(Expr const &e) const + { + return typename result<as_element(Expr const &)>::type(e); + } + }; + + template<typename Expr> + struct flat_view + : fusion::sequence_base<flat_view<Expr> > + { + typedef fusion::forward_traversal_tag category; + typedef + tag::proto_flat_view< + typename Expr::proto_tag + , typename Expr::proto_domain + > + fusion_tag; + typedef + typename fusion::result_of::as_list< + typename fusion::result_of::transform< + Expr + , as_element<typename Expr::proto_tag> + >::type + >::type + segments_type; + + explicit flat_view(Expr &e) + : segs_(fusion::as_list(fusion::transform(e, as_element<typename Expr::proto_tag>()))) + {} + + segments_type segs_; + }; + } + + namespace result_of + { + template<typename Expr> + struct flatten + : flatten<Expr const &> + {}; + + template<typename Expr> + struct flatten<Expr &> + { + typedef detail::flat_view<Expr> type; + }; + } + + namespace functional + { + /// \brief A PolymorphicFunctionObject type that returns a "flattened" + /// view of a Proto expression tree. + /// + /// A PolymorphicFunctionObject type that returns a "flattened" + /// view of a Proto expression tree. For a tree with a top-most node + /// tag of type \c T, the elements of the flattened sequence are + /// determined by recursing into each child node with the same + /// tag type and returning those nodes of different type. So for + /// instance, the Proto expression tree corresponding to the + /// expression <tt>a | b | c</tt> has a flattened view with elements + /// [a, b, c], even though the tree is grouped as + /// <tt>((a | b) | c)</tt>. + struct flatten + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + : result<This(Expr const &)> + {}; + + template<typename This, typename Expr> + struct result<This(Expr &)> + { + typedef proto::detail::flat_view<Expr> type; + }; + + template<typename Expr> + proto::detail::flat_view<Expr> const + operator ()(Expr &e) const + { + return proto::detail::flat_view<Expr>(e); + } + + template<typename Expr> + proto::detail::flat_view<Expr const> const + operator ()(Expr const &e) const + { + return proto::detail::flat_view<Expr const>(e); + } + }; + } + + /// \brief A function that returns a "flattened" + /// view of a Proto expression tree. + /// + /// For a tree with a top-most node + /// tag of type \c T, the elements of the flattened sequence are + /// determined by recursing into each child node with the same + /// tag type and returning those nodes of different type. So for + /// instance, the Proto expression tree corresponding to the + /// expression <tt>a | b | c</tt> has a flattened view with elements + /// [a, b, c], even though the tree is grouped as + /// <tt>((a | b) | c)</tt>. + template<typename Expr> + proto::detail::flat_view<Expr> const + flatten(Expr &e) + { + return proto::detail::flat_view<Expr>(e); + } + + /// \overload + /// + template<typename Expr> + proto::detail::flat_view<Expr const> const + flatten(Expr const &e) + { + return proto::detail::flat_view<Expr const>(e); + } + + /// INTERNAL ONLY + /// + template<typename Context> + struct eval_fun + : proto::callable + { + explicit eval_fun(Context &ctx) + : ctx_(ctx) + {} + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + : result<This(Expr const &)> + {}; + + template<typename This, typename Expr> + struct result<This(Expr &)> + : proto::result_of::eval<Expr, Context> + {}; + + template<typename Expr> + typename proto::result_of::eval<Expr, Context>::type + operator ()(Expr &e) const + { + return proto::eval(e, this->ctx_); + } + + template<typename Expr> + typename proto::result_of::eval<Expr const, Context>::type + operator ()(Expr const &e) const + { + return proto::eval(e, this->ctx_); + } + + private: + Context &ctx_; + }; + + /// INTERNAL ONLY + /// + template<typename Context> + struct is_callable<eval_fun<Context> > + : mpl::true_ + {}; +}} + +namespace boost { namespace fusion +{ + namespace extension + { + template<typename Tag> + struct is_sequence_impl; + + template<typename Tag, typename Domain> + struct is_sequence_impl<proto::tag::proto_flat_view<Tag, Domain> > + { + template<typename Sequence> + struct apply + : mpl::true_ + {}; + }; + + template<typename Tag, typename Domain> + struct is_sequence_impl<proto::tag::proto_expr<Tag, Domain> > + { + template<typename Sequence> + struct apply + : mpl::true_ + {}; + }; + + template<typename Tag> + struct is_view_impl; + + template<typename Tag, typename Domain> + struct is_view_impl<proto::tag::proto_flat_view<Tag, Domain> > + { + template<typename Sequence> + struct apply + : mpl::true_ + {}; + }; + + template<typename Tag, typename Domain> + struct is_view_impl<proto::tag::proto_expr<Tag, Domain> > + { + template<typename Sequence> + struct apply + : mpl::false_ + {}; + }; + + template<typename Tag> + struct value_of_impl; + + template<typename Tag, typename Domain> + struct value_of_impl<proto::tag::proto_expr_iterator<Tag, Domain> > + { + template< + typename Iterator + , long Arity = proto::arity_of<typename Iterator::expr_type>::value + > + struct apply + { + typedef + typename proto::result_of::child_c< + typename Iterator::expr_type + , Iterator::index + >::value_type + type; + }; + + template<typename Iterator> + struct apply<Iterator, 0> + { + typedef + typename proto::result_of::value< + typename Iterator::expr_type + >::value_type + type; + }; + }; + + template<typename Tag> + struct deref_impl; + + template<typename Tag, typename Domain> + struct deref_impl<proto::tag::proto_expr_iterator<Tag, Domain> > + { + template< + typename Iterator + , long Arity = proto::arity_of<typename Iterator::expr_type>::value + > + struct apply + { + typedef + typename proto::result_of::child_c< + typename Iterator::expr_type & + , Iterator::index + >::type + type; + + static type call(Iterator const &iter) + { + return proto::child_c<Iterator::index>(iter.expr); + } + }; + + template<typename Iterator> + struct apply<Iterator, 0> + { + typedef + typename proto::result_of::value< + typename Iterator::expr_type & + >::type + type; + + static type call(Iterator const &iter) + { + return proto::value(iter.expr); + } + }; + }; + + template<typename Tag> + struct advance_impl; + + template<typename Tag, typename Domain> + struct advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> > + { + template<typename Iterator, typename N> + struct apply + { + typedef + proto::detail::expr_iterator< + typename Iterator::expr_type + , Iterator::index + N::value + > + type; + + static type call(Iterator const &iter) + { + return type(iter.expr); + } + }; + }; + + template<typename Tag> + struct distance_impl; + + template<typename Tag, typename Domain> + struct distance_impl<proto::tag::proto_expr_iterator<Tag, Domain> > + { + template<typename IteratorFrom, typename IteratorTo> + struct apply + : mpl::long_<IteratorTo::index - IteratorFrom::index> + {}; + }; + + template<typename Tag> + struct next_impl; + + template<typename Tag, typename Domain> + struct next_impl<proto::tag::proto_expr_iterator<Tag, Domain> > + { + template<typename Iterator> + struct apply + : advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >::template apply<Iterator, mpl::long_<1> > + {}; + }; + + template<typename Tag> + struct prior_impl; + + template<typename Tag, typename Domain> + struct prior_impl<proto::tag::proto_expr_iterator<Tag, Domain> > + { + template<typename Iterator> + struct apply + : advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >::template apply<Iterator, mpl::long_<-1> > + {}; + }; + + template<typename Tag> + struct category_of_impl; + + template<typename Tag, typename Domain> + struct category_of_impl<proto::tag::proto_expr<Tag, Domain> > + { + template<typename Sequence> + struct apply + { + typedef random_access_traversal_tag type; + }; + }; + + template<typename Tag> + struct size_impl; + + template<typename Tag, typename Domain> + struct size_impl<proto::tag::proto_expr<Tag, Domain> > + { + template<typename Sequence> + struct apply + : mpl::long_<0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c> + {}; + }; + + template<typename Tag> + struct begin_impl; + + template<typename Tag, typename Domain> + struct begin_impl<proto::tag::proto_expr<Tag, Domain> > + { + template<typename Sequence> + struct apply + { + typedef proto::detail::expr_iterator<Sequence, 0> type; + + static type call(Sequence &seq) + { + return type(seq); + } + }; + }; + + template<typename Tag> + struct end_impl; + + template<typename Tag, typename Domain> + struct end_impl<proto::tag::proto_expr<Tag, Domain> > + { + template<typename Sequence> + struct apply + { + typedef + proto::detail::expr_iterator< + Sequence + , 0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c + > + type; + + static type call(Sequence &seq) + { + return type(seq); + } + }; + }; + + template<typename Tag> + struct value_at_impl; + + template<typename Tag, typename Domain> + struct value_at_impl<proto::tag::proto_expr<Tag, Domain> > + { + template< + typename Sequence + , typename Index + , long Arity = proto::arity_of<Sequence>::value + > + struct apply + { + typedef + typename proto::result_of::child_c< + Sequence + , Index::value + >::value_type + type; + }; + + template<typename Sequence, typename Index> + struct apply<Sequence, Index, 0> + { + typedef + typename proto::result_of::value< + Sequence + >::value_type + type; + }; + }; + + template<typename Tag> + struct at_impl; + + template<typename Tag, typename Domain> + struct at_impl<proto::tag::proto_expr<Tag, Domain> > + { + template< + typename Sequence + , typename Index + , long Arity = proto::arity_of<Sequence>::value + > + struct apply + { + typedef + typename proto::result_of::child_c< + Sequence & + , Index::value + >::type + type; + + static type call(Sequence &seq) + { + return proto::child_c<Index::value>(seq); + } + }; + + template<typename Sequence, typename Index> + struct apply<Sequence, Index, 0> + { + typedef + typename proto::result_of::value< + Sequence & + >::type + type; + + static type call(Sequence &seq) + { + return proto::value(seq); + } + }; + }; + + template<typename Tag> + struct convert_impl; + + template<typename Tag, typename Domain> + struct convert_impl<proto::tag::proto_expr<Tag, Domain> > + { + template<typename Sequence> + struct apply + { + typedef + typename proto::result_of::unpack_expr< + Tag + , Domain + , Sequence + >::type + type; + + static type call(Sequence& seq) + { + return proto::unpack_expr<Tag, Domain>(seq); + } + }; + }; + + template<typename Tag, typename Domain> + struct convert_impl<proto::tag::proto_flat_view<Tag, Domain> > + { + template<typename Sequence> + struct apply + { + typedef + typename proto::result_of::unpack_expr< + Tag + , Domain + , Sequence + >::type + type; + + static type call(Sequence& seq) + { + return proto::unpack_expr<Tag, Domain>(seq); + } + }; + }; + + template<typename Tag> + struct is_segmented_impl; + + template<typename Tag, typename Domain> + struct is_segmented_impl<proto::tag::proto_flat_view<Tag, Domain> > + { + template<typename Iterator> + struct apply + : mpl::true_ + {}; + }; + + template<typename Tag> + struct segments_impl; + + template<typename Tag, typename Domain> + struct segments_impl<proto::tag::proto_flat_view<Tag, Domain> > + { + template<typename Sequence> + struct apply + { + typedef typename Sequence::segments_type const &type; + + static type call(Sequence &sequence) + { + return sequence.segs_; + } + }; + }; + + template<typename Tag, typename Domain> + struct category_of_impl<proto::tag::proto_flat_view<Tag, Domain> > + { + template<typename Sequence> + struct apply + { + typedef forward_traversal_tag type; + }; + }; + } + + namespace traits + { + template<typename Seq1, typename Seq2> + struct enable_equality< + Seq1 + , Seq2 + , typename enable_if_c< + mpl::or_< + proto::is_expr<Seq1> + , proto::is_expr<Seq2> + >::value + >::type + > + : mpl::false_ + {}; + + template<typename Seq1, typename Seq2> + struct enable_comparison< + Seq1 + , Seq2 + , typename enable_if_c< + mpl::or_< + proto::is_expr<Seq1> + , proto::is_expr<Seq2> + >::value + >::type + > + : mpl::false_ + {}; + } +}} + +namespace boost { namespace mpl +{ + template<typename Tag, typename Args, long Arity> + struct sequence_tag< proto::expr<Tag, Args, Arity> > + { + typedef fusion::fusion_sequence_tag type; + }; + + template<typename Tag, typename Args, long Arity> + struct sequence_tag< proto::basic_expr<Tag, Args, Arity> > + { + typedef fusion::fusion_sequence_tag type; + }; +}} + +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/generate.hpp b/3rdParty/Boost/src/boost/proto/generate.hpp new file mode 100644 index 0000000..92a47c4 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/generate.hpp @@ -0,0 +1,470 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file generate.hpp +/// Contains definition of generate\<\> class template, which end users can +/// specialize for generating domain-specific expression wrappers. +// +// Copyright 2008 Eric Niebler. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 +#define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 + +#include <boost/config.hpp> +#include <boost/version.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/args.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + + namespace detail + { + template<typename Expr> + struct by_value_generator_; + + template<typename Tag, typename Arg> + struct by_value_generator_<proto::expr<Tag, term<Arg>, 0> > + { + typedef + proto::expr< + Tag + , term<typename detail::term_traits<Arg>::value_type> + , 0 + > + type; + + BOOST_FORCEINLINE + static type const call(proto::expr<Tag, term<Arg>, 0> const &e) + { + type that = {e.child0}; + return that; + } + }; + + template<typename Tag, typename Arg> + struct by_value_generator_<proto::basic_expr<Tag, term<Arg>, 0> > + { + typedef + proto::basic_expr< + Tag + , term<typename detail::term_traits<Arg>::value_type> + , 0 + > + type; + + BOOST_FORCEINLINE + static type const call(proto::basic_expr<Tag, term<Arg>, 0> const &e) + { + type that = {e.child0}; + return that; + } + }; + + // Include the other specializations of by_value_generator_ + #include <boost/proto/detail/generate_by_value.hpp> + } + + /// \brief Annotate a generator to indicate that it would + /// prefer to be passed instances of \c proto::basic_expr\<\> rather + /// than \c proto::expr\<\>. <tt>use_basic_expr\<Generator\></tt> is + /// itself a generator. + /// + template<typename Generator> + struct use_basic_expr + : Generator + { + BOOST_PROTO_USE_BASIC_EXPR() + }; + + /// \brief A simple generator that passes an expression + /// through unchanged. + /// + /// Generators are intended for use as the first template parameter + /// to the \c domain\<\> class template and control if and how + /// expressions within that domain are to be customized. + /// The \c default_generator makes no modifications to the expressions + /// passed to it. + struct default_generator + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef Expr type; + }; + + /// \param expr A Proto expression + /// \return expr + template<typename Expr> + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(Expr, Expr const &) + operator ()(Expr const &e) const + { + return e; + } + }; + + /// \brief A simple generator that passes an expression + /// through unchanged and specifies a preference for + /// \c proto::basic_expr\<\> over \c proto::expr\<\>. + /// + /// Generators are intended for use as the first template parameter + /// to the \c domain\<\> class template and control if and how + /// expressions within that domain are to be customized. + /// The \c default_generator makes no modifications to the expressions + /// passed to it. + struct basic_default_generator + : proto::use_basic_expr<default_generator> + {}; + + /// \brief A generator that wraps expressions passed + /// to it in the specified extension wrapper. + /// + /// Generators are intended for use as the first template parameter + /// to the \c domain\<\> class template and control if and how + /// expressions within that domain are to be customized. + /// \c generator\<\> wraps each expression passed to it in + /// the \c Extends\<\> wrapper. + template<template<typename> class Extends> + struct generator + { + BOOST_PROTO_CALLABLE() + BOOST_PROTO_USE_BASIC_EXPR() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef Extends<Expr> type; + }; + + template<typename This, typename Expr> + struct result<This(Expr &)> + { + typedef Extends<Expr> type; + }; + + template<typename This, typename Expr> + struct result<This(Expr const &)> + { + typedef Extends<Expr> type; + }; + + /// \param expr A Proto expression + /// \return Extends<Expr>(expr) + template<typename Expr> + BOOST_FORCEINLINE + Extends<Expr> operator ()(Expr const &e) const + { + return Extends<Expr>(e); + } + }; + + /// \brief A generator that wraps expressions passed + /// to it in the specified extension wrapper and uses + /// aggregate initialization for the wrapper. + /// + /// Generators are intended for use as the first template parameter + /// to the \c domain\<\> class template and control if and how + /// expressions within that domain are to be customized. + /// \c pod_generator\<\> wraps each expression passed to it in + /// the \c Extends\<\> wrapper, and uses aggregate initialzation + /// for the wrapped object. + template<template<typename> class Extends> + struct pod_generator + { + BOOST_PROTO_CALLABLE() + BOOST_PROTO_USE_BASIC_EXPR() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef Extends<Expr> type; + }; + + template<typename This, typename Expr> + struct result<This(Expr &)> + { + typedef Extends<Expr> type; + }; + + template<typename This, typename Expr> + struct result<This(Expr const &)> + { + typedef Extends<Expr> type; + }; + + /// \param expr The expression to wrap + /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt> + template<typename Expr> + BOOST_FORCEINLINE + Extends<Expr> operator ()(Expr const &e) const + { + Extends<Expr> that = {e}; + return that; + } + + // Work-around for: + // https://connect.microsoft.com/VisualStudio/feedback/details/765449/codegen-stack-corruption-using-runtime-checks-when-aggregate-initializing-struct + #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700)) + template<typename Class, typename Member> + BOOST_FORCEINLINE + Extends<expr<tag::terminal, proto::term<Member Class::*> > > operator ()(expr<tag::terminal, proto::term<Member Class::*> > const &e) const + { + Extends<expr<tag::terminal, proto::term<Member Class::*> > > that; + proto::value(that.proto_expr_) = proto::value(e); + return that; + } + + template<typename Class, typename Member> + BOOST_FORCEINLINE + Extends<basic_expr<tag::terminal, proto::term<Member Class::*> > > operator ()(basic_expr<tag::terminal, proto::term<Member Class::*> > const &e) const + { + Extends<basic_expr<tag::terminal, proto::term<Member Class::*> > > that; + proto::value(that.proto_expr_) = proto::value(e); + return that; + } + #endif + }; + + /// \brief A generator that replaces child nodes held by + /// reference with ones held by value. Use with + /// \c compose_generators to forward that result to another + /// generator. + /// + /// Generators are intended for use as the first template parameter + /// to the \c domain\<\> class template and control if and how + /// expressions within that domain are to be customized. + /// \c by_value_generator ensures all child nodes are + /// held by value. This generator is typically composed with a + /// second generator for further processing, as + /// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>. + struct by_value_generator + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef + typename detail::by_value_generator_<Expr>::type + type; + }; + + template<typename This, typename Expr> + struct result<This(Expr &)> + { + typedef + typename detail::by_value_generator_<Expr>::type + type; + }; + + template<typename This, typename Expr> + struct result<This(Expr const &)> + { + typedef + typename detail::by_value_generator_<Expr>::type + type; + }; + + /// \param expr The expression to modify. + /// \return <tt>deep_copy(expr)</tt> + template<typename Expr> + BOOST_FORCEINLINE + typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const + { + return detail::by_value_generator_<Expr>::call(e); + } + }; + + /// \brief A composite generator that first applies one + /// transform to an expression and then forwards the result + /// on to another generator for further transformation. + /// + /// Generators are intended for use as the first template parameter + /// to the \c domain\<\> class template and control if and how + /// expressions within that domain are to be customized. + /// \c compose_generators\<\> is a composite generator that first + /// applies one transform to an expression and then forwards the + /// result on to another generator for further transformation. + template<typename First, typename Second> + struct compose_generators + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef + typename Second::template result< + Second(typename First::template result<First(Expr)>::type) + >::type + type; + }; + + template<typename This, typename Expr> + struct result<This(Expr &)> + { + typedef + typename Second::template result< + Second(typename First::template result<First(Expr)>::type) + >::type + type; + }; + + template<typename This, typename Expr> + struct result<This(Expr const &)> + { + typedef + typename Second::template result< + Second(typename First::template result<First(Expr)>::type) + >::type + type; + }; + + /// \param expr The expression to modify. + /// \return Second()(First()(expr)) + template<typename Expr> + BOOST_FORCEINLINE + typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const + { + return Second()(First()(e)); + } + }; + + /// \brief Tests a generator to see whether it would prefer + /// to be passed instances of \c proto::basic_expr\<\> rather than + /// \c proto::expr\<\>. + /// + template<typename Generator, typename Void> + struct wants_basic_expr + : mpl::false_ + {}; + + template<typename Generator> + struct wants_basic_expr<Generator, typename Generator::proto_use_basic_expr_> + : mpl::true_ + {}; + + /// INTERNAL ONLY + template<> + struct is_callable<default_generator> + : mpl::true_ + {}; + + /// INTERNAL ONLY + template<template<typename> class Extends> + struct is_callable<generator<Extends> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + template<template<typename> class Extends> + struct is_callable<pod_generator<Extends> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + template<> + struct is_callable<by_value_generator> + : mpl::true_ + {}; + + /// INTERNAL ONLY + template<typename First, typename Second> + struct is_callable<compose_generators<First, Second> > + : mpl::true_ + {}; + +}} + +// Specializations of boost::result_of and boost::tr1_result_of to eliminate +// some unnecessary template instantiations +namespace boost +{ + template<typename Expr> + struct result_of<proto::default_domain(Expr)> + { + typedef Expr type; + }; + + template<typename Expr> + struct result_of<proto::basic_default_domain(Expr)> + { + typedef Expr type; + }; + + template<typename Expr> + struct result_of<proto::default_generator(Expr)> + { + typedef Expr type; + }; + + template<typename Expr> + struct result_of<proto::basic_default_generator(Expr)> + { + typedef Expr type; + }; + + #if BOOST_VERSION >= 104400 + template<typename Expr> + struct tr1_result_of<proto::default_domain(Expr)> + { + typedef Expr type; + }; + + template<typename Expr> + struct tr1_result_of<proto::basic_default_domain(Expr)> + { + typedef Expr type; + }; + + template<typename Expr> + struct tr1_result_of<proto::default_generator(Expr)> + { + typedef Expr type; + }; + + template<typename Expr> + struct tr1_result_of<proto::basic_default_generator(Expr)> + { + typedef Expr type; + }; + #endif +} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif // BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 diff --git a/3rdParty/Boost/src/boost/proto/literal.hpp b/3rdParty/Boost/src/boost/proto/literal.hpp new file mode 100644 index 0000000..accab5f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/literal.hpp @@ -0,0 +1,112 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file literal.hpp +/// The literal\<\> terminal wrapper, and the proto::lit() function for +/// creating literal\<\> wrappers. +// +// Copyright 2008 Eric Niebler. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PROTO_LITERAL_HPP_EAN_01_03_2007 +#define BOOST_PROTO_LITERAL_HPP_EAN_01_03_2007 + +#include <boost/config.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/expr.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/extends.hpp> + +namespace boost { namespace proto +{ + namespace utility + { + /// \brief A simple wrapper for a terminal, provided for + /// ease of use. + /// + /// A simple wrapper for a terminal, provided for + /// ease of use. In all cases, <tt>literal\<X\> l(x);</tt> + /// is equivalent to <tt>terminal\<X\>::type l = {x};</tt>. + /// + /// The \c Domain template parameter defaults to + /// \c proto::default_domain. + template< + typename T + , typename Domain // = default_domain + > + struct literal + : extends<basic_expr<tag::terminal, term<T>, 0>, literal<T, Domain>, Domain> + { + private: + typedef basic_expr<tag::terminal, term<T>, 0> terminal_type; + typedef extends<terminal_type, literal<T, Domain>, Domain> base_type; + typedef literal<T, Domain> literal_t; + + public: + typedef typename detail::term_traits<T>::value_type value_type; + typedef typename detail::term_traits<T>::reference reference; + typedef typename detail::term_traits<T>::const_reference const_reference; + + literal() + : base_type(terminal_type::make(T())) + {} + + template<typename U> + literal(U &u) + : base_type(terminal_type::make(u)) + {} + + template<typename U> + literal(U const &u) + : base_type(terminal_type::make(u)) + {} + + template<typename U> + literal(literal<U, Domain> const &u) + : base_type(terminal_type::make(u.get())) + {} + + BOOST_PROTO_EXTENDS_USING_ASSIGN(literal_t) + + reference get() + { + return proto::value(*this); + } + + const_reference get() const + { + return proto::value(*this); + } + }; + } + + /// \brief A helper function for creating a \c literal\<\> wrapper. + /// \param t The object to wrap. + /// \return literal\<T &\>(t) + /// \attention The returned value holds the argument by reference. + /// \throw nothrow + template<typename T> + inline literal<T &> const lit(T &t) + { + return literal<T &>(t); + } + + /// \overload + /// + template<typename T> + inline literal<T const &> const lit(T const &t) + { + #ifdef BOOST_MSVC + #pragma warning(push) + #pragma warning(disable: 4180) // warning C4180: qualifier applied to function type has no meaning; ignored + #endif + + return literal<T const &>(t); + + #ifdef BOOST_MSVC + #pragma warning(pop) + #endif + } + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/make_expr.hpp b/3rdParty/Boost/src/boost/proto/make_expr.hpp new file mode 100644 index 0000000..08ef2f5 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/make_expr.hpp @@ -0,0 +1,509 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file make_expr.hpp +/// Definition of the \c make_expr() and \c unpack_expr() utilities for +/// building Proto expression nodes from child nodes or from a Fusion +/// sequence of child nodes, respectively. +// +// 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_MAKE_EXPR_HPP_EAN_04_01_2005 +#define BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/punctuation/comma_if.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_shifted_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/ref.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_reference.hpp> +#include <boost/type_traits/remove_cv.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/domain.hpp> +#include <boost/proto/generate.hpp> +#include <boost/fusion/include/at_c.hpp> +#include <boost/fusion/include/begin.hpp> +#include <boost/fusion/include/next.hpp> +#include <boost/fusion/include/value_of.hpp> +#include <boost/fusion/include/size.hpp> +#include <boost/proto/detail/poly_function.hpp> +#include <boost/proto/detail/deprecated.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4180) // qualifier applied to function type has no meaning; ignored +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ +/// INTERNAL ONLY +/// +#define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA) \ + typename boost::proto::detail::protoify< \ + BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N) \ + , BOOST_PP_TUPLE_ELEM(3, 2, DATA) \ + >::result_type \ + /**/ + +/// INTERNAL ONLY +/// +#define BOOST_PROTO_AS_CHILD(Z, N, DATA) \ + boost::proto::detail::protoify< \ + BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N) \ + , BOOST_PP_TUPLE_ELEM(3, 2, DATA) \ + >()(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, DATA), N)) \ + /**/ + + namespace detail + { + template<typename T, typename Domain> + struct protoify + : Domain::template as_expr<T> + {}; + + template<typename T, typename Domain> + struct protoify<T &, Domain> + : Domain::template as_child<T> + {}; + + template<typename T, typename Domain> + struct protoify<boost::reference_wrapper<T>, Domain> + : Domain::template as_child<T> + {}; + + template<typename T, typename Domain> + struct protoify<boost::reference_wrapper<T> const, Domain> + : Domain::template as_child<T> + {}; + + // Definition of detail::unpack_expr_ + #include <boost/proto/detail/unpack_expr_.hpp> + + // Definition of detail::make_expr_ + #include <boost/proto/detail/make_expr_.hpp> + } + + namespace result_of + { + /// \brief Metafunction that computes the return type of the + /// \c make_expr() function, with a domain deduced from the + /// domains of the children. + /// + /// Use the <tt>result_of::make_expr\<\></tt> metafunction to + /// compute the return type of the \c make_expr() function. + /// + /// In this specialization, the domain is deduced from the + /// domains of the child types. (If + /// <tt>is_domain\<A0\>::value</tt> is \c true, then another + /// specialization is selected.) + template< + typename Tag + , BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename A) + , typename Void1 // = void + , typename Void2 // = void + > + struct make_expr + { + /// Same as <tt>result_of::make_expr\<Tag, D, A0, ... AN\>::type</tt> + /// where \c D is the deduced domain, which is calculated as follows: + /// + /// For each \c x in <tt>[0,N)</tt> (proceeding in order beginning with + /// <tt>x=0</tt>), if <tt>domain_of\<Ax\>::type</tt> is not + /// \c default_domain, then \c D is <tt>domain_of\<Ax\>::type</tt>. + /// Otherwise, \c D is \c default_domain. + typedef + typename detail::make_expr_< + Tag + , deduce_domain + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A) + >::result_type + type; + }; + + /// \brief Metafunction that computes the return type of the + /// \c make_expr() function, within the specified domain. + /// + /// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute + /// the return type of the \c make_expr() function. + template< + typename Tag + , typename Domain + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, typename A) + > + struct make_expr< + Tag + , Domain + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A) + , typename Domain::proto_is_domain_ + > + { + /// If \c Tag is <tt>tag::terminal</tt>, then \c type is a + /// typedef for <tt>boost::result_of\<Domain(expr\<tag::terminal, + /// term\<A0\> \>)\>::type</tt>. + /// + /// Otherwise, \c type is a typedef for <tt>boost::result_of\<Domain(expr\<Tag, + /// listN\< as_child\<A0\>::type, ... as_child\<AN\>::type\>) + /// \>::type</tt>, where \c N is the number of non-void template + /// arguments, and <tt>as_child\<A\>::type</tt> is evaluated as + /// follows: + /// + /// \li If <tt>is_expr\<A\>::value</tt> is \c true, then the + /// child type is \c A. + /// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>, + /// and <tt>is_expr\<B\>::value</tt> is \c true, then the + /// child type is <tt>B &</tt>. + /// \li If <tt>is_expr\<A\>::value</tt> is \c false, then the + /// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<A\> \> + /// )\>::type</tt>. + /// \li If \c A is <tt>B &</tt> or <tt>cv boost::reference_wrapper\<B\></tt>, + /// and <tt>is_expr\<B\>::value</tt> is \c false, then the + /// child type is <tt>boost::result_of\<Domain(expr\<tag::terminal, term\<B &\> \> + /// )\>::type</tt>. + typedef + typename detail::make_expr_< + Tag + , Domain + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A) + >::result_type + type; + }; + + /// \brief Metafunction that computes the return type of the + /// \c unpack_expr() function, with a domain deduced from the + /// domains of the children. + /// + /// Use the <tt>result_of::unpack_expr\<\></tt> metafunction to + /// compute the return type of the \c unpack_expr() function. + /// + /// \c Sequence is a Fusion Forward Sequence. + /// + /// In this specialization, the domain is deduced from the + /// domains of the child types. (If + /// <tt>is_domain\<Sequence>::value</tt> is \c true, then another + /// specialization is selected.) + template< + typename Tag + , typename Sequence + , typename Void1 // = void + , typename Void2 // = void + > + struct unpack_expr + { + /// Let \c S be the type of a Fusion Random Access Sequence + /// equivalent to \c Sequence. Then \c type is the + /// same as <tt>result_of::make_expr\<Tag, + /// fusion::result_of::value_at_c\<S, 0\>::type, ... + /// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>, + /// where \c N is the size of \c S. + typedef + typename detail::unpack_expr_< + Tag + , deduce_domain + , Sequence + , fusion::result_of::size<Sequence>::type::value + >::type + type; + }; + + /// \brief Metafunction that computes the return type of the + /// \c unpack_expr() function, within the specified domain. + /// + /// Use the <tt>result_of::make_expr\<\></tt> metafunction to compute + /// the return type of the \c make_expr() function. + template<typename Tag, typename Domain, typename Sequence> + struct unpack_expr<Tag, Domain, Sequence, typename Domain::proto_is_domain_> + { + /// Let \c S be the type of a Fusion Random Access Sequence + /// equivalent to \c Sequence. Then \c type is the + /// same as <tt>result_of::make_expr\<Tag, Domain, + /// fusion::result_of::value_at_c\<S, 0\>::type, ... + /// fusion::result_of::value_at_c\<S, N-1\>::type\>::type</tt>, + /// where \c N is the size of \c S. + typedef + typename detail::unpack_expr_< + Tag + , Domain + , Sequence + , fusion::result_of::size<Sequence>::type::value + >::type + type; + }; + } + + namespace functional + { + /// \brief A callable function object equivalent to the + /// \c proto::make_expr() function. + /// + /// In all cases, <tt>functional::make_expr\<Tag, Domain\>()(a0, ... aN)</tt> + /// is equivalent to <tt>proto::make_expr\<Tag, Domain\>(a0, ... aN)</tt>. + /// + /// <tt>functional::make_expr\<Tag\>()(a0, ... aN)</tt> + /// is equivalent to <tt>proto::make_expr\<Tag\>(a0, ... aN)</tt>. + template<typename Tag, typename Domain /* = deduce_domain*/> + struct make_expr + { + BOOST_PROTO_CALLABLE() + BOOST_PROTO_POLY_FUNCTION() + + template<typename Sig> + struct result; + + template<typename This, typename A0> + struct result<This(A0)> + { + typedef + typename result_of::make_expr< + Tag + , Domain + , A0 + >::type + type; + }; + + /// Construct an expression node with tag type \c Tag + /// and in the domain \c Domain. + /// + /// \return <tt>proto::make_expr\<Tag, Domain\>(a0,...aN)</tt> + template<typename A0> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , A0 const + >::type const + operator ()(A0 const &a0) const + { + return proto::detail::make_expr_< + Tag + , Domain + , A0 const + >()(a0); + } + + // Additional overloads generated by the preprocessor ... + #include <boost/proto/detail/make_expr_funop.hpp> + + /// INTERNAL ONLY + /// + template< + BOOST_PP_ENUM_BINARY_PARAMS( + BOOST_PROTO_MAX_ARITY + , typename A + , = void BOOST_PP_INTERCEPT + ) + > + struct impl + : detail::make_expr_< + Tag + , Domain + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A) + > + {}; + }; + + /// \brief A callable function object equivalent to the + /// \c proto::unpack_expr() function. + /// + /// In all cases, <tt>functional::unpack_expr\<Tag, Domain\>()(seq)</tt> + /// is equivalent to <tt>proto::unpack_expr\<Tag, Domain\>(seq)</tt>. + /// + /// <tt>functional::unpack_expr\<Tag\>()(seq)</tt> + /// is equivalent to <tt>proto::unpack_expr\<Tag\>(seq)</tt>. + template<typename Tag, typename Domain /* = deduce_domain*/> + struct unpack_expr + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Sequence> + struct result<This(Sequence)> + { + typedef + typename result_of::unpack_expr< + Tag + , Domain + , typename remove_reference<Sequence>::type + >::type + type; + }; + + /// Construct an expression node with tag type \c Tag + /// and in the domain \c Domain. + /// + /// \param sequence A Fusion Forward Sequence + /// \return <tt>proto::unpack_expr\<Tag, Domain\>(sequence)</tt> + template<typename Sequence> + BOOST_FORCEINLINE + typename result_of::unpack_expr<Tag, Domain, Sequence const>::type const + operator ()(Sequence const &sequence) const + { + return proto::detail::unpack_expr_< + Tag + , Domain + , Sequence const + , fusion::result_of::size<Sequence>::type::value + >::call(sequence); + } + }; + + } // namespace functional + + /// \brief Construct an expression of the requested tag type + /// with a domain and with the specified arguments as children. + /// + /// This function template may be invoked either with or without + /// specifying a \c Domain argument. If no domain is specified, + /// the domain is deduced by examining in order the domains of + /// the given arguments and taking the first that is not + /// \c default_domain, if any such domain exists, or + /// \c default_domain otherwise. + /// + /// Let \c wrap_(x) be defined such that: + /// \li If \c x is a <tt>boost::reference_wrapper\<\></tt>, + /// \c wrap_(x) is equivalent to <tt>as_child\<Domain\>(x.get())</tt>. + /// \li Otherwise, \c wrap_(x) is equivalent to + /// <tt>as_expr\<Domain\>(x)</tt>. + /// + /// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as + /// <tt>expr\<Tag, listN\<C0,...CN\> \>::make(c0,...cN)</tt> + /// where \c Bx is the type of \c bx. + /// + /// \return <tt>Domain()(make_\<Tag\>(wrap_(a0),...wrap_(aN)))</tt>. + template<typename Tag, typename A0> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<A0> + , result_of::make_expr< + Tag + , A0 const + > + >::type const + make_expr(A0 const &a0) + { + return proto::detail::make_expr_< + Tag + , deduce_domain + , A0 const + >()(a0); + } + + /// \overload + /// + template<typename Tag, typename Domain, typename C0> + BOOST_FORCEINLINE + typename result_of::make_expr< + Tag + , Domain + , C0 const + >::type const + make_expr(C0 const &c0) + { + return proto::detail::make_expr_< + Tag + , Domain + , C0 const + >()(c0); + } + + // Additional overloads generated by the preprocessor... + #include <boost/proto/detail/make_expr.hpp> + + /// \brief Construct an expression of the requested tag type + /// with a domain and with childres from the specified Fusion + /// Forward Sequence. + /// + /// This function template may be invoked either with or without + /// specifying a \c Domain argument. If no domain is specified, + /// the domain is deduced by examining in order the domains of the + /// elements of \c sequence and taking the first that is not + /// \c default_domain, if any such domain exists, or + /// \c default_domain otherwise. + /// + /// Let \c s be a Fusion Random Access Sequence equivalent to \c sequence. + /// Let <tt>wrap_\<N\>(s)</tt>, where \c s has type \c S, be defined + /// such that: + /// \li If <tt>fusion::result_of::value_at_c\<S,N\>::type</tt> is a reference, + /// <tt>wrap_\<N\>(s)</tt> is equivalent to + /// <tt>as_child\<Domain\>(fusion::at_c\<N\>(s))</tt>. + /// \li Otherwise, <tt>wrap_\<N\>(s)</tt> is equivalent to + /// <tt>as_expr\<Domain\>(fusion::at_c\<N\>(s))</tt>. + /// + /// Let <tt>make_\<Tag\>(b0,...bN)</tt> be defined as + /// <tt>expr\<Tag, listN\<B0,...BN\> \>::make(b0,...bN)</tt> + /// where \c Bx is the type of \c bx. + /// + /// \param sequence a Fusion Forward Sequence. + /// \return <tt>Domain()(make_\<Tag\>(wrap_\<0\>(s),...wrap_\<N-1\>(s)))</tt>, + /// where N is the size of \c Sequence. + template<typename Tag, typename Sequence> + BOOST_FORCEINLINE + typename lazy_disable_if< + is_domain<Sequence> + , result_of::unpack_expr<Tag, Sequence const> + >::type const + unpack_expr(Sequence const &sequence) + { + return proto::detail::unpack_expr_< + Tag + , deduce_domain + , Sequence const + , fusion::result_of::size<Sequence>::type::value + >::call(sequence); + } + + /// \overload + /// + template<typename Tag, typename Domain, typename Sequence2> + BOOST_FORCEINLINE + typename result_of::unpack_expr<Tag, Domain, Sequence2 const>::type const + unpack_expr(Sequence2 const &sequence2) + { + return proto::detail::unpack_expr_< + Tag + , Domain + , Sequence2 const + , fusion::result_of::size<Sequence2>::type::value + >::call(sequence2); + } + + /// INTERNAL ONLY + /// + template<typename Tag, typename Domain> + struct is_callable<functional::make_expr<Tag, Domain> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Tag, typename Domain> + struct is_callable<functional::unpack_expr<Tag, Domain> > + : mpl::true_ + {}; + +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005 diff --git a/3rdParty/Boost/src/boost/proto/matches.hpp b/3rdParty/Boost/src/boost/proto/matches.hpp new file mode 100644 index 0000000..38ff962 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/matches.hpp @@ -0,0 +1,947 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file matches.hpp +/// Contains definition of matches\<\> metafunction for determining if +/// a given expression matches a given pattern. +// +// 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_MATCHES_HPP_EAN_11_03_2006 +#define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006 + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/punctuation/comma_if.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_shifted.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_shifted_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/config.hpp> +#include <boost/mpl/logical.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/proto/detail/template_arity.hpp> +#include <boost/utility/enable_if.hpp> +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) +#include <boost/type_traits/is_array.hpp> +#endif +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/is_reference.hpp> +#include <boost/type_traits/is_pointer.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/transform/when.hpp> +#include <boost/proto/transform/impl.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable:4305) // 'specialization' : truncation from 'const int' to 'bool' +#endif + +#define BOOST_PROTO_LOGICAL_typename_G BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G) +#define BOOST_PROTO_LOGICAL_G BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G) + +namespace boost { namespace proto +{ + + namespace detail + { + template<typename Expr, typename BasicExpr, typename Grammar> + struct matches_; + + template<bool B, typename Pred> + struct and_2; + + template<typename And, typename Expr, typename State, typename Data> + struct _and_impl; + + template<typename T, typename U> + struct array_matches + : mpl::false_ + {}; + + template<typename T, std::size_t M> + struct array_matches<T[M], T *> + : mpl::true_ + {}; + + template<typename T, std::size_t M> + struct array_matches<T[M], T const *> + : mpl::true_ + {}; + + template<typename T, std::size_t M> + struct array_matches<T[M], T[proto::N]> + : mpl::true_ + {}; + + template<typename T, typename U + BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<U>::value) + > + struct lambda_matches + : mpl::false_ + {}; + + template<typename T> + struct lambda_matches<T, proto::_ BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> + : mpl::true_ + {}; + + template<typename T> + struct lambda_matches<T, T BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> + : mpl::true_ + {}; + + template<typename T, std::size_t M, typename U> + struct lambda_matches<T[M], U BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> + : array_matches<T[M], U> + {}; + + template<typename T, std::size_t M> + struct lambda_matches<T[M], _ BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> + : mpl::true_ + {}; + + template<typename T, std::size_t M> + struct lambda_matches<T[M], T[M] BOOST_PROTO_TEMPLATE_ARITY_PARAM(-1)> + : mpl::true_ + {}; + + template<template<typename> class T, typename Expr0, typename Grammar0> + struct lambda_matches<T<Expr0>, T<Grammar0> BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) > + : lambda_matches<Expr0, Grammar0> + {}; + + // vararg_matches_impl + template<typename Args1, typename Back, long From, long To> + struct vararg_matches_impl; + + // vararg_matches + template<typename Expr, typename Args1, typename Args2, typename Back, bool Can, bool Zero, typename Void = void> + struct vararg_matches + : mpl::false_ + {}; + + template<typename Expr, typename Args1, typename Args2, typename Back> + struct vararg_matches<Expr, Args1, Args2, Back, true, true, typename Back::proto_is_vararg_> + : matches_< + Expr + , proto::basic_expr<ignore, Args1, Args1::arity> + , proto::basic_expr<ignore, Args2, Args1::arity> + > + {}; + + template<typename Expr, typename Args1, typename Args2, typename Back> + struct vararg_matches<Expr, Args1, Args2, Back, true, false, typename Back::proto_is_vararg_> + : and_2< + matches_< + Expr + , proto::basic_expr<ignore, Args1, Args2::arity> + , proto::basic_expr<ignore, Args2, Args2::arity> + >::value + , vararg_matches_impl<Args1, typename Back::proto_grammar, Args2::arity + 1, Args1::arity> + > + {}; + + // How terminal_matches<> handles references and cv-qualifiers. + // The cv and ref matter *only* if the grammar has a top-level ref. + // + // Expr | Grammar | Matches? + // ------------------------------------- + // T T yes + // T & T yes + // T const & T yes + // T T & no + // T & T & yes + // T const & T & no + // T T const & no + // T & T const & no + // T const & T const & yes + + template<typename T, typename U> + struct is_cv_ref_compatible + : mpl::true_ + {}; + + template<typename T, typename U> + struct is_cv_ref_compatible<T, U &> + : mpl::false_ + {}; + + template<typename T, typename U> + struct is_cv_ref_compatible<T &, U &> + : mpl::bool_<is_const<T>::value == is_const<U>::value> + {}; + + #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + // MSVC-7.1 has lots of problems with array types that have been + // deduced. Partially specializing terminal_matches<> on array types + // doesn't seem to work. + template< + typename T + , typename U + , bool B = is_array<BOOST_PROTO_UNCVREF(T)>::value + > + struct terminal_array_matches + : mpl::false_ + {}; + + template<typename T, typename U, std::size_t M> + struct terminal_array_matches<T, U(&)[M], true> + : is_convertible<T, U(&)[M]> + {}; + + template<typename T, typename U> + struct terminal_array_matches<T, U(&)[proto::N], true> + : is_convertible<T, U *> + {}; + + template<typename T, typename U> + struct terminal_array_matches<T, U *, true> + : is_convertible<T, U *> + {}; + + // terminal_matches + template<typename T, typename U> + struct terminal_matches + : mpl::or_< + mpl::and_< + is_cv_ref_compatible<T, U> + , lambda_matches< + BOOST_PROTO_UNCVREF(T) + , BOOST_PROTO_UNCVREF(U) + > + > + , terminal_array_matches<T, U> + > + {}; + #else + // terminal_matches + template<typename T, typename U> + struct terminal_matches + : mpl::and_< + is_cv_ref_compatible<T, U> + , lambda_matches< + BOOST_PROTO_UNCVREF(T) + , BOOST_PROTO_UNCVREF(U) + > + > + {}; + + template<typename T, std::size_t M> + struct terminal_matches<T(&)[M], T(&)[proto::N]> + : mpl::true_ + {}; + + template<typename T, std::size_t M> + struct terminal_matches<T(&)[M], T *> + : mpl::true_ + {}; + + // Avoid ambiguity errors on MSVC + #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) + template<typename T, std::size_t M> + struct terminal_matches<T const (&)[M], T const[M]> + : mpl::true_ + {}; + #endif + #endif + + template<typename T> + struct terminal_matches<T, T> + : mpl::true_ + {}; + + template<typename T> + struct terminal_matches<T &, T> + : mpl::true_ + {}; + + template<typename T> + struct terminal_matches<T const &, T> + : mpl::true_ + {}; + + template<typename T> + struct terminal_matches<T, proto::_> + : mpl::true_ + {}; + + template<typename T> + struct terminal_matches<T, exact<T> > + : mpl::true_ + {}; + + template<typename T, typename U> + struct terminal_matches<T, proto::convertible_to<U> > + : is_convertible<T, U> + {}; + + // matches_ + template<typename Expr, typename BasicExpr, typename Grammar> + struct matches_ + : mpl::false_ + {}; + + template<typename Expr, typename BasicExpr> + struct matches_< Expr, BasicExpr, proto::_ > + : mpl::true_ + {}; + + template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<Tag, Args2, N2> > + : vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) > + {}; + + template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<proto::_, Args2, N2> > + : vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) > + {}; + + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<Tag, Args2, 0> > + : terminal_matches<typename Args1::child0, typename Args2::child0> + {}; + + template<typename Expr, typename Tag, typename Args1, typename Args2, long N2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, N2> > + : mpl::false_ + {}; + + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, 0> > + : terminal_matches<typename Args1::child0, typename Args2::child0> + {}; + + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<Tag, Args2, 1> > + : matches_< + typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar + , typename Args2::child0::proto_grammar + > + {}; + + template<typename Expr, typename Tag, typename Args1, typename Args2> + struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<proto::_, Args2, 1> > + : matches_< + typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr + , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar + , typename Args2::child0::proto_grammar + > + {}; + + #include <boost/proto/detail/and_n.hpp> + #include <boost/proto/detail/or_n.hpp> + #include <boost/proto/detail/matches_.hpp> + #include <boost/proto/detail/vararg_matches_impl.hpp> + #include <boost/proto/detail/lambda_matches.hpp> + + // handle proto::if_ + template<typename Expr, typename Tag, typename Args, long Arity, typename If, typename Then, typename Else> + struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, proto::if_<If, Then, Else> > + : mpl::eval_if_c< + static_cast<bool>( + remove_reference< + typename when<_, If>::template impl<Expr, int, int>::result_type + >::type::value + ) + , matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Then::proto_grammar> + , matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Else::proto_grammar> + >::type + { + typedef + typename mpl::if_c< + static_cast<bool>( + remove_reference< + typename when<_, If>::template impl<Expr, int, int>::result_type + >::type::value + ) + , Then + , Else + >::type + which; + }; + + // handle degenerate cases of proto::or_ + template<typename Expr, typename BasicExpr> + struct matches_<Expr, BasicExpr, or_<> > + : mpl::false_ + { + typedef not_<_> which; + }; + + template<typename Expr, typename BasicExpr, typename G0> + struct matches_<Expr, BasicExpr, or_<G0> > + : matches_<Expr, BasicExpr, typename G0::proto_grammar> + { + typedef G0 which; + }; + + // handle degenerate cases of proto::and_ + template<typename Expr, typename BasicExpr> + struct matches_<Expr, BasicExpr, and_<> > + : mpl::true_ + {}; + + template<typename Expr, typename BasicExpr, typename G0> + struct matches_<Expr, BasicExpr, and_<G0> > + : matches_<Expr, BasicExpr, typename G0::proto_grammar> + {}; + + // handle proto::not_ + template<typename Expr, typename BasicExpr, typename Grammar> + struct matches_<Expr, BasicExpr, not_<Grammar> > + : mpl::not_<matches_<Expr, BasicExpr, typename Grammar::proto_grammar> > + {}; + + // handle proto::switch_ + template<typename Expr, typename Tag, typename Args, long Arity, typename Cases, typename Transform> + struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases, Transform> > + : matches_< + Expr + , proto::basic_expr<Tag, Args, Arity> + , typename Cases::template case_< + typename when<_,Transform>::template impl<Expr,int,int>::result_type + >::proto_grammar + > + { + typedef + typename Cases::template case_< + typename when<_, Transform>::template impl<Expr, int, int>::result_type + > + which; + }; + + // handle proto::switch_ with the default Transform for specially for better compile times + template<typename Expr, typename Tag, typename Args, long Arity, typename Cases> + struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases> > + : matches_< + Expr + , proto::basic_expr<Tag, Args, Arity> + , typename Cases::template case_<Tag>::proto_grammar + > + { + typedef typename Cases::template case_<Tag> which; + }; + } + + /// \brief A Boolean metafunction that evaluates whether a given + /// expression type matches a grammar. + /// + /// <tt>matches\<Expr,Grammar\></tt> inherits (indirectly) from + /// \c mpl::true_ if <tt>Expr::proto_grammar</tt> matches + /// <tt>Grammar::proto_grammar</tt>, and from \c mpl::false_ + /// otherwise. + /// + /// Non-terminal expressions are matched against a grammar + /// according to the following rules: + /// + /// \li The wildcard pattern, \c _, matches any expression. + /// \li An expression <tt>expr\<AT, listN\<A0,A1,...An\> \></tt> + /// matches a grammar <tt>expr\<BT, listN\<B0,B1,...Bn\> \></tt> + /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx for + /// each \c x in <tt>[0,n)</tt>. + /// \li An expression <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt> + /// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt> + /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx + /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V + /// for each \c x in <tt>[0,m)</tt>. + /// \li An expression \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E + /// matches some \c Bx for \c x in <tt>[0,n)</tt>. + /// \li An expression \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E + /// matches all \c Bx for \c x in <tt>[0,n)</tt>. + /// \li An expression \c E matches <tt>if_\<T,U,V\></tt> if + /// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt> + /// is \c true and \c E matches \c U; or, if + /// <tt>boost::result_of\<when\<_,T\>(E,int,int)\>::type::value</tt> + /// is \c false and \c E matches \c V. (Note: \c U defaults to \c _ + /// and \c V defaults to \c not_\<_\>.) + /// \li An expression \c E matches <tt>not_\<T\></tt> if \c E does + /// not match \c T. + /// \li An expression \c E matches <tt>switch_\<C,T\></tt> if + /// \c E matches <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>. + /// (Note: T defaults to <tt>tag_of\<_\>()</tt>.) + /// + /// A terminal expression <tt>expr\<AT,term\<A\> \></tt> matches + /// a grammar <tt>expr\<BT,term\<B\> \></tt> if \c BT is \c AT or + /// \c proto::_ and if one of the following is true: + /// + /// \li \c B is the wildcard pattern, \c _ + /// \li \c A is \c B + /// \li \c A is <tt>B &</tt> + /// \li \c A is <tt>B const &</tt> + /// \li \c B is <tt>exact\<A\></tt> + /// \li \c B is <tt>convertible_to\<X\></tt> and + /// <tt>is_convertible\<A,X\>::value</tt> is \c true. + /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and + /// \c B is <tt>X[proto::N]</tt>. + /// \li \c A is <tt>X(&)[M]</tt> and \c B is <tt>X(&)[proto::N]</tt>. + /// \li \c A is <tt>X[M]</tt> or <tt>X(&)[M]</tt> and + /// \c B is <tt>X*</tt>. + /// \li \c B lambda-matches \c A (see below). + /// + /// A type \c B lambda-matches \c A if one of the following is true: + /// + /// \li \c B is \c A + /// \li \c B is the wildcard pattern, \c _ + /// \li \c B is <tt>T\<B0,B1,...Bn\></tt> and \c A is + /// <tt>T\<A0,A1,...An\></tt> and for each \c x in + /// <tt>[0,n)</tt>, \c Ax and \c Bx are types + /// such that \c Ax lambda-matches \c Bx + template<typename Expr, typename Grammar> + struct matches + : detail::matches_< + typename Expr::proto_derived_expr + , typename Expr::proto_grammar + , typename Grammar::proto_grammar + > + {}; + + /// INTERNAL ONLY + /// + template<typename Expr, typename Grammar> + struct matches<Expr &, Grammar> + : detail::matches_< + typename Expr::proto_derived_expr + , typename Expr::proto_grammar + , typename Grammar::proto_grammar + > + {}; + + /// \brief A wildcard grammar element that matches any expression, + /// and a transform that returns the current expression unchanged. + /// + /// The wildcard type, \c _, is a grammar element such that + /// <tt>matches\<E,_\>::value</tt> is \c true for any expression + /// type \c E. + /// + /// The wildcard can also be used as a stand-in for a template + /// argument when matching terminals. For instance, the following + /// is a grammar that will match any <tt>std::complex\<\></tt> + /// terminal: + /// + /// \code + /// BOOST_MPL_ASSERT(( + /// matches< + /// terminal<std::complex<double> >::type + /// , terminal<std::complex< _ > > + /// > + /// )); + /// \endcode + /// + /// When used as a transform, \c _ returns the current expression + /// unchanged. For instance, in the following, \c _ is used with + /// the \c fold\<\> transform to fold the children of a node: + /// + /// \code + /// struct CountChildren + /// : or_< + /// // Terminals have no children + /// when<terminal<_>, mpl::int_<0>()> + /// // Use fold<> to count the children of non-terminals + /// , otherwise< + /// fold< + /// _ // <-- fold the current expression + /// , mpl::int_<0>() + /// , mpl::plus<_state, mpl::int_<1> >() + /// > + /// > + /// > + /// {}; + /// \endcode + struct _ : transform<_> + { + typedef _ proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// \param expr An expression + /// \return \c e + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) + operator()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return e; + } + }; + }; + + namespace detail + { + template<typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<>, Expr, State, Data> + : proto::_::impl<Expr, State, Data> + {}; + + template<typename G0, typename Expr, typename State, typename Data> + struct _and_impl<proto::and_<G0>, Expr, State, Data> + : proto::when<proto::_, G0>::template impl<Expr, State, Data> + {}; + } + + /// \brief Inverts the set of expressions matched by a grammar. When + /// used as a transform, \c not_\<\> returns the current expression + /// unchanged. + /// + /// If an expression type \c E does not match a grammar \c G, then + /// \c E \e does match <tt>not_\<G\></tt>. For example, + /// <tt>not_\<terminal\<_\> \></tt> will match any non-terminal. + template<typename Grammar> + struct not_ : transform<not_<Grammar> > + { + typedef not_ proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// \param e An expression + /// \pre <tt>matches\<Expr,not_\>::value</tt> is \c true. + /// \return \c e + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) + operator()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return e; + } + }; + }; + + /// \brief Used to select one grammar or another based on the result + /// of a compile-time Boolean. When used as a transform, \c if_\<\> + /// selects between two transforms based on a compile-time Boolean. + /// + /// When <tt>if_\<If,Then,Else\></tt> is used as a grammar, \c If + /// must be a Proto transform and \c Then and \c Else must be grammars. + /// An expression type \c E matches <tt>if_\<If,Then,Else\></tt> if + /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> + /// is \c true and \c E matches \c U; or, if + /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> + /// is \c false and \c E matches \c V. + /// + /// The template parameter \c Then defaults to \c _ + /// and \c Else defaults to \c not\<_\>, so an expression type \c E + /// will match <tt>if_\<If\></tt> if and only if + /// <tt>boost::result_of\<when\<_,If\>(E,int,int)\>::type::value</tt> + /// is \c true. + /// + /// \code + /// // A grammar that only matches integral terminals, + /// // using is_integral<> from Boost.Type_traits. + /// struct IsIntegral + /// : and_< + /// terminal<_> + /// , if_< is_integral<_value>() > + /// > + /// {}; + /// \endcode + /// + /// When <tt>if_\<If,Then,Else\></tt> is used as a transform, \c If, + /// \c Then and \c Else must be Proto transforms. When applying + /// the transform to an expression \c E, state \c S and data \c V, + /// if <tt>boost::result_of\<when\<_,If\>(E,S,V)\>::type::value</tt> + /// is \c true then the \c Then transform is applied; otherwise + /// the \c Else transform is applied. + /// + /// \code + /// // Match a terminal. If the terminal is integral, return + /// // mpl::true_; otherwise, return mpl::false_. + /// struct IsIntegral2 + /// : when< + /// terminal<_> + /// , if_< + /// is_integral<_value>() + /// , mpl::true_() + /// , mpl::false_() + /// > + /// > + /// {}; + /// \endcode + template< + typename If + , typename Then // = _ + , typename Else // = not_<_> + > + struct if_ : transform<if_<If, Then, Else> > + { + typedef if_ proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef + typename when<_, If>::template impl<Expr, State, Data>::result_type + condition; + + typedef + typename mpl::if_c< + static_cast<bool>(remove_reference<condition>::type::value) + , when<_, Then> + , when<_, Else> + >::type + which; + + typedef typename which::template impl<Expr, State, Data>::result_type result_type; + + /// \param e An expression + /// \param s The current state + /// \param d A data of arbitrary type + /// \return <tt>which::impl<Expr, State, Data>()(e, s, d)</tt> + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return typename which::template impl<Expr, State, Data>()(e, s, d); + } + }; + }; + + /// \brief For matching one of a set of alternate grammars. Alternates + /// tried in order to avoid ambiguity. When used as a transform, \c or_\<\> + /// applies the transform associated with the first grammar that matches + /// the expression. + /// + /// An expression type \c E matches <tt>or_\<B0,B1,...Bn\></tt> if \c E + /// matches any \c Bx for \c x in <tt>[0,n)</tt>. + /// + /// When applying <tt>or_\<B0,B1,...Bn\></tt> as a transform with an + /// expression \c e of type \c E, state \c s and data \c d, it is + /// equivalent to <tt>Bx()(e, s, d)</tt>, where \c x is the lowest + /// number such that <tt>matches\<E,Bx\>::value</tt> is \c true. + template<BOOST_PROTO_LOGICAL_typename_G> + struct or_ : transform<or_<BOOST_PROTO_LOGICAL_G> > + { + typedef or_ proto_grammar; + + /// \param e An expression + /// \param s The current state + /// \param d A data of arbitrary type + /// \pre <tt>matches\<Expr,or_\>::value</tt> is \c true. + /// \return <tt>which()(e, s, d)</tt>, where <tt>which</tt> is the + /// sub-grammar that matched <tt>Expr</tt>. + + template<typename Expr, typename State, typename Data> + struct impl + : detail::matches_< + typename Expr::proto_derived_expr + , typename Expr::proto_grammar + , or_ + >::which::template impl<Expr, State, Data> + {}; + + template<typename Expr, typename State, typename Data> + struct impl<Expr &, State, Data> + : detail::matches_< + typename Expr::proto_derived_expr + , typename Expr::proto_grammar + , or_ + >::which::template impl<Expr &, State, Data> + {}; + }; + + /// \brief For matching all of a set of grammars. When used as a + /// transform, \c and_\<\> applies the transforms associated with + /// the each grammar in the set, and returns the result of the last. + /// + /// An expression type \c E matches <tt>and_\<B0,B1,...Bn\></tt> if \c E + /// matches all \c Bx for \c x in <tt>[0,n)</tt>. + /// + /// When applying <tt>and_\<B0,B1,...Bn\></tt> as a transform with an + /// expression \c e, state \c s and data \c d, it is + /// equivalent to <tt>(B0()(e, s, d),B1()(e, s, d),...Bn()(e, s, d))</tt>. + template<BOOST_PROTO_LOGICAL_typename_G> + struct and_ : transform<and_<BOOST_PROTO_LOGICAL_G> > + { + typedef and_ proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : detail::_and_impl<and_, Expr, State, Data> + {}; + }; + + /// \brief For matching one of a set of alternate grammars, which + /// are looked up based on some property of an expression. The + /// property on which to dispatch is specified by the \c Transform + /// template parameter, which defaults to <tt>tag_of\<_\>()</tt>. + /// That is, when the \c Trannsform is not specified, the alternate + /// grammar is looked up using the tag type of the current expression. + /// + /// When used as a transform, \c switch_\<\> applies the transform + /// associated with the grammar that matches the expression. + /// + /// \note \c switch_\<\> is functionally identical to \c or_\<\> but + /// is often more efficient. It does a fast, O(1) lookup using the + /// result of the specified transform to find a sub-grammar that may + /// potentially match the expression. + /// + /// An expression type \c E matches <tt>switch_\<C,T\></tt> if \c E + /// matches <tt>C::case_\<boost::result_of\<T(E)\>::type\></tt>. + /// + /// When applying <tt>switch_\<C,T\></tt> as a transform with an + /// expression \c e of type \c E, state \c s of type \S and data + /// \c d of type \c D, it is equivalent to + /// <tt>C::case_\<boost::result_of\<T(E,S,D)\>::type\>()(e, s, d)</tt>. + template<typename Cases, typename Transform> + struct switch_ : transform<switch_<Cases, Transform> > + { + typedef switch_ proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : Cases::template case_< + typename when<_, Transform>::template impl<Expr, State, Data>::result_type + >::template impl<Expr, State, Data> + {}; + }; + + /// INTERNAL ONLY (This is merely a compile-time optimization for the common case) + /// + template<typename Cases> + struct switch_<Cases> : transform<switch_<Cases> > + { + typedef switch_ proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : Cases::template case_<typename Expr::proto_tag>::template impl<Expr, State, Data> + {}; + + template<typename Expr, typename State, typename Data> + struct impl<Expr &, State, Data> + : Cases::template case_<typename Expr::proto_tag>::template impl<Expr &, State, Data> + {}; + }; + + /// \brief For forcing exact matches of terminal types. + /// + /// By default, matching terminals ignores references and + /// cv-qualifiers. For instance, a terminal expression of + /// type <tt>terminal\<int const &\>::type</tt> will match + /// the grammar <tt>terminal\<int\></tt>. If that is not + /// desired, you can force an exact match with + /// <tt>terminal\<exact\<int\> \></tt>. This will only + /// match integer terminals where the terminal is held by + /// value. + template<typename T> + struct exact + {}; + + /// \brief For matching terminals that are convertible to + /// a type. + /// + /// Use \c convertible_to\<\> to match a terminal that is + /// convertible to some type. For example, the grammar + /// <tt>terminal\<convertible_to\<int\> \></tt> will match + /// any terminal whose argument is convertible to an integer. + /// + /// \note The trait \c is_convertible\<\> from Boost.Type_traits + /// is used to determinal convertibility. + template<typename T> + struct convertible_to + {}; + + /// \brief For matching a Grammar to a variable number of + /// sub-expressions. + /// + /// An expression type <tt>expr\<AT, listN\<A0,...An,U0,...Um\> \></tt> + /// matches a grammar <tt>expr\<BT, listM\<B0,...Bn,vararg\<V\> \> \></tt> + /// if \c BT is \c _ or \c AT, and if \c Ax matches \c Bx + /// for each \c x in <tt>[0,n)</tt> and if \c Ux matches \c V + /// for each \c x in <tt>[0,m)</tt>. + /// + /// For example: + /// + /// \code + /// // Match any function call expression, irregardless + /// // of the number of function arguments: + /// struct Function + /// : function< vararg<_> > + /// {}; + /// \endcode + /// + /// When used as a transform, <tt>vararg\<G\></tt> applies + /// <tt>G</tt>'s transform. + template<typename Grammar> + struct vararg + : Grammar + { + /// INTERNAL ONLY + typedef void proto_is_vararg_; + }; + + /// INTERNAL ONLY + /// + template<BOOST_PROTO_LOGICAL_typename_G> + struct is_callable<or_<BOOST_PROTO_LOGICAL_G> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<BOOST_PROTO_LOGICAL_typename_G> + struct is_callable<and_<BOOST_PROTO_LOGICAL_G> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Grammar> + struct is_callable<not_<Grammar> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename If, typename Then, typename Else> + struct is_callable<if_<If, Then, Else> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Grammar> + struct is_callable<vararg<Grammar> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Cases, typename Transform> + struct is_callable<switch_<Cases, Transform> > + : mpl::true_ + {}; + +}} + +#undef BOOST_PROTO_LOGICAL_typename_G +#undef BOOST_PROTO_LOGICAL_G + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/operators.hpp b/3rdParty/Boost/src/boost/proto/operators.hpp new file mode 100644 index 0000000..1f2bad8 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/operators.hpp @@ -0,0 +1,378 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file operators.hpp +/// Contains all the overloaded operators that make it possible to build +/// Proto expression trees. +// +// 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_OPERATORS_HPP_EAN_04_01_2005 +#define BOOST_PROTO_OPERATORS_HPP_EAN_04_01_2005 + +#include <boost/config.hpp> +#include <boost/preprocessor/punctuation/comma.hpp> +#include <boost/mpl/logical.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/tags.hpp> +#include <boost/proto/domain.hpp> +#include <boost/proto/matches.hpp> +#include <boost/proto/generate.hpp> +#include <boost/proto/make_expr.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template<typename MakeExpr, typename Grammar> + struct lazy_matches + : proto::matches<typename MakeExpr::type, Grammar> + {}; + + template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Arg> + struct enable_unary + : boost::lazy_enable_if_c< + boost::mpl::and_< + Trait + , lazy_matches<result_of::make_expr<Tag, basic_default_domain, Arg>, Grammar> + >::value + , result_of::make_expr<Tag, Domain, Arg> + > + {}; + + template<typename Domain, typename Trait, typename Tag, typename Arg> + struct enable_unary<Domain, proto::_, Trait, Tag, Arg &> + : boost::lazy_enable_if_c< + Trait::value + , result_of::make_expr<Tag, Domain, Arg &> + > + {}; + + template<typename Trait, typename Tag, typename Arg> + struct enable_unary<deduce_domain, not_a_grammar, Trait, Tag, Arg &> + : enable_unary< + typename domain_of<Arg>::type + , typename domain_of<Arg>::type::proto_grammar + , Trait + , Tag + , Arg & + > + {}; + + template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Left, typename Right> + struct enable_binary + : boost::lazy_enable_if_c< + boost::mpl::and_< + Trait + , lazy_matches<result_of::make_expr<Tag, basic_default_domain, Left, Right>, Grammar> + >::value + , result_of::make_expr<Tag, Domain, Left, Right> + > + {}; + + template<typename Domain, typename Trait, typename Tag, typename Left, typename Right> + struct enable_binary<Domain, proto::_, Trait, Tag, Left &, Right &> + : boost::lazy_enable_if_c< + Trait::value + , result_of::make_expr<Tag, Domain, Left &, Right &> + > + {}; + + template<typename Trait, typename Tag, typename Left, typename Right> + struct enable_binary<deduce_domain, not_a_grammar, Trait, Tag, Left &, Right &> + : enable_binary< + typename deduce_domain2<Left, Right>::type + , typename deduce_domain2<Left, Right>::type::proto_grammar + , Trait + , Tag + , Left & + , Right & + > + {}; + + } // detail + +#define BOOST_PROTO_UNARY_OP_IS_POSTFIX_0 +#define BOOST_PROTO_UNARY_OP_IS_POSTFIX_1 , int + +#ifdef BOOST_NO_RVALUE_REFERENCES + +#define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST) \ + template<typename Arg> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename boost::proto::detail::enable_unary< \ + DOMAIN \ + , DOMAIN::proto_grammar \ + , BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \ + , TAG \ + , Arg & \ + >::type const \ + operator OP(Arg &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \ + { \ + return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg &>()(arg); \ + } \ + \ + template<typename Arg> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename boost::proto::detail::enable_unary< \ + DOMAIN \ + , DOMAIN::proto_grammar \ + , BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \ + , TAG \ + , Arg const & \ + >::type const \ + operator OP(Arg const &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \ + { \ + return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg const &>()(arg); \ + } \ + /**/ + +#define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN) \ + template<typename Left, typename Right> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename boost::proto::detail::enable_binary< \ + DOMAIN \ + , DOMAIN::proto_grammar \ + , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ + , TAG \ + , Left & \ + , Right & \ + >::type const \ + operator OP(Left &left, Right &right) \ + { \ + return boost::proto::detail::make_expr_<TAG, DOMAIN, Left &, Right &>()(left, right); \ + } \ + \ + template<typename Left, typename Right> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename boost::proto::detail::enable_binary< \ + DOMAIN \ + , DOMAIN::proto_grammar \ + , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ + , TAG \ + , Left & \ + , Right const & \ + >::type const \ + operator OP(Left &left, Right const &right) \ + { \ + return boost::proto::detail::make_expr_<TAG, DOMAIN, Left &, Right const &>()(left, right); \ + } \ + \ + template<typename Left, typename Right> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename boost::proto::detail::enable_binary< \ + DOMAIN \ + , DOMAIN::proto_grammar \ + , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ + , TAG \ + , Left const & \ + , Right & \ + >::type const \ + operator OP(Left const &left, Right &right) \ + { \ + return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right &>()(left, right); \ + } \ + \ + template<typename Left, typename Right> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename boost::proto::detail::enable_binary< \ + DOMAIN \ + , DOMAIN::proto_grammar \ + , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ + , TAG \ + , Left const & \ + , Right const & \ + >::type const \ + operator OP(Left const &left, Right const &right) \ + { \ + return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right const &>()(left, right);\ + } \ + /**/ + +#else + +#define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST) \ + template<typename Arg> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename boost::proto::detail::enable_unary< \ + DOMAIN \ + , DOMAIN::proto_grammar \ + , BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \ + , TAG \ + , Arg const & \ + >::type const \ + operator OP(Arg &&arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \ + { \ + return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg const &>()(arg); \ + } \ + /**/ + +#define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN) \ + template<typename Left, typename Right> \ + BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ + typename boost::proto::detail::enable_binary< \ + DOMAIN \ + , DOMAIN::proto_grammar \ + , BOOST_PROTO_APPLY_BINARY_(TRAIT, Left, Right) \ + , TAG \ + , Left const & \ + , Right const & \ + >::type const \ + operator OP(Left &&left, Right &&right) \ + { \ + return boost::proto::detail::make_expr_<TAG, DOMAIN, Left const &, Right const &>()(left, right);\ + } \ + /**/ + +#endif + +#define BOOST_PROTO_DEFINE_OPERATORS(TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, boost::proto::tag::unary_plus, TRAIT, DOMAIN, 0) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, boost::proto::tag::negate, TRAIT, DOMAIN, 0) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, boost::proto::tag::dereference, TRAIT, DOMAIN, 0) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, boost::proto::tag::complement, TRAIT, DOMAIN, 0) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, boost::proto::tag::address_of, TRAIT, DOMAIN, 0) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, boost::proto::tag::logical_not, TRAIT, DOMAIN, 0) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, boost::proto::tag::pre_inc, TRAIT, DOMAIN, 0) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, boost::proto::tag::pre_dec, TRAIT, DOMAIN, 0) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, boost::proto::tag::post_inc, TRAIT, DOMAIN, 1) \ + BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, boost::proto::tag::post_dec, TRAIT, DOMAIN, 1) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, boost::proto::tag::shift_left, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, boost::proto::tag::shift_right, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, boost::proto::tag::multiplies, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, boost::proto::tag::divides, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, boost::proto::tag::modulus, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, boost::proto::tag::plus, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, boost::proto::tag::minus, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, boost::proto::tag::less, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, boost::proto::tag::greater, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, boost::proto::tag::less_equal, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, boost::proto::tag::greater_equal, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, boost::proto::tag::equal_to, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, boost::proto::tag::not_equal_to, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, boost::proto::tag::logical_or, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, boost::proto::tag::logical_and, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, boost::proto::tag::bitwise_and, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, boost::proto::tag::bitwise_or, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, boost::proto::tag::bitwise_xor, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(), boost::proto::tag::comma, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, boost::proto::tag::mem_ptr, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=, boost::proto::tag::shift_left_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=, boost::proto::tag::shift_right_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=, boost::proto::tag::multiplies_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, boost::proto::tag::divides_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, boost::proto::tag::modulus_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, boost::proto::tag::plus_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, boost::proto::tag::minus_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=, boost::proto::tag::bitwise_and_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=, boost::proto::tag::bitwise_or_assign, TRAIT, DOMAIN) \ + BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=, boost::proto::tag::bitwise_xor_assign, TRAIT, DOMAIN) \ + /**/ + + // Extensions are a superset of Proto expressions + template<typename T> + struct is_extension + : is_expr<T> + {}; + + template<typename T> + struct is_extension<T &> + : is_expr<T> + {}; + + #define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) TRAIT<ARG> + #define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) boost::mpl::or_<TRAIT<LEFT>, TRAIT<RIGHT> > + + namespace exprns_ + { + // This defines all of Proto's built-in free operator overloads + BOOST_PROTO_DEFINE_OPERATORS(is_extension, deduce_domain) + + // if_else, for the non-overloadable ternary conditional operator ?: + template<typename A0, typename A1, typename A2> + BOOST_FORCEINLINE + typename result_of::make_expr< + tag::if_else_ + , deduce_domain + , A0 const & + , A1 const & + , A2 const & + >::type const + if_else(A0 const &a0, A1 const &a1, A2 const &a2) + { + return proto::detail::make_expr_< + tag::if_else_ + , deduce_domain + , A0 const & + , A1 const & + , A2 const & + >()(a0, a1, a2); + } + } + + using exprns_::if_else; + + #undef BOOST_PROTO_APPLY_UNARY_ + #undef BOOST_PROTO_APPLY_BINARY_ + + // Redefine BOOST_PROTO_APPLY_UNARY_ and BOOST_PROTO_APPLY_BINARY_ so that end users + // can use BOOST_PROTO_DEFINE_OPERATORS to define Proto operator overloads that work + // with their own terminal types. + +#ifdef BOOST_NO_RVALUE_REFERENCES + + #define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) \ + boost::mpl::and_< \ + TRAIT<ARG> \ + , boost::mpl::not_<boost::proto::is_extension<ARG> > \ + > \ + /**/ + + #define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) \ + boost::mpl::and_< \ + boost::mpl::or_<TRAIT<LEFT>, TRAIT<RIGHT> > \ + , boost::mpl::not_< \ + boost::mpl::or_< \ + boost::proto::is_extension<LEFT> \ + , boost::proto::is_extension<RIGHT> \ + > \ + > \ + > \ + /**/ + +#else + + #define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) \ + boost::mpl::and_< \ + TRAIT<BOOST_PROTO_UNCVREF(ARG) > \ + , boost::mpl::not_<boost::proto::is_extension<ARG> > \ + > \ + /**/ + + #define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) \ + boost::mpl::and_< \ + boost::mpl::or_<TRAIT<BOOST_PROTO_UNCVREF(LEFT) >, TRAIT<BOOST_PROTO_UNCVREF(RIGHT) > > \ + , boost::mpl::not_< \ + boost::mpl::or_< \ + boost::proto::is_extension<LEFT> \ + , boost::proto::is_extension<RIGHT> \ + > \ + > \ + > \ + /**/ + +#endif + +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/proto.hpp b/3rdParty/Boost/src/boost/proto/proto.hpp new file mode 100644 index 0000000..ad2f1bb --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/proto.hpp @@ -0,0 +1,18 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file proto.hpp +/// Includes all of Proto. +// +// 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_HPP_EAN_04_01_2005 +#define BOOST_PROTO_HPP_EAN_04_01_2005 + +#include <boost/proto/core.hpp> +#include <boost/proto/debug.hpp> +#include <boost/proto/context.hpp> +#include <boost/proto/transform.hpp> +#include <boost/proto/functional.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/proto_fwd.hpp b/3rdParty/Boost/src/boost/proto/proto_fwd.hpp new file mode 100644 index 0000000..5547e77 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/proto_fwd.hpp @@ -0,0 +1,886 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file proto_fwd.hpp +/// Forward declarations of all of proto's public types and functions. +// +// 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_FWD_HPP_EAN_04_01_2005 +#define BOOST_PROTO_FWD_HPP_EAN_04_01_2005 + +#include <cstddef> +#include <climits> +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/punctuation/comma.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> +#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/ref.hpp> +#include <boost/mpl/long.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/mpl/aux_/config/ttp.hpp> +#include <boost/utility/result_of.hpp> + +#ifndef BOOST_PROTO_MAX_ARITY +# define BOOST_PROTO_MAX_ARITY 10 +#endif + +#ifndef BOOST_PROTO_MAX_LOGICAL_ARITY +# define BOOST_PROTO_MAX_LOGICAL_ARITY 10 +#endif + +#ifndef BOOST_PROTO_MAX_FUNCTION_CALL_ARITY +# define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY BOOST_PROTO_MAX_ARITY +#endif + +#if BOOST_PROTO_MAX_ARITY < 3 +# error BOOST_PROTO_MAX_ARITY must be at least 3 +#endif + +#if BOOST_PROTO_MAX_FUNCTION_CALL_ARITY > BOOST_PROTO_MAX_ARITY +# error BOOST_PROTO_MAX_FUNCTION_CALL_ARITY cannot be larger than BOOST_PROTO_MAX_ARITY +#endif + +#ifndef BOOST_PROTO_DONT_USE_PREPROCESSED_FILES + #if 10 < BOOST_PROTO_MAX_ARITY || \ + 10 < BOOST_PROTO_MAX_LOGICAL_ARITY || \ + 10 < BOOST_PROTO_MAX_FUNCTION_CALL_ARITY + #define BOOST_PROTO_DONT_USE_PREPROCESSED_FILES + #endif +#endif + +#ifndef BOOST_PROTO_BROKEN_CONST_OVERLOADS +# if BOOST_WORKAROUND(__GNUC__, == 3) \ + || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) +# define BOOST_PROTO_BROKEN_CONST_OVERLOADS +# endif +#endif + +#ifndef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS +# if BOOST_WORKAROUND(__GNUC__, == 3) \ + || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) +# define BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS +# endif +#endif + +#ifdef BOOST_PROTO_BROKEN_CONST_OVERLOADS +# include <boost/utility/enable_if.hpp> +# include <boost/type_traits/is_const.hpp> +# define BOOST_PROTO_DISABLE_IF_IS_CONST(T)\ + , typename boost::disable_if_c<boost::is_const<T>::value, boost::proto::detail::undefined>::type * = 0 +#else +# define BOOST_PROTO_DISABLE_IF_IS_CONST(T) +#endif + +#ifdef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS +# include <boost/utility/enable_if.hpp> +# include <boost/type_traits/is_function.hpp> +# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)\ + , typename boost::disable_if_c<boost::is_function<T>::value, boost::proto::detail::undefined>::type * = 0 +#else +# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T) +#endif + +#ifndef BOOST_PROTO_BROKEN_PTS +# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) +# define BOOST_PROTO_BROKEN_PTS +# endif +#endif + +#ifdef BOOST_NO_DECLTYPE_N3276 +# // Proto can only use the decltype-based result_of if N3276 has been +# // implemented by the compiler. +# // See http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf +# ifndef BOOST_PROTO_USE_NORMAL_RESULT_OF +# define BOOST_PROTO_USE_NORMAL_RESULT_OF +# endif +#endif + +// Unless compiler support is there, use tr1_result_of instead of +// result_of to avoid the problems addressed by N3276. +#ifdef BOOST_PROTO_USE_NORMAL_RESULT_OF +# define BOOST_PROTO_RESULT_OF boost::result_of +#else +# define BOOST_PROTO_RESULT_OF boost::tr1_result_of +#endif + +// If we're using the decltype-based result_of, we need to be a bit +// stricter about the return types of some functions. +#if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_PROTO_USE_NORMAL_RESULT_OF) +# define BOOST_PROTO_STRICT_RESULT_OF +# define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) X +#else +# define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) Y +#endif + +#ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING +# define BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING +#endif + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable : 4522)) // 'class' : multiple assignment operators specified +# define BOOST_PROTO_DISABLE_MSVC_C4714 __pragma(warning(disable : 4714)) // function 'xxx' marked as __forceinline not inlined +#else +# define BOOST_PROTO_DISABLE_MSVC_C4522 +# define BOOST_PROTO_DISABLE_MSVC_C4714 +#endif + +namespace boost { namespace proto +{ + namespace detail + { + typedef char yes_type; + typedef char (&no_type)[2]; + + template<int N> + struct sized_type + { + typedef char (&type)[N]; + }; + + struct dont_care; + struct undefined; // leave this undefined + struct not_a_valid_type; + + struct private_type_ + { + private_type_ operator ,(int) const; + }; + + template<typename T> + struct uncvref + { + typedef T type; + }; + + template<typename T> + struct uncvref<T const> + { + typedef T type; + }; + + template<typename T> + struct uncvref<T &> + { + typedef T type; + }; + + template<typename T> + struct uncvref<T const &> + { + typedef T type; + }; + + template<typename T, std::size_t N> + struct uncvref<T const[N]> + { + typedef T type[N]; + }; + + template<typename T, std::size_t N> + struct uncvref<T (&)[N]> + { + typedef T type[N]; + }; + + template<typename T, std::size_t N> + struct uncvref<T const (&)[N]> + { + typedef T type[N]; + }; + + struct ignore + { + ignore() + {} + + template<typename T> + ignore(T const &) + {} + }; + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_UNCVREF(X) \ + typename boost::proto::detail::uncvref<X>::type \ + /**/ + + struct _default; + + struct not_a_domain; + struct not_a_grammar; + struct not_a_generator; + + template<typename T, typename Void = void> + struct is_transform_; + + template<typename T, typename Void = void> + struct is_aggregate_; + + template<typename Expr> + struct flat_view; + } + + typedef detail::ignore const ignore; + + namespace argsns_ + { + template<typename Arg0> + struct term; + + #define M0(Z, N, DATA) \ + template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename Arg)> struct BOOST_PP_CAT(list, N); \ + /**/ + BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~) + #undef M0 + } + + using namespace argsns_; + + /////////////////////////////////////////////////////////////////////////////// + // Operator tags + namespace tagns_ + { + namespace tag + { + struct terminal; + struct unary_plus; + struct negate; + struct dereference; + struct complement; + struct address_of; + struct logical_not; + struct pre_inc; + struct pre_dec; + struct post_inc; + struct post_dec; + + struct shift_left; + struct shift_right; + struct multiplies; + struct divides; + struct modulus; + struct plus; + struct minus; + struct less; + struct greater; + struct less_equal; + struct greater_equal; + struct equal_to; + struct not_equal_to; + struct logical_or; + struct logical_and; + struct bitwise_and; + struct bitwise_or; + struct bitwise_xor; + struct comma; + struct mem_ptr; + + struct assign; + struct shift_left_assign; + struct shift_right_assign; + struct multiplies_assign; + struct divides_assign; + struct modulus_assign; + struct plus_assign; + struct minus_assign; + struct bitwise_and_assign; + struct bitwise_or_assign; + struct bitwise_xor_assign; + struct subscript; + struct member; + struct if_else_; + struct function; + + // Fusion tags + template<typename Tag, typename Domain> struct proto_expr; + template<typename Tag, typename Domain> struct proto_expr_iterator; + template<typename Tag, typename Domain> struct proto_flat_view; + } + } + + using namespace tagns_; + + template<typename Expr> + struct tag_of; + + //////////////////////////////////////////////////////////////////////////////////////////////// + struct _; + + //////////////////////////////////////////////////////////////////////////////////////////////// + struct default_generator; + + struct basic_default_generator; + + template<template<typename> class Extends> + struct generator; + + template<template<typename> class Extends> + struct pod_generator; + + struct by_value_generator; + + template<typename First, typename Second> + struct compose_generators; + + template<typename Generator, typename Void = void> + struct wants_basic_expr; + + template<typename Generator> + struct use_basic_expr; + + //////////////////////////////////////////////////////////////////////////////////////////////// + namespace domainns_ + { + typedef detail::not_a_domain no_super_domain; + + template< + typename Generator = default_generator + , typename Grammar = proto::_ + , typename Super = no_super_domain + > + struct domain; + + struct default_domain; + + struct basic_default_domain; + + struct deduce_domain; + + template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr = wants_basic_expr<typename Domain::proto_generator>::value> + struct base_expr; + } + + using namespace domainns_; + + //////////////////////////////////////////////////////////////////////////////////////////////// + namespace exprns_ + { + template<typename Tag, typename Args, long Arity = Args::arity> + struct basic_expr; + + template<typename Tag, typename Args, long Arity = Args::arity> + struct expr; + + template< + typename Expr + , typename Derived + , typename Domain = default_domain + , long Arity = Expr::proto_arity_c + > + struct extends; + + template<typename This, typename Fun, typename Domain> + struct virtual_member; + + struct is_proto_expr; + } + //////////////////////////////////////////////////////////////////////////////////////////////// + + using exprns_::expr; + using exprns_::basic_expr; + using exprns_::extends; + using exprns_::is_proto_expr; + + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)> + struct or_; + + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G, void)> + struct and_; + + template<typename Grammar> + struct not_; + + template<typename Condition, typename Then = _, typename Else = not_<_> > + struct if_; + + template<typename Cases, typename Transform = tag_of<_>()> + struct switch_; + + template<typename T> + struct exact; + + template<typename T> + struct convertible_to; + + template<typename Grammar> + struct vararg; + + struct pack; + + // Boost bug https://svn.boost.org/trac/boost/ticket/4602 + //int const N = INT_MAX; + int const N = (INT_MAX >> 10); + + namespace context + { + struct null_context; + + template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> + struct null_eval; + + struct default_context; + + template<typename Expr, typename Context, typename Tag = typename Expr::proto_tag, long Arity = Expr::proto_arity_c> + struct default_eval; + + template<typename Derived, typename DefaultCtx = default_context> + struct callable_context; + + template<typename Expr, typename Context, long Arity = Expr::proto_arity_c> + struct callable_eval; + } + + using context::null_context; + using context::null_eval; + using context::default_context; + using context::default_eval; + using context::callable_context; + using context::callable_eval; + + namespace utility + { + template<typename T, typename Domain = default_domain> + struct literal; + } + + using utility::literal; + + namespace result_of + { + template<typename T, typename Domain = default_domain> + struct as_expr; + + template<typename T, typename Domain = default_domain> + struct as_child; + + template<typename Expr, typename N = mpl::long_<0> > + struct child; + + template<typename Expr, long N> + struct child_c; + + template<typename Expr> + struct left; + + template<typename Expr> + struct right; + + template<typename Expr> + struct deep_copy; + + template<typename Expr, typename Context> + struct eval; + + template< + typename Tag + , typename DomainOrA0 + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( + BOOST_PROTO_MAX_ARITY + , typename A + , = void BOOST_PP_INTERCEPT + ) + , typename Void = void + > + struct make_expr; + + template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void> + struct unpack_expr; + + template<typename T> + struct as_env; + + template<typename Env, typename Tag> + struct has_env_var; + + template<typename Env, typename Tag> + struct env_var; + } + + template<typename T, typename Void = void> + struct is_expr; + + template<typename T, typename Void = void> + struct is_domain; + + template<typename SubDomain, typename SuperDomain> + struct is_sub_domain_of; + + template<typename T, typename Void = void> + struct is_env; + + template<typename Expr> + struct arity_of; + + template<typename T, typename Void = void> + struct domain_of; + + template<typename Expr, typename Grammar> + struct matches; + + // Generic expression metafunctions and + // grammar elements + template<typename Tag, typename Arg> + struct unary_expr; + + template<typename Tag, typename Left, typename Right> + struct binary_expr; + + template<typename Tag, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)> + struct nary_expr; + + // Specific expression metafunctions and + // grammar elements, for convenience + template<typename T> struct terminal; + template<typename T> struct unary_plus; + template<typename T> struct negate; + template<typename T> struct dereference; + template<typename T> struct complement; + template<typename T> struct address_of; + template<typename T> struct logical_not; + template<typename T> struct pre_inc; + template<typename T> struct pre_dec; + template<typename T> struct post_inc; + template<typename T> struct post_dec; + + template<typename T, typename U> struct shift_left; + template<typename T, typename U> struct shift_right; + template<typename T, typename U> struct multiplies; + template<typename T, typename U> struct divides; + template<typename T, typename U> struct modulus; + template<typename T, typename U> struct plus; + template<typename T, typename U> struct minus; + template<typename T, typename U> struct less; + template<typename T, typename U> struct greater; + template<typename T, typename U> struct less_equal; + template<typename T, typename U> struct greater_equal; + template<typename T, typename U> struct equal_to; + template<typename T, typename U> struct not_equal_to; + template<typename T, typename U> struct logical_or; + template<typename T, typename U> struct logical_and; + template<typename T, typename U> struct bitwise_and; + template<typename T, typename U> struct bitwise_or; + template<typename T, typename U> struct bitwise_xor; + template<typename T, typename U> struct comma; + template<typename T, typename U> struct mem_ptr; + + template<typename T, typename U> struct assign; + template<typename T, typename U> struct shift_left_assign; + template<typename T, typename U> struct shift_right_assign; + template<typename T, typename U> struct multiplies_assign; + template<typename T, typename U> struct divides_assign; + template<typename T, typename U> struct modulus_assign; + template<typename T, typename U> struct plus_assign; + template<typename T, typename U> struct minus_assign; + template<typename T, typename U> struct bitwise_and_assign; + template<typename T, typename U> struct bitwise_or_assign; + template<typename T, typename U> struct bitwise_xor_assign; + template<typename T, typename U> struct subscript; + template<typename T, typename U> struct member; + template<typename T, typename U, typename V> struct if_else_; + + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void)> + struct function; + + namespace functional + { + struct left; + struct right; + struct eval; + struct deep_copy; + + template<typename Domain = default_domain> + struct as_expr; + + template<typename Domain = default_domain> + struct as_child; + + template<typename N = mpl::long_<0> > + struct child; + + template<long N> + struct child_c; + + struct as_env; + + template<typename Tag> + struct has_env_var; + + template<typename Tag> + struct env_var; + + template<typename Tag, typename Domain = deduce_domain> + struct make_expr; + + template<typename Tag, typename Domain = deduce_domain> + struct unpack_expr; + + typedef make_expr<tag::terminal> make_terminal; + typedef make_expr<tag::unary_plus> make_unary_plus; + typedef make_expr<tag::negate> make_negate; + typedef make_expr<tag::dereference> make_dereference; + typedef make_expr<tag::complement> make_complement; + typedef make_expr<tag::address_of> make_address_of; + typedef make_expr<tag::logical_not> make_logical_not; + typedef make_expr<tag::pre_inc> make_pre_inc; + typedef make_expr<tag::pre_dec> make_pre_dec; + typedef make_expr<tag::post_inc> make_post_inc; + typedef make_expr<tag::post_dec> make_post_dec; + typedef make_expr<tag::shift_left> make_shift_left; + typedef make_expr<tag::shift_right> make_shift_right; + typedef make_expr<tag::multiplies> make_multiplies; + typedef make_expr<tag::divides> make_divides; + typedef make_expr<tag::modulus> make_modulus; + typedef make_expr<tag::plus> make_plus; + typedef make_expr<tag::minus> make_minus; + typedef make_expr<tag::less> make_less; + typedef make_expr<tag::greater> make_greater; + typedef make_expr<tag::less_equal> make_less_equal; + typedef make_expr<tag::greater_equal> make_greater_equal; + typedef make_expr<tag::equal_to> make_equal_to; + typedef make_expr<tag::not_equal_to> make_not_equal_to; + typedef make_expr<tag::logical_or> make_logical_or; + typedef make_expr<tag::logical_and> make_logical_and; + typedef make_expr<tag::bitwise_and> make_bitwise_and; + typedef make_expr<tag::bitwise_or> make_bitwise_or; + typedef make_expr<tag::bitwise_xor> make_bitwise_xor; + typedef make_expr<tag::comma> make_comma; + typedef make_expr<tag::mem_ptr> make_mem_ptr; + typedef make_expr<tag::assign> make_assign; + typedef make_expr<tag::shift_left_assign> make_shift_left_assign; + typedef make_expr<tag::shift_right_assign> make_shift_right_assign; + typedef make_expr<tag::multiplies_assign> make_multiplies_assign; + typedef make_expr<tag::divides_assign> make_divides_assign; + typedef make_expr<tag::modulus_assign> make_modulus_assign; + typedef make_expr<tag::plus_assign> make_plus_assign; + typedef make_expr<tag::minus_assign> make_minus_assign; + typedef make_expr<tag::bitwise_and_assign> make_bitwise_and_assign; + typedef make_expr<tag::bitwise_or_assign> make_bitwise_or_assign; + typedef make_expr<tag::bitwise_xor_assign> make_bitwise_xor_assign; + typedef make_expr<tag::subscript> make_subscript; + typedef make_expr<tag::if_else_> make_if_else; + typedef make_expr<tag::function> make_function; + + struct flatten; + struct make_pair; + struct first; + struct second; + struct at; + struct pop_front; + struct push_front; + struct pop_back; + struct push_back; + struct reverse; + } + + typedef functional::flatten _flatten; + typedef functional::make_pair _make_pair; + typedef functional::first _first; + typedef functional::second _second; + typedef functional::pop_front _at; + typedef functional::pop_front _pop_front; + typedef functional::push_front _push_front; + typedef functional::pop_back _pop_back; + typedef functional::push_back _push_back; + typedef functional::reverse _reverse; + typedef functional::eval _eval; + struct _deep_copy; + + typedef functional::make_expr<tag::terminal> _make_terminal; + typedef functional::make_expr<tag::unary_plus> _make_unary_plus; + typedef functional::make_expr<tag::negate> _make_negate; + typedef functional::make_expr<tag::dereference> _make_dereference; + typedef functional::make_expr<tag::complement> _make_complement; + typedef functional::make_expr<tag::address_of> _make_address_of; + typedef functional::make_expr<tag::logical_not> _make_logical_not; + typedef functional::make_expr<tag::pre_inc> _make_pre_inc; + typedef functional::make_expr<tag::pre_dec> _make_pre_dec; + typedef functional::make_expr<tag::post_inc> _make_post_inc; + typedef functional::make_expr<tag::post_dec> _make_post_dec; + typedef functional::make_expr<tag::shift_left> _make_shift_left; + typedef functional::make_expr<tag::shift_right> _make_shift_right; + typedef functional::make_expr<tag::multiplies> _make_multiplies; + typedef functional::make_expr<tag::divides> _make_divides; + typedef functional::make_expr<tag::modulus> _make_modulus; + typedef functional::make_expr<tag::plus> _make_plus; + typedef functional::make_expr<tag::minus> _make_minus; + typedef functional::make_expr<tag::less> _make_less; + typedef functional::make_expr<tag::greater> _make_greater; + typedef functional::make_expr<tag::less_equal> _make_less_equal; + typedef functional::make_expr<tag::greater_equal> _make_greater_equal; + typedef functional::make_expr<tag::equal_to> _make_equal_to; + typedef functional::make_expr<tag::not_equal_to> _make_not_equal_to; + typedef functional::make_expr<tag::logical_or> _make_logical_or; + typedef functional::make_expr<tag::logical_and> _make_logical_and; + typedef functional::make_expr<tag::bitwise_and> _make_bitwise_and; + typedef functional::make_expr<tag::bitwise_or> _make_bitwise_or; + typedef functional::make_expr<tag::bitwise_xor> _make_bitwise_xor; + typedef functional::make_expr<tag::comma> _make_comma; + typedef functional::make_expr<tag::mem_ptr> _make_mem_ptr; + typedef functional::make_expr<tag::assign> _make_assign; + typedef functional::make_expr<tag::shift_left_assign> _make_shift_left_assign; + typedef functional::make_expr<tag::shift_right_assign> _make_shift_right_assign; + typedef functional::make_expr<tag::multiplies_assign> _make_multiplies_assign; + typedef functional::make_expr<tag::divides_assign> _make_divides_assign; + typedef functional::make_expr<tag::modulus_assign> _make_modulus_assign; + typedef functional::make_expr<tag::plus_assign> _make_plus_assign; + typedef functional::make_expr<tag::minus_assign> _make_minus_assign; + typedef functional::make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign; + typedef functional::make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign; + typedef functional::make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign; + typedef functional::make_expr<tag::subscript> _make_subscript; + typedef functional::make_expr<tag::if_else_> _make_if_else; + typedef functional::make_expr<tag::function> _make_function; + + template<typename T> + struct is_callable; + + template<typename T> + struct is_transform; + + template<typename T> + struct is_aggregate; + + #define BOOST_PROTO_UNEXPR() typedef int proto_is_expr_; + #define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_; + #define BOOST_PROTO_AGGREGATE() typedef void proto_is_aggregate_; + #define BOOST_PROTO_USE_BASIC_EXPR() typedef void proto_use_basic_expr_; + + struct callable + { + BOOST_PROTO_CALLABLE() + }; + + namespace envns_ + { + struct key_not_found; + + struct empty_env; + + typedef int empty_state; + + template<typename Tag, typename Value, typename Base = empty_env> + struct env; + + struct data_type; + + struct transforms_type; + } + + using envns_::key_not_found; + using envns_::empty_env; + using envns_::empty_state; + using envns_::env; + using envns_::data_type; + using envns_::transforms_type; + + struct external_transform; + + template<typename PrimitiveTransform = void, typename X = void> + struct transform; + + template<typename Grammar, typename Fun = Grammar> + struct when; + + template<typename Fun> + struct otherwise; + + template<typename Fun> + struct call; + + template<typename Fun> + struct make; + + template<typename PrimitiveTransform> + struct protect; + + template<typename T> + struct noinvoke; + + template<typename Fun> + struct lazy; + + template<typename Sequence, typename State, typename Fun> + struct fold; + + template<typename Sequence, typename State, typename Fun> + struct reverse_fold; + + // Q: can we replace fold_tree with fold<flatten(_), state, fun> ? + // A: once segmented Fusion works well. + template<typename Sequence, typename State, typename Fun> + struct fold_tree; + + template<typename Sequence, typename State, typename Fun> + struct reverse_fold_tree; + + template<typename Grammar, typename Domain = deduce_domain> + struct pass_through; + + template<typename Grammar = detail::_default> + struct _default; + + struct _expr; + struct _state; + struct _data; + + struct _value; + + struct _void; + + template<typename T, T I> + struct integral_c; + + template<char I> + struct char_; + + template<int I> + struct int_; + + template<long I> + struct long_; + + template<std::size_t I> + struct size_t; + + template<int I> + struct _child_c; + + typedef _child_c<0> _child0; + typedef _child_c<1> _child1; + typedef _child0 _child; + typedef _child0 _left; + typedef _child1 _right; + + // _child2, _child3, _child4, ... + #define M0(Z, N, DATA) typedef _child_c<N> BOOST_PP_CAT(_child, N); + BOOST_PP_REPEAT_FROM_TO( + 2 + , BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY) + , M0 + , ~ + ) + #undef M0 + + struct _byref; + struct _byval; + + template<typename Tag> + struct _env_var; + + struct _env; + + template<typename T> + struct is_extension; + + namespace exops = exprns_; + +}} // namespace boost::proto + +#endif diff --git a/3rdParty/Boost/src/boost/proto/repeat.hpp b/3rdParty/Boost/src/boost/proto/repeat.hpp new file mode 100644 index 0000000..205adbf --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/repeat.hpp @@ -0,0 +1,310 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file repeat.hpp +/// Contains macros to ease the generation of repetitious code constructs +// +// 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_REPEAT_HPP_EAN_11_24_2008 +#define BOOST_PROTO_REPEAT_HPP_EAN_11_24_2008 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/iteration/local.hpp> +#include <boost/preprocessor/tuple/elem.hpp> +#include <boost/proto/proto_fwd.hpp> // for BOOST_PROTO_MAX_ARITY + +//////////////////////////////////////////// +/// INTERNAL ONLY +#define BOOST_PROTO_ref_a_aux(Z, N, DATA)\ + boost::ref(BOOST_PP_CAT(proto_a, N)) + +/// \brief Generates a sequence like <tt>typename A0, typename A1, ...</tt> +/// +#define BOOST_PROTO_typename_A(N)\ + BOOST_PP_ENUM_PARAMS(N, typename proto_A) + +/// \brief Generates a sequence like <tt>A0 const &, A1 const &, ...</tt> +/// +#define BOOST_PROTO_A_const_ref(N)\ + BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, const & BOOST_PP_INTERCEPT) + +/// \brief Generates a sequence like <tt>A0 &, A1 &, ...</tt> +/// +#define BOOST_PROTO_A_ref(N)\ + BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, & BOOST_PP_INTERCEPT) + +/// \brief Generates a sequence like <tt>A0, A1, ...</tt> +/// +#define BOOST_PROTO_A(N)\ + BOOST_PP_ENUM_PARAMS(N, proto_A) + +/// \brief Generates a sequence like <tt>A0 const, A1 const, ...</tt> +/// +#define BOOST_PROTO_A_const(N)\ + BOOST_PP_ENUM_PARAMS(N, const proto_A) + +/// \brief Generates a sequence like <tt>A0 const &a0, A1 const &a0, ...</tt> +/// +#define BOOST_PROTO_A_const_ref_a(N)\ + BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, const &proto_a) + +/// \brief Generates a sequence like <tt>A0 &a0, A1 &a0, ...</tt> +/// +#define BOOST_PROTO_A_ref_a(N)\ + BOOST_PP_ENUM_BINARY_PARAMS(N, proto_A, &proto_a) + +/// \brief Generates a sequence like <tt>boost::ref(a0), boost::ref(a1), ...</tt> +/// +#define BOOST_PROTO_ref_a(N)\ + BOOST_PP_ENUM(N, BOOST_PROTO_ref_a_aux, ~) + +/// \brief Generates a sequence like <tt>a0, a1, ...</tt> +/// +#define BOOST_PROTO_a(N)\ + BOOST_PP_ENUM_PARAMS(N, proto_a) + +//////////////////////////////////////////// +/// INTERNAL ONLY +#define BOOST_PROTO_invoke(Z, N, DATA)\ + BOOST_PP_TUPLE_ELEM(5,0,DATA)(N, BOOST_PP_TUPLE_ELEM(5,1,DATA), BOOST_PP_TUPLE_ELEM(5,2,DATA), BOOST_PP_TUPLE_ELEM(5,3,DATA), BOOST_PP_TUPLE_ELEM(5,4,DATA)) + +/// \brief Repeatedly invoke the specified macro. +/// +/// BOOST_PROTO_REPEAT_FROM_TO_EX() is used generate the kind of repetitive code that is typical +/// of EDSLs built with Proto. BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, typename_A, A, A_a, a) is equivalent to: +/// +/// \code +/// MACRO(FROM, typename_A, A, A_a, a) +/// MACRO(FROM+1, typename_A, A, A_a, a) +/// ... +/// MACRO(TO-1, typename_A, A, A_a, a) +/// \endcode +#define BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, typename_A, A, A_a, a)\ + BOOST_PP_REPEAT_FROM_TO(FROM, TO, BOOST_PROTO_invoke, (MACRO, typename_A, A, A_a, a)) + +/// \brief Repeatedly invoke the specified macro. +/// +/// BOOST_PROTO_REPEAT_FROM_TO() is used generate the kind of repetitive code that is typical +/// of EDSLs built with Proto. BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO) is equivalent to: +/// +/// \code +/// MACRO(FROM, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) +/// MACRO(FROM+1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) +/// ... +/// MACRO(TO-1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) +/// \endcode +/// +/// Example: +/// +/** \code + +// Generate BOOST_PROTO_MAX_ARITY-1 overloads of the +// following construct() function template. +#define M0(N, typename_A, A_const_ref, A_const_ref_a, ref_a) \ +template<typename T, typename_A(N)> \ +typename proto::result_of::make_expr< \ + proto::tag::function \ + , construct_helper<T> \ + , A_const_ref(N) \ +>::type const \ +construct(A_const_ref_a(N)) \ +{ \ + return proto::make_expr< \ + proto::tag::function \ + >( \ + construct_helper<T>() \ + , ref_a(N) \ + ); \ +} +BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, M0) +#undef M0 + +\endcode +**/ +/// The above invocation of BOOST_PROTO_REPEAT_FROM_TO() will generate +/// the following code: +/// +/// \code +/// template<typename T, typename A0> +/// typename proto::result_of::make_expr< +/// proto::tag::function +/// , construct_helper<T> +/// , A0 const & +/// >::type const +/// construct(A0 const & a0) +/// { +/// return proto::make_expr< +/// proto::tag::function +/// >( +/// construct_helper<T>() +/// , boost::ref(a0) +/// ); +/// } +/// +/// template<typename T, typename A0, typename A1> +/// typename proto::result_of::make_expr< +/// proto::tag::function +/// , construct_helper<T> +/// , A0 const & +/// , A1 const & +/// >::type const +/// construct(A0 const & a0, A1 const & a1) +/// { +/// return proto::make_expr< +/// proto::tag::function +/// >( +/// construct_helper<T>() +/// , boost::ref(a0) +/// , boost::ref(a1) +/// ); +/// } +/// +/// // ... and so on, up to BOOST_PROTO_MAX_ARITY-1 arguments ... +/// \endcode +#define BOOST_PROTO_REPEAT_FROM_TO(FROM, TO, MACRO)\ + BOOST_PROTO_REPEAT_FROM_TO_EX(FROM, TO, MACRO, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) + +/// \brief Repeatedly invoke the specified macro. +/// +/// BOOST_PROTO_REPEAT_EX() is used generate the kind of repetitive code that is typical +/// of EDSLs built with Proto. BOOST_PROTO_REPEAT_EX(MACRO, typename_A, A, A_a, a) is equivalent to: +/// +/// \code +/// MACRO(1, typename_A, A, A_a, a) +/// MACRO(2, typename_A, A, A_a, a) +/// ... +/// MACRO(BOOST_PROTO_MAX_ARITY, typename_A, A, A_a, a) +/// \endcode +#define BOOST_PROTO_REPEAT_EX(MACRO, typename_A, A, A_a, a)\ + BOOST_PROTO_REPEAT_FROM_TO_EX(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), MACRO, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) + +/// \brief Repeatedly invoke the specified macro. +/// +/// BOOST_PROTO_REPEAT() is used generate the kind of repetitive code that is typical +/// of EDSLs built with Proto. BOOST_PROTO_REPEAT(MACRO) is equivalent to: +/// +/// \code +/// MACRO(1, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) +/// MACRO(2, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) +/// ... +/// MACRO(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_typename_A, BOOST_PROTO_A_const_ref, BOOST_PROTO_A_const_ref_a, BOOST_PROTO_ref_a) +/// \endcode +#define BOOST_PROTO_REPEAT(MACRO)\ + BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), MACRO) + +/// \brief Repeatedly invoke the specified macro. +/// +/// BOOST_PROTO_LOCAL_ITERATE() is used generate the kind of repetitive code that is typical +/// of EDSLs built with Proto. This macro causes the user-defined macro BOOST_PROTO_LOCAL_MACRO to +/// be expanded with values in the range specified by BOOST_PROTO_LOCAL_LIMITS. +/// +/// Usage: +/// +/// \code +/// #include BOOST_PROTO_LOCAL_ITERATE() +/// \endcode +/// +/// Example: +/// +/** \code + +// Generate BOOST_PROTO_MAX_ARITY-1 overloads of the +// following construct() function template. +#define BOOST_PROTO_LOCAL_MACRO(N, typename_A, A_const_ref, \ + A_const_ref_a, ref_a) \ +template<typename T, typename_A(N)> \ +typename proto::result_of::make_expr< \ + proto::tag::function \ + , construct_helper<T> \ + , A_const_ref(N) \ +>::type const \ +construct(A_const_ref_a(N)) \ +{ \ + return proto::make_expr< \ + proto::tag::function \ + >( \ + construct_helper<T>() \ + , ref_a(N) \ + ); \ +} +#define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY)) +#include BOOST_PROTO_LOCAL_ITERATE() + +\endcode +**/ +/// The above inclusion of BOOST_PROTO_LOCAL_ITERATE() will generate +/// the following code: +/// +/// \code +/// template<typename T, typename A0> +/// typename proto::result_of::make_expr< +/// proto::tag::function +/// , construct_helper<T> +/// , A0 const & +/// >::type const +/// construct(A0 const & a0) +/// { +/// return proto::make_expr< +/// proto::tag::function +/// >( +/// construct_helper<T>() +/// , boost::ref(a0) +/// ); +/// } +/// +/// template<typename T, typename A0, typename A1> +/// typename proto::result_of::make_expr< +/// proto::tag::function +/// , construct_helper<T> +/// , A0 const & +/// , A1 const & +/// >::type const +/// construct(A0 const & a0, A1 const & a1) +/// { +/// return proto::make_expr< +/// proto::tag::function +/// >( +/// construct_helper<T>() +/// , boost::ref(a0) +/// , boost::ref(a1) +/// ); +/// } +/// +/// // ... and so on, up to BOOST_PROTO_MAX_ARITY-1 arguments ... +/// \endcode +/// +/// If BOOST_PROTO_LOCAL_LIMITS is not defined by the user, it defaults +/// to (1, BOOST_PROTO_MAX_ARITY) +/// +/// At each iteration, BOOST_PROTO_LOCAL_MACRO is invoked with the current +/// iteration number and the following 4 macro parameters: +/// +/// \li BOOST_PROTO_LOCAL_typename_A +/// \li BOOST_PROTO_LOCAL_A +/// \li BOOST_PROTO_LOCAL_A_a +/// \li BOOST_PROTO_LOCAL_a +/// +/// If these macros are not defined by the user, they default respectively to: +/// +/// \li BOOST_PROTO_typename_A +/// \li BOOST_PROTO_A_const_ref +/// \li BOOST_PROTO_A_const_ref_a +/// \li BOOST_PROTO_ref_a +/// +/// After including BOOST_PROTO_LOCAL_ITERATE(), the following macros are +/// automatically undefined: +/// +/// \li BOOST_PROTO_LOCAL_MACRO +/// \li BOOST_PROTO_LOCAL_LIMITS +/// \li BOOST_PROTO_LOCAL_typename_A +/// \li BOOST_PROTO_LOCAL_A +/// \li BOOST_PROTO_LOCAL_A_a +/// \li BOOST_PROTO_LOCAL_a +#define BOOST_PROTO_LOCAL_ITERATE() <boost/proto/detail/local.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/tags.hpp b/3rdParty/Boost/src/boost/proto/tags.hpp new file mode 100644 index 0000000..5ad9720 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/tags.hpp @@ -0,0 +1,157 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file tags.hpp +/// Contains the tags for all the overloadable operators in C++ +// +// 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_TAGS_HPP_EAN_04_01_2005 +#define BOOST_PROTO_TAGS_HPP_EAN_04_01_2005 + +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace tagns_ { namespace tag +{ + + /// Tag type for terminals; aka, leaves in the expression tree. + struct terminal {}; + + /// Tag type for the unary + operator. + struct unary_plus {}; + + /// Tag type for the unary - operator. + struct negate {}; + + /// Tag type for the unary * operator. + struct dereference {}; + + /// Tag type for the unary ~ operator. + struct complement {}; + + /// Tag type for the unary & operator. + struct address_of {}; + + /// Tag type for the unary ! operator. + struct logical_not {}; + + /// Tag type for the unary prefix ++ operator. + struct pre_inc {}; + + /// Tag type for the unary prefix -- operator. + struct pre_dec {}; + + /// Tag type for the unary postfix ++ operator. + struct post_inc {}; + + /// Tag type for the unary postfix -- operator. + struct post_dec {}; + + /// Tag type for the binary \<\< operator. + struct shift_left {}; + + /// Tag type for the binary \>\> operator. + struct shift_right {}; + + /// Tag type for the binary * operator. + struct multiplies {}; + + /// Tag type for the binary / operator. + struct divides {}; + + /// Tag type for the binary % operator. + struct modulus {}; + + /// Tag type for the binary + operator. + struct plus {}; + + /// Tag type for the binary - operator. + struct minus {}; + + /// Tag type for the binary \< operator. + struct less {}; + + /// Tag type for the binary \> operator. + struct greater {}; + + /// Tag type for the binary \<= operator. + struct less_equal {}; + + /// Tag type for the binary \>= operator. + struct greater_equal {}; + + /// Tag type for the binary == operator. + struct equal_to {}; + + /// Tag type for the binary != operator. + struct not_equal_to {}; + + /// Tag type for the binary || operator. + struct logical_or {}; + + /// Tag type for the binary && operator. + struct logical_and {}; + + /// Tag type for the binary & operator. + struct bitwise_and {}; + + /// Tag type for the binary | operator. + struct bitwise_or {}; + + /// Tag type for the binary ^ operator. + struct bitwise_xor {}; + + /// Tag type for the binary , operator. + struct comma {}; + + /// Tag type for the binary ->* operator. + struct mem_ptr {}; + + /// Tag type for the binary = operator. + struct assign {}; + + /// Tag type for the binary \<\<= operator. + struct shift_left_assign {}; + + /// Tag type for the binary \>\>= operator. + struct shift_right_assign {}; + + /// Tag type for the binary *= operator. + struct multiplies_assign {}; + + /// Tag type for the binary /= operator. + struct divides_assign {}; + + /// Tag type for the binary %= operator. + struct modulus_assign {}; + + /// Tag type for the binary += operator. + struct plus_assign {}; + + /// Tag type for the binary -= operator. + struct minus_assign {}; + + /// Tag type for the binary &= operator. + struct bitwise_and_assign {}; + + /// Tag type for the binary |= operator. + struct bitwise_or_assign {}; + + /// Tag type for the binary ^= operator. + struct bitwise_xor_assign {}; + + /// Tag type for the binary subscript operator. + struct subscript {}; + + /// Tag type for the binary virtual data members. + struct member {}; + + /// Tag type for the ternary ?: conditional operator. + struct if_else_ {}; + + /// Tag type for the n-ary function call operator. + struct function {}; + +}}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/traits.hpp b/3rdParty/Boost/src/boost/proto/traits.hpp new file mode 100644 index 0000000..cf9f091 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/traits.hpp @@ -0,0 +1,1258 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file traits.hpp +/// Contains definitions for child\<\>, child_c\<\>, left\<\>, +/// right\<\>, tag_of\<\>, and the helper functions child(), child_c(), +/// value(), left() and right(). +// +// 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_ARG_TRAITS_HPP_EAN_04_01_2005 +#define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005 + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/static_assert.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/proto/detail/template_arity.hpp> +#include <boost/type_traits/is_pod.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/args.hpp> +#include <boost/proto/domain.hpp> +#include <boost/proto/transform/pass_through.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# if BOOST_WORKAROUND( BOOST_MSVC, >= 1400 ) +# pragma warning(disable: 4180) // warning C4180: qualifier applied to function type has no meaning; ignored +# endif +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template<typename T, typename Void = void> + struct if_vararg + {}; + + template<typename T> + struct if_vararg<T, typename T::proto_is_vararg_> + : T + {}; + + template<typename T, typename Void = void> + struct is_callable2_ + : mpl::false_ + {}; + + template<typename T> + struct is_callable2_<T, typename T::proto_is_callable_> + : mpl::true_ + {}; + + template<typename T BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = boost::proto::detail::template_arity<T>::value)> + struct is_callable_ + : is_callable2_<T> + {}; + + } + + /// \brief Boolean metafunction which detects whether a type is + /// a callable function object type or not. + /// + /// <tt>is_callable\<\></tt> is used by the <tt>when\<\></tt> transform + /// to determine whether a function type <tt>R(A1,A2,...AN)</tt> is a + /// callable transform or an object transform. (The former are evaluated + /// using <tt>call\<\></tt> and the later with <tt>make\<\></tt>.) If + /// <tt>is_callable\<R\>::value</tt> is \c true, the function type is + /// a callable transform; otherwise, it is an object transform. + /// + /// Unless specialized for a type \c T, <tt>is_callable\<T\>::value</tt> + /// is computed as follows: + /// + /// \li If \c T is a template type <tt>X\<Y0,Y1,...YN\></tt>, where all \c Yx + /// are types for \c x in <tt>[0,N]</tt>, <tt>is_callable\<T\>::value</tt> + /// is <tt>is_same\<YN, proto::callable\>::value</tt>. + /// \li If \c T has a nested type \c proto_is_callable_ that is a typedef + /// for \c void, <tt>is_callable\<T\>::value</tt> is \c true. (Note: this is + /// the case for any type that derives from \c proto::callable.) + /// \li Otherwise, <tt>is_callable\<T\>::value</tt> is \c false. + template<typename T> + struct is_callable + : proto::detail::is_callable_<T> + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<proto::_> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<proto::callable> + : mpl::false_ + {}; + + /// INTERNAL ONLY + /// + template<typename PrimitiveTransform, typename X> + struct is_callable<proto::transform<PrimitiveTransform, X> > + : mpl::false_ + {}; + + #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) + // work around GCC bug + template<typename Tag, typename Args, long N> + struct is_callable<proto::expr<Tag, Args, N> > + : mpl::false_ + {}; + + // work around GCC bug + template<typename Tag, typename Args, long N> + struct is_callable<proto::basic_expr<Tag, Args, N> > + : mpl::false_ + {}; + #endif + + namespace detail + { + template<typename T, typename Void /*= void*/> + struct is_transform_ + : mpl::false_ + {}; + + template<typename T> + struct is_transform_<T, typename T::proto_is_transform_> + : mpl::true_ + {}; + } + + /// \brief Boolean metafunction which detects whether a type is + /// a PrimitiveTransform type or not. + /// + /// <tt>is_transform\<\></tt> is used by the <tt>call\<\></tt> transform + /// to determine whether the function types <tt>R()</tt>, <tt>R(A1)</tt>, + /// and <tt>R(A1, A2)</tt> should be passed the expression, state and data + /// parameters (as needed). + /// + /// Unless specialized for a type \c T, <tt>is_transform\<T\>::value</tt> + /// is computed as follows: + /// + /// \li If \c T has a nested type \c proto_is_transform_ that is a typedef + /// for \c void, <tt>is_transform\<T\>::value</tt> is \c true. (Note: this is + /// the case for any type that derives from an instantiation of \c proto::transform.) + /// \li Otherwise, <tt>is_transform\<T\>::value</tt> is \c false. + template<typename T> + struct is_transform + : proto::detail::is_transform_<T> + {}; + + namespace detail + { + template<typename T, typename Void /*= void*/> + struct is_aggregate_ + : is_pod<T> + {}; + + template<typename Tag, typename Args, long N> + struct is_aggregate_<proto::expr<Tag, Args, N>, void> + : mpl::true_ + {}; + + template<typename Tag, typename Args, long N> + struct is_aggregate_<proto::basic_expr<Tag, Args, N>, void> + : mpl::true_ + {}; + + template<typename T> + struct is_aggregate_<T, typename T::proto_is_aggregate_> + : mpl::true_ + {}; + } + + /// \brief A Boolean metafunction that indicates whether a type requires + /// aggregate initialization. + /// + /// <tt>is_aggregate\<\></tt> is used by the <tt>make\<\></tt> transform + /// to determine how to construct an object of some type \c T, given some + /// initialization arguments <tt>a0,a1,...aN</tt>. + /// If <tt>is_aggregate\<T\>::value</tt> is \c true, then an object of + /// type T will be initialized as <tt>T t = {a0,a1,...aN};</tt>. Otherwise, + /// it will be initialized as <tt>T t(a0,a1,...aN)</tt>. + template<typename T> + struct is_aggregate + : proto::detail::is_aggregate_<T> + {}; + + /// \brief A Boolean metafunction that indicates whether a given + /// type \c T is a Proto expression type. + /// + /// If \c T has a nested type \c proto_is_expr_ that is a typedef + /// for \c void, <tt>is_expr\<T\>::value</tt> is \c true. (Note, this + /// is the case for <tt>proto::expr\<\></tt>, any type that is derived + /// from <tt>proto::extends\<\></tt> or that uses the + /// <tt>BOOST_PROTO_BASIC_EXTENDS()</tt> macro.) Otherwise, + /// <tt>is_expr\<T\>::value</tt> is \c false. + template<typename T, typename Void /* = void*/> + struct is_expr + : mpl::false_ + {}; + + /// \brief A Boolean metafunction that indicates whether a given + /// type \c T is a Proto expression type. + /// + /// If \c T has a nested type \c proto_is_expr_ that is a typedef + /// for \c void, <tt>is_expr\<T\>::value</tt> is \c true. (Note, this + /// is the case for <tt>proto::expr\<\></tt>, any type that is derived + /// from <tt>proto::extends\<\></tt> or that uses the + /// <tt>BOOST_PROTO_BASIC_EXTENDS()</tt> macro.) Otherwise, + /// <tt>is_expr\<T\>::value</tt> is \c false. + template<typename T> + struct is_expr<T, typename T::proto_is_expr_> + : mpl::true_ + {}; + + template<typename T> + struct is_expr<T &, void> + : is_expr<T> + {}; + + /// \brief A metafunction that returns the tag type of a + /// Proto expression. + template<typename Expr> + struct tag_of + { + typedef typename Expr::proto_tag type; + }; + + template<typename Expr> + struct tag_of<Expr &> + { + typedef typename Expr::proto_tag type; + }; + + /// \brief A metafunction that returns the arity of a + /// Proto expression. + template<typename Expr> + struct arity_of + : Expr::proto_arity + {}; + + template<typename Expr> + struct arity_of<Expr &> + : Expr::proto_arity + {}; + + namespace result_of + { + /// \brief A metafunction that computes the return type of the \c as_expr() + /// function. + template<typename T, typename Domain /*= default_domain*/> + struct as_expr + { + typedef typename Domain::template as_expr<T>::result_type type; + }; + + /// \brief A metafunction that computes the return type of the \c as_child() + /// function. + template<typename T, typename Domain /*= default_domain*/> + struct as_child + { + typedef typename Domain::template as_child<T>::result_type type; + }; + + /// \brief A metafunction that returns the type of the Nth child + /// of a Proto expression, where N is an MPL Integral Constant. + /// + /// <tt>result_of::child\<Expr, N\></tt> is equivalent to + /// <tt>result_of::child_c\<Expr, N::value\></tt>. + template<typename Expr, typename N /* = mpl::long_<0>*/> + struct child + : child_c<Expr, N::value> + {}; + + /// \brief A metafunction that returns the type of the value + /// of a terminal Proto expression. + /// + template<typename Expr> + struct value + { + /// Verify that we are actually operating on a terminal + BOOST_STATIC_ASSERT(0 == Expr::proto_arity_c); + + /// The raw type of the Nth child as it is stored within + /// \c Expr. This may be a value or a reference + typedef typename Expr::proto_child0 value_type; + + /// The "value" type of the child, suitable for storage by value, + /// computed as follows: + /// \li <tt>T const(&)[N]</tt> becomes <tt>T[N]</tt> + /// \li <tt>T[N]</tt> becomes <tt>T[N]</tt> + /// \li <tt>T(&)[N]</tt> becomes <tt>T[N]</tt> + /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt> + /// \li <tt>T const &</tt> becomes <tt>T</tt> + /// \li <tt>T &</tt> becomes <tt>T</tt> + /// \li <tt>T</tt> becomes <tt>T</tt> + typedef typename detail::term_traits<typename Expr::proto_child0>::value_type type; + }; + + template<typename Expr> + struct value<Expr &> + { + /// Verify that we are actually operating on a terminal + BOOST_STATIC_ASSERT(0 == Expr::proto_arity_c); + + /// The raw type of the Nth child as it is stored within + /// \c Expr. This may be a value or a reference + typedef typename Expr::proto_child0 value_type; + + /// The "reference" type of the child, suitable for storage by + /// reference, computed as follows: + /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt> + /// \li <tt>T[N]</tt> becomes <tt>T(&)[N]</tt> + /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt> + /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt> + /// \li <tt>T const &</tt> becomes <tt>T const &</tt> + /// \li <tt>T &</tt> becomes <tt>T &</tt> + /// \li <tt>T</tt> becomes <tt>T &</tt> + typedef typename detail::term_traits<typename Expr::proto_child0>::reference type; + }; + + template<typename Expr> + struct value<Expr const &> + { + /// Verify that we are actually operating on a terminal + BOOST_STATIC_ASSERT(0 == Expr::proto_arity_c); + + /// The raw type of the Nth child as it is stored within + /// \c Expr. This may be a value or a reference + typedef typename Expr::proto_child0 value_type; + + /// The "const reference" type of the child, suitable for storage by + /// const reference, computed as follows: + /// \li <tt>T const(&)[N]</tt> becomes <tt>T const(&)[N]</tt> + /// \li <tt>T[N]</tt> becomes <tt>T const(&)[N]</tt> + /// \li <tt>T(&)[N]</tt> becomes <tt>T(&)[N]</tt> + /// \li <tt>R(&)(A0,...)</tt> becomes <tt>R(&)(A0,...)</tt> + /// \li <tt>T const &</tt> becomes <tt>T const &</tt> + /// \li <tt>T &</tt> becomes <tt>T &</tt> + /// \li <tt>T</tt> becomes <tt>T const &</tt> + typedef typename detail::term_traits<typename Expr::proto_child0>::const_reference type; + }; + + /// \brief A metafunction that returns the type of the left child + /// of a binary Proto expression. + /// + /// <tt>result_of::left\<Expr\></tt> is equivalent to + /// <tt>result_of::child_c\<Expr, 0\></tt>. + template<typename Expr> + struct left + : child_c<Expr, 0> + {}; + + /// \brief A metafunction that returns the type of the right child + /// of a binary Proto expression. + /// + /// <tt>result_of::right\<Expr\></tt> is equivalent to + /// <tt>result_of::child_c\<Expr, 1\></tt>. + template<typename Expr> + struct right + : child_c<Expr, 1> + {}; + + } // namespace result_of + + /// \brief A metafunction for generating terminal expression types, + /// a grammar element for matching terminal expressions, and a + /// PrimitiveTransform that returns the current expression unchanged. + template<typename T> + struct terminal + : proto::transform<terminal<T>, int> + { + typedef proto::expr<proto::tag::terminal, term<T>, 0> type; + typedef proto::basic_expr<proto::tag::terminal, term<T>, 0> proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// \param e The current expression + /// \pre <tt>matches\<Expr, terminal\<T\> \>::value</tt> is \c true. + /// \return \c e + /// \throw nothrow + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) + operator ()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return e; + } + }; + + /// INTERNAL ONLY + typedef proto::tag::terminal proto_tag; + /// INTERNAL ONLY + typedef T proto_child0; + }; + + /// \brief A metafunction for generating ternary conditional expression types, + /// a grammar element for matching ternary conditional expressions, and a + /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> + /// transform. + template<typename T, typename U, typename V> + struct if_else_ + : proto::transform<if_else_<T, U, V>, int> + { + typedef proto::expr<proto::tag::if_else_, list3<T, U, V>, 3> type; + typedef proto::basic_expr<proto::tag::if_else_, list3<T, U, V>, 3> proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<if_else_, deduce_domain, Expr, State, Data> + {}; + + /// INTERNAL ONLY + typedef proto::tag::if_else_ proto_tag; + /// INTERNAL ONLY + typedef T proto_child0; + /// INTERNAL ONLY + typedef U proto_child1; + /// INTERNAL ONLY + typedef V proto_child2; + }; + + /// \brief A metafunction for generating nullary expression types with a + /// specified tag type, + /// a grammar element for matching nullary expressions, and a + /// PrimitiveTransform that returns the current expression unchanged. + /// + /// Use <tt>nullary_expr\<_, _\></tt> as a grammar element to match any + /// nullary expression. + template<typename Tag, typename T> + struct nullary_expr + : proto::transform<nullary_expr<Tag, T>, int> + { + typedef proto::expr<Tag, term<T>, 0> type; + typedef proto::basic_expr<Tag, term<T>, 0> proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// \param e The current expression + /// \pre <tt>matches\<Expr, nullary_expr\<Tag, T\> \>::value</tt> is \c true. + /// \return \c e + /// \throw nothrow + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) + operator ()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return e; + } + }; + + /// INTERNAL ONLY + typedef Tag proto_tag; + /// INTERNAL ONLY + typedef T proto_child0; + }; + + /// \brief A metafunction for generating unary expression types with a + /// specified tag type, + /// a grammar element for matching unary expressions, and a + /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> + /// transform. + /// + /// Use <tt>unary_expr\<_, _\></tt> as a grammar element to match any + /// unary expression. + template<typename Tag, typename T> + struct unary_expr + : proto::transform<unary_expr<Tag, T>, int> + { + typedef proto::expr<Tag, list1<T>, 1> type; + typedef proto::basic_expr<Tag, list1<T>, 1> proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<unary_expr, deduce_domain, Expr, State, Data> + {}; + + /// INTERNAL ONLY + typedef Tag proto_tag; + /// INTERNAL ONLY + typedef T proto_child0; + }; + + /// \brief A metafunction for generating binary expression types with a + /// specified tag type, + /// a grammar element for matching binary expressions, and a + /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt> + /// transform. + /// + /// Use <tt>binary_expr\<_, _, _\></tt> as a grammar element to match any + /// binary expression. + template<typename Tag, typename T, typename U> + struct binary_expr + : proto::transform<binary_expr<Tag, T, U>, int> + { + typedef proto::expr<Tag, list2<T, U>, 2> type; + typedef proto::basic_expr<Tag, list2<T, U>, 2> proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<binary_expr, deduce_domain, Expr, State, Data> + {}; + + /// INTERNAL ONLY + typedef Tag proto_tag; + /// INTERNAL ONLY + typedef T proto_child0; + /// INTERNAL ONLY + typedef U proto_child1; + }; + +#define BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(Op) \ + template<typename T> \ + struct Op \ + : proto::transform<Op<T>, int> \ + { \ + typedef proto::expr<proto::tag::Op, list1<T>, 1> type; \ + typedef proto::basic_expr<proto::tag::Op, list1<T>, 1> proto_grammar; \ + \ + template<typename Expr, typename State, typename Data> \ + struct impl \ + : detail::pass_through_impl<Op, deduce_domain, Expr, State, Data> \ + {}; \ + \ + typedef proto::tag::Op proto_tag; \ + typedef T proto_child0; \ + }; \ + /**/ + +#define BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(Op) \ + template<typename T, typename U> \ + struct Op \ + : proto::transform<Op<T, U>, int> \ + { \ + typedef proto::expr<proto::tag::Op, list2<T, U>, 2> type; \ + typedef proto::basic_expr<proto::tag::Op, list2<T, U>, 2> proto_grammar; \ + \ + template<typename Expr, typename State, typename Data> \ + struct impl \ + : detail::pass_through_impl<Op, deduce_domain, Expr, State, Data> \ + {}; \ + \ + typedef proto::tag::Op proto_tag; \ + typedef T proto_child0; \ + typedef U proto_child1; \ + }; \ + /**/ + + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(unary_plus) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(negate) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(dereference) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(complement) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(address_of) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(logical_not) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(pre_inc) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(pre_dec) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(post_inc) + BOOST_PROTO_DEFINE_UNARY_METAFUNCTION(post_dec) + + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_left) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_right) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(multiplies) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(divides) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(modulus) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(plus) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(minus) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(less) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(greater) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(less_equal) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(greater_equal) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(equal_to) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(not_equal_to) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(logical_or) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(logical_and) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_or) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_and) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_xor) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(comma) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(mem_ptr) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_left_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(shift_right_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(multiplies_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(divides_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(modulus_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(plus_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(minus_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_or_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_and_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(bitwise_xor_assign) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(subscript) + BOOST_PROTO_DEFINE_BINARY_METAFUNCTION(member) + + #undef BOOST_PROTO_DEFINE_UNARY_METAFUNCTION + #undef BOOST_PROTO_DEFINE_BINARY_METAFUNCTION + + #include <boost/proto/detail/traits.hpp> + + namespace functional + { + /// \brief A callable PolymorphicFunctionObject that is + /// equivalent to the \c as_expr() function. + template<typename Domain /* = default_domain*/> + struct as_expr + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef typename Domain::template as_expr<T>::result_type type; + }; + + template<typename This, typename T> + struct result<This(T &)> + { + typedef typename Domain::template as_expr<T>::result_type type; + }; + + /// \brief Wrap an object in a Proto terminal if it isn't a + /// Proto expression already. + /// \param t The object to wrap. + /// \return <tt>proto::as_expr\<Domain\>(t)</tt> + template<typename T> + BOOST_FORCEINLINE + typename add_const<typename result<as_expr(T &)>::type>::type + operator ()(T &t) const + { + return typename Domain::template as_expr<T>()(t); + } + + /// \overload + /// + template<typename T> + BOOST_FORCEINLINE + typename add_const<typename result<as_expr(T const &)>::type>::type + operator ()(T const &t) const + { + return typename Domain::template as_expr<T const>()(t); + } + + #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + template<typename T, std::size_t N_> + BOOST_FORCEINLINE + typename add_const<typename result<as_expr(T (&)[N_])>::type>::type + operator ()(T (&t)[N_]) const + { + return typename Domain::template as_expr<T[N_]>()(t); + } + + template<typename T, std::size_t N_> + BOOST_FORCEINLINE + typename add_const<typename result<as_expr(T const (&)[N_])>::type>::type + operator ()(T const (&t)[N_]) const + { + return typename Domain::template as_expr<T const[N_]>()(t); + } + #endif + }; + + /// \brief A callable PolymorphicFunctionObject that is + /// equivalent to the \c as_child() function. + template<typename Domain /* = default_domain*/> + struct as_child + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef typename Domain::template as_child<T>::result_type type; + }; + + template<typename This, typename T> + struct result<This(T &)> + { + typedef typename Domain::template as_child<T>::result_type type; + }; + + /// \brief Wrap an object in a Proto terminal if it isn't a + /// Proto expression already. + /// \param t The object to wrap. + /// \return <tt>proto::as_child\<Domain\>(t)</tt> + template<typename T> + BOOST_FORCEINLINE + typename add_const<typename result<as_child(T &)>::type>::type + operator ()(T &t) const + { + return typename Domain::template as_child<T>()(t); + } + + /// \overload + /// + template<typename T> + BOOST_FORCEINLINE + typename add_const<typename result<as_child(T const &)>::type>::type + operator ()(T const &t) const + { + return typename Domain::template as_child<T const>()(t); + } + }; + + /// \brief A callable PolymorphicFunctionObject that is + /// equivalent to the \c child_c() function. + template<long N> + struct child_c + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef typename result_of::child_c<Expr, N>::type type; + }; + + /// \brief Return the Nth child of the given expression. + /// \param expr The expression node. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true + /// \pre <tt>N \< Expr::proto_arity::value</tt> + /// \return <tt>proto::child_c\<N\>(expr)</tt> + /// \throw nothrow + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::child_c<Expr &, N>::type + operator ()(Expr &e) const + { + return result_of::child_c<Expr &, N>::call(e); + } + + /// \overload + /// + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::child_c<Expr const &, N>::type + operator ()(Expr const &e) const + { + return result_of::child_c<Expr const &, N>::call(e); + } + }; + + /// \brief A callable PolymorphicFunctionObject that is + /// equivalent to the \c child() function. + /// + /// A callable PolymorphicFunctionObject that is + /// equivalent to the \c child() function. \c N is required + /// to be an MPL Integral Constant. + template<typename N /* = mpl::long_<0>*/> + struct child + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef typename result_of::child<Expr, N>::type type; + }; + + /// \brief Return the Nth child of the given expression. + /// \param expr The expression node. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true + /// \pre <tt>N::value \< Expr::proto_arity::value</tt> + /// \return <tt>proto::child\<N\>(expr)</tt> + /// \throw nothrow + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::child<Expr &, N>::type + operator ()(Expr &e) const + { + return result_of::child<Expr &, N>::call(e); + } + + /// \overload + /// + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::child<Expr const &, N>::type + operator ()(Expr const &e) const + { + return result_of::child<Expr const &, N>::call(e); + } + }; + + /// \brief A callable PolymorphicFunctionObject that is + /// equivalent to the \c value() function. + struct value + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef typename result_of::value<Expr>::type type; + }; + + /// \brief Return the value of the given terminal expression. + /// \param expr The terminal expression node. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true + /// \pre <tt>0 == Expr::proto_arity::value</tt> + /// \return <tt>proto::value(expr)</tt> + /// \throw nothrow + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::value<Expr &>::type + operator ()(Expr &e) const + { + return e.proto_base().child0; + } + + /// \overload + /// + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::value<Expr const &>::type + operator ()(Expr const &e) const + { + return e.proto_base().child0; + } + }; + + /// \brief A callable PolymorphicFunctionObject that is + /// equivalent to the \c left() function. + struct left + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef typename result_of::left<Expr>::type type; + }; + + /// \brief Return the left child of the given binary expression. + /// \param expr The expression node. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true + /// \pre <tt>2 == Expr::proto_arity::value</tt> + /// \return <tt>proto::left(expr)</tt> + /// \throw nothrow + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::left<Expr &>::type + operator ()(Expr &e) const + { + return e.proto_base().child0; + } + + /// \overload + /// + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::left<Expr const &>::type + operator ()(Expr const &e) const + { + return e.proto_base().child0; + } + }; + + /// \brief A callable PolymorphicFunctionObject that is + /// equivalent to the \c right() function. + struct right + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Expr> + struct result<This(Expr)> + { + typedef typename result_of::right<Expr>::type type; + }; + + /// \brief Return the right child of the given binary expression. + /// \param expr The expression node. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true + /// \pre <tt>2 == Expr::proto_arity::value</tt> + /// \return <tt>proto::right(expr)</tt> + /// \throw nothrow + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::right<Expr &>::type + operator ()(Expr &e) const + { + return e.proto_base().child1; + } + + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::right<Expr const &>::type + operator ()(Expr const &e) const + { + return e.proto_base().child1; + } + }; + + } + + /// \brief A function that wraps non-Proto expression types in Proto + /// terminals and leaves Proto expression types alone. + /// + /// The <tt>as_expr()</tt> function turns objects into Proto terminals if + /// they are not Proto expression types already. Non-Proto types are + /// held by value, if possible. Types which are already Proto types are + /// left alone and returned by reference. + /// + /// This function can be called either with an explicitly specified + /// \c Domain parameter (i.e., <tt>as_expr\<Domain\>(t)</tt>), or + /// without (i.e., <tt>as_expr(t)</tt>). If no domain is + /// specified, \c default_domain is assumed. + /// + /// If <tt>is_expr\<T\>::value</tt> is \c true, then the argument is + /// returned unmodified, by reference. Otherwise, the argument is wrapped + /// in a Proto terminal expression node according to the following rules. + /// If \c T is a function type, let \c A be <tt>T &</tt>. Otherwise, let + /// \c A be the type \c T stripped of cv-qualifiers. Then, \c as_expr() + /// returns <tt>Domain()(terminal\<A\>::type::make(t))</tt>. + /// + /// \param t The object to wrap. + template<typename T> + BOOST_FORCEINLINE + typename add_const<typename result_of::as_expr<T, default_domain>::type>::type + as_expr(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)) + { + return default_domain::as_expr<T>()(t); + } + + /// \overload + /// + template<typename T> + BOOST_FORCEINLINE + typename add_const<typename result_of::as_expr<T const, default_domain>::type>::type + as_expr(T const &t) + { + return default_domain::as_expr<T const>()(t); + } + + /// \overload + /// + template<typename Domain, typename T> + BOOST_FORCEINLINE + typename add_const<typename result_of::as_expr<T, Domain>::type>::type + as_expr(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)) + { + return typename Domain::template as_expr<T>()(t); + } + + /// \overload + /// + template<typename Domain, typename T> + BOOST_FORCEINLINE + typename add_const<typename result_of::as_expr<T const, Domain>::type>::type + as_expr(T const &t) + { + return typename Domain::template as_expr<T const>()(t); + } + + /// \brief A function that wraps non-Proto expression types in Proto + /// terminals (by reference) and returns Proto expression types by + /// reference + /// + /// The <tt>as_child()</tt> function turns objects into Proto terminals if + /// they are not Proto expression types already. Non-Proto types are + /// held by reference. Types which are already Proto types are simply + /// returned as-is. + /// + /// This function can be called either with an explicitly specified + /// \c Domain parameter (i.e., <tt>as_child\<Domain\>(t)</tt>), or + /// without (i.e., <tt>as_child(t)</tt>). If no domain is + /// specified, \c default_domain is assumed. + /// + /// If <tt>is_expr\<T\>::value</tt> is \c true, then the argument is + /// returned as-is. Otherwise, \c as_child() returns + /// <tt>Domain()(terminal\<T &\>::type::make(t))</tt>. + /// + /// \param t The object to wrap. + template<typename T> + BOOST_FORCEINLINE + typename add_const<typename result_of::as_child<T, default_domain>::type>::type + as_child(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)) + { + return default_domain::as_child<T>()(t); + } + + /// \overload + /// + template<typename T> + BOOST_FORCEINLINE + typename add_const<typename result_of::as_child<T const, default_domain>::type>::type + as_child(T const &t) + { + return default_domain::as_child<T const>()(t); + } + + /// \overload + /// + template<typename Domain, typename T> + BOOST_FORCEINLINE + typename add_const<typename result_of::as_child<T, Domain>::type>::type + as_child(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T) BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)) + { + return typename Domain::template as_child<T>()(t); + } + + /// \overload + /// + template<typename Domain, typename T> + BOOST_FORCEINLINE + typename add_const<typename result_of::as_child<T const, Domain>::type>::type + as_child(T const &t) + { + return typename Domain::template as_child<T const>()(t); + } + + /// \brief Return the Nth child of the specified Proto expression. + /// + /// Return the Nth child of the specified Proto expression. If + /// \c N is not specified, as in \c child(expr), then \c N is assumed + /// to be <tt>mpl::long_\<0\></tt>. The child is returned by + /// reference. + /// + /// \param expr The Proto expression. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. + /// \pre \c N is an MPL Integral Constant. + /// \pre <tt>N::value \< Expr::proto_arity::value</tt> + /// \throw nothrow + /// \return A reference to the Nth child + template<typename N, typename Expr> + BOOST_FORCEINLINE + typename result_of::child<Expr &, N>::type + child(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) + { + return result_of::child<Expr &, N>::call(e); + } + + /// \overload + /// + template<typename N, typename Expr> + BOOST_FORCEINLINE + typename result_of::child<Expr const &, N>::type + child(Expr const &e) + { + return result_of::child<Expr const &, N>::call(e); + } + + /// \overload + /// + template<typename Expr2> + BOOST_FORCEINLINE + typename detail::expr_traits<typename Expr2::proto_base_expr::proto_child0>::reference + child(Expr2 &expr2 BOOST_PROTO_DISABLE_IF_IS_CONST(Expr2)) + { + return expr2.proto_base().child0; + } + + /// \overload + /// + template<typename Expr2> + BOOST_FORCEINLINE + typename detail::expr_traits<typename Expr2::proto_base_expr::proto_child0>::const_reference + child(Expr2 const &expr2) + { + return expr2.proto_base().child0; + } + + /// \brief Return the Nth child of the specified Proto expression. + /// + /// Return the Nth child of the specified Proto expression. The child + /// is returned by reference. + /// + /// \param expr The Proto expression. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. + /// \pre <tt>N \< Expr::proto_arity::value</tt> + /// \throw nothrow + /// \return A reference to the Nth child + template<long N, typename Expr> + BOOST_FORCEINLINE + typename result_of::child_c<Expr &, N>::type + child_c(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) + { + return result_of::child_c<Expr &, N>::call(e); + } + + /// \overload + /// + template<long N, typename Expr> + BOOST_FORCEINLINE + typename result_of::child_c<Expr const &, N>::type + child_c(Expr const &e) + { + return result_of::child_c<Expr const &, N>::call(e); + } + + /// \brief Return the value stored within the specified Proto + /// terminal expression. + /// + /// Return the the value stored within the specified Proto + /// terminal expression. The value is returned by + /// reference. + /// + /// \param expr The Proto terminal expression. + /// \pre <tt>N::value == 0</tt> + /// \throw nothrow + /// \return A reference to the terminal's value + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::value<Expr &>::type + value(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) + { + return e.proto_base().child0; + } + + /// \overload + /// + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::value<Expr const &>::type + value(Expr const &e) + { + return e.proto_base().child0; + } + + /// \brief Return the left child of the specified binary Proto + /// expression. + /// + /// Return the left child of the specified binary Proto expression. The + /// child is returned by reference. + /// + /// \param expr The Proto expression. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. + /// \pre <tt>2 == Expr::proto_arity::value</tt> + /// \throw nothrow + /// \return A reference to the left child + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::left<Expr &>::type + left(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) + { + return e.proto_base().child0; + } + + /// \overload + /// + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::left<Expr const &>::type + left(Expr const &e) + { + return e.proto_base().child0; + } + + /// \brief Return the right child of the specified binary Proto + /// expression. + /// + /// Return the right child of the specified binary Proto expression. The + /// child is returned by reference. + /// + /// \param expr The Proto expression. + /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. + /// \pre <tt>2 == Expr::proto_arity::value</tt> + /// \throw nothrow + /// \return A reference to the right child + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::right<Expr &>::type + right(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) + { + return e.proto_base().child1; + } + + /// \overload + /// + template<typename Expr> + BOOST_FORCEINLINE + typename result_of::right<Expr const &>::type + right(Expr const &e) + { + return e.proto_base().child1; + } + + /// INTERNAL ONLY + /// + template<typename Domain> + struct is_callable<functional::as_expr<Domain> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Domain> + struct is_callable<functional::as_child<Domain> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<long N> + struct is_callable<functional::child_c<N> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename N> + struct is_callable<functional::child<N> > + : mpl::true_ + {}; + +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform.hpp b/3rdParty/Boost/src/boost/proto/transform.hpp new file mode 100644 index 0000000..ae376d7 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform.hpp @@ -0,0 +1,24 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file transform.hpp +/// Includes all the transforms in the transform/ sub-directory. +// +// 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_TRANSFORM_HPP_EAN_06_23_2007 +#define BOOST_PROTO_TRANSFORM_HPP_EAN_06_23_2007 + +#include <boost/proto/transform/arg.hpp> +#include <boost/proto/transform/call.hpp> +#include <boost/proto/transform/default.hpp> +#include <boost/proto/transform/env.hpp> +#include <boost/proto/transform/fold.hpp> +#include <boost/proto/transform/fold_tree.hpp> +#include <boost/proto/transform/integral_c.hpp> +#include <boost/proto/transform/lazy.hpp> +#include <boost/proto/transform/make.hpp> +#include <boost/proto/transform/pass_through.hpp> +#include <boost/proto/transform/when.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/arg.hpp b/3rdParty/Boost/src/boost/proto/transform/arg.hpp new file mode 100644 index 0000000..9fdf80e --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/arg.hpp @@ -0,0 +1,359 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file arg.hpp +/// Contains definition of the argN transforms. +// +// 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_TRANSFORM_ARG_HPP_EAN_11_01_2007 +#define BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007 + +#include <boost/mpl/if.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/type_traits/is_array.hpp> +#include <boost/proto/transform/env.hpp> + +namespace boost { namespace proto +{ + + /// \brief A PrimitiveTransform that returns the current expression + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// proto::terminal<int>::type & j = proto::_expr()(i); + /// assert( boost::addressof(i) == boost::addressof(j) ); + /// \endcode + struct _expr : transform<_expr> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// Returns the current expression. + /// \param e The current expression. + /// \return \c e + /// \throw nothrow + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) + operator()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return e; + } + }; + }; + + /// \brief A PrimitiveTransform that returns the current state + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// char ch = proto::_state()(i, 'a'); + /// assert( ch == 'a' ); + /// \endcode + struct _state : transform<_state> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef State result_type; + + /// Returns the current state. + /// \param s The current state. + /// \return \c s + /// \throw nothrow + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::state_param) + operator ()( + typename impl::expr_param + , typename impl::state_param s + , typename impl::data_param + ) const + { + return s; + } + }; + }; + + /// \brief A PrimitiveTransform that returns the current data + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// std::string str("hello"); + /// std::string & data = proto::_data()(i, 'a', str); + /// assert( &str == &data ); + /// \endcode + struct _data : transform<_data> + { + template<typename Expr, typename State, typename Data> + struct impl + : mpl::if_c< + is_env<Data>::value + , _env_var<data_type> + , _env + >::type::template impl<Expr, State, Data> + {}; + }; + + /// \brief A PrimitiveTransform that returns N-th child of the current + /// expression. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// proto::terminal<int>::type & j = proto::_child_c<0>()(-i); + /// assert( boost::addressof(i) == boost::addressof(j) ); + /// \endcode + template<int N> + struct _child_c : transform<_child_c<N> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef + typename result_of::child_c<Expr, N>::type + result_type; + + /// Returns the N-th child of \c e + /// \pre <tt>arity_of\<Expr\>::value \> N</tt> + /// \param e The current expression. + /// \return <tt>proto::child_c\<N\>(e)</tt> + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + result_type + #else + typename result_of::child_c<typename impl::expr_param, N>::type + #endif + operator ()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return proto::child_c<N>(e); + } + }; + }; + + /// \brief A PrimitiveTransform that returns the value of the + /// current terminal expression. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// int j = proto::_value()(i); + /// assert( 42 == j ); + /// \endcode + struct _value : transform<_value> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef + typename result_of::value<Expr>::type + result_type; + + /// Returns the value of the specified terminal expression. + /// \pre <tt>arity_of\<Expr\>::value == 0</tt>. + /// \param e The current expression. + /// \return <tt>proto::value(e)</tt> + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + typename mpl::if_c<is_array<result_type>::value, result_type &, result_type>::type + #else + typename result_of::value<typename impl::expr_param>::type + #endif + operator ()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return proto::value(e); + } + }; + }; + + /// \brief A PrimitiveTransform that does nothing + /// and returns void. + struct _void : transform<_void> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef void result_type; + + /// Does nothing and returns void + void operator ()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param + ) const + {} + }; + }; + + /// \brief A unary CallableTransform that wraps its argument + /// in a \c boost::reference_wrapper\<\>. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// boost::reference_wrapper<proto::terminal<int>::type> j + /// = proto::when<_, proto::_byref(_)>()(i); + /// assert( boost::addressof(i) == boost::addressof(j.get()) ); + /// \endcode + struct _byref : callable + { + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef boost::reference_wrapper<T const> const type; + }; + + template<typename This, typename T> + struct result<This(T &)> + { + typedef boost::reference_wrapper<T> const type; + }; + + /// Wrap the parameter \c t in a \c boost::reference_wrapper\<\> + /// \param t The object to wrap + /// \return <tt>boost::ref(t)</tt> + /// \throw nothrow + template<typename T> + boost::reference_wrapper<T> const operator ()(T &t) const + { + return boost::reference_wrapper<T>(t); + } + + /// \overload + /// + template<typename T> + boost::reference_wrapper<T const> const operator ()(T const &t) const + { + return boost::reference_wrapper<T const>(t); + } + }; + + /// \brief A unary CallableTransform that strips references + /// and \c boost::reference_wrapper\<\> from its argument. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// int j = 67; + /// int k = proto::when<_, proto::_byval(proto::_state)>()(i, boost::ref(j)); + /// assert( 67 == k ); + /// \endcode + struct _byval : callable + { + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef T type; + }; + + template<typename This, typename T> + struct result<This(T &)> + : result<This(T)> + {}; + + template<typename This, typename T> + struct result<This(boost::reference_wrapper<T>)> + : result<This(T)> + {}; + + /// \param t The object to unref + /// \return <tt>t</tt> + /// \throw nothrow + template<typename T> + T operator ()(T const &t) const + { + return t; + } + + /// \overload + /// + template<typename T> + T operator ()(boost::reference_wrapper<T> const &t) const + { + return t; + } + }; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_expr> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_state> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_data> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<int N> + struct is_callable<_child_c<N> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_value> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_byref> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_byval> + : mpl::true_ + {}; + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/call.hpp b/3rdParty/Boost/src/boost/proto/transform/call.hpp new file mode 100644 index 0000000..7d87c90 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/call.hpp @@ -0,0 +1,401 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file call.hpp +/// Contains definition of the call<> transform. +// +// 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_TRANSFORM_CALL_HPP_EAN_11_02_2007 +#define BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007 + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable: 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/ref.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/proto/detail/as_lvalue.hpp> +#include <boost/proto/detail/poly_function.hpp> +#include <boost/proto/transform/detail/pack.hpp> + +namespace boost { namespace proto +{ + /// \brief Wrap \c PrimitiveTransform so that <tt>when\<\></tt> knows + /// it is callable. Requires that the parameter is actually a + /// PrimitiveTransform. + /// + /// This form of <tt>call\<\></tt> is useful for annotating an + /// arbitrary PrimitiveTransform as callable when using it with + /// <tt>when\<\></tt>. Consider the following transform, which + /// is parameterized with another transform. + /// + /// \code + /// template<typename Grammar> + /// struct Foo + /// : when< + /// unary_plus<Grammar> + /// , Grammar(_child) // May or may not work. + /// > + /// {}; + /// \endcode + /// + /// The problem with the above is that <tt>when\<\></tt> may or + /// may not recognize \c Grammar as callable, depending on how + /// \c Grammar is implemented. (See <tt>is_callable\<\></tt> for + /// a discussion of this issue.) You can guard against + /// the issue by wrapping \c Grammar in <tt>call\<\></tt>, such + /// as: + /// + /// \code + /// template<typename Grammar> + /// struct Foo + /// : when< + /// unary_plus<Grammar> + /// , call<Grammar>(_child) // OK, this works + /// > + /// {}; + /// \endcode + /// + /// The above could also have been written as: + /// + /// \code + /// template<typename Grammar> + /// struct Foo + /// : when< + /// unary_plus<Grammar> + /// , call<Grammar(_child)> // OK, this works, too + /// > + /// {}; + /// \endcode + template<typename PrimitiveTransform> + struct call + : PrimitiveTransform + {}; + + /// \brief A specialization that treats function pointer Transforms as + /// if they were function type Transforms. + /// + /// This specialization requires that \c Fun is actually a function type. + /// + /// This specialization is required for nested transforms such as + /// <tt>call\<T0(T1(_))\></tt>. In C++, functions that are used as + /// parameters to other functions automatically decay to funtion + /// pointer types. In other words, the type <tt>T0(T1(_))</tt> is + /// indistinguishable from <tt>T0(T1(*)(_))</tt>. This specialization + /// is required to handle these nested function pointer type transforms + /// properly. + template<typename Fun> + struct call<Fun *> + : call<Fun> + {}; + + /// INTERNAL ONLY + template<typename Fun> + struct call<detail::msvc_fun_workaround<Fun> > + : call<Fun> + {}; + + /// \brief Either call the PolymorphicFunctionObject with 0 + /// arguments, or invoke the PrimitiveTransform with 3 + /// arguments. + template<typename Fun> + struct call<Fun()> : transform<call<Fun()> > + { + /// INTERNAL ONLY + template<typename Expr, typename State, typename Data, bool B> + struct impl2 + : transform_impl<Expr, State, Data> + { + typedef typename BOOST_PROTO_RESULT_OF<Fun()>::type result_type; + + BOOST_FORCEINLINE + result_type operator()( + typename impl2::expr_param + , typename impl2::state_param + , typename impl2::data_param + ) const + { + return Fun()(); + } + }; + + /// INTERNAL ONLY + template<typename Expr, typename State, typename Data> + struct impl2<Expr, State, Data, true> + : Fun::template impl<Expr, State, Data> + {}; + + /// Either call the PolymorphicFunctionObject \c Fun with 0 arguments; or + /// invoke the PrimitiveTransform \c Fun with 3 arguments: the current + /// expression, state, and data. + /// + /// If \c Fun is a nullary PolymorphicFunctionObject, return <tt>Fun()()</tt>. + /// Otherwise, return <tt>Fun()(e, s, d)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + + /// If \c Fun is a nullary PolymorphicFunctionObject, \c type is a typedef + /// for <tt>boost::result_of\<Fun()\>::type</tt>. Otherwise, it is + /// a typedef for <tt>boost::result_of\<Fun(Expr, State, Data)\>::type</tt>. + template<typename Expr, typename State, typename Data> + struct impl + : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> + {}; + }; + + /// \brief Either call the PolymorphicFunctionObject with 1 + /// argument, or invoke the PrimitiveTransform with 3 + /// arguments. + template<typename Fun, typename A0> + struct call<Fun(A0)> : transform<call<Fun(A0)> > + { + template<typename Expr, typename State, typename Data, bool B> + struct impl2 + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename detail::poly_function_traits<Fun, Fun(a0)>::result_type result_type; + + BOOST_FORCEINLINE + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename detail::poly_function_traits<Fun, Fun(a0)>::function_type()( + detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) + ); + } + }; + + template<typename Expr, typename State, typename Data> + struct impl2<Expr, State, Data, true> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename Fun::template impl<a0, State, Data>::result_type result_type; + + BOOST_FORCEINLINE + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename Fun::template impl<a0, State, Data>()( + typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) + , s + , d + ); + } + }; + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt> and \c X + /// be the type of \c x. + /// If \c Fun is a unary PolymorphicFunctionObject that accepts \c x, + /// then \c type is a typedef for <tt>boost::result_of\<Fun(X)\>::type</tt>. + /// Otherwise, it is a typedef for <tt>boost::result_of\<Fun(X, State, Data)\>::type</tt>. + + /// Either call the PolymorphicFunctionObject with 1 argument: + /// the result of applying the \c A0 transform; or + /// invoke the PrimitiveTransform with 3 arguments: + /// result of applying the \c A0 transform, the state, and the + /// data. + /// + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. + /// If \c Fun is a unary PolymorphicFunctionObject that accepts \c x, + /// then return <tt>Fun()(x)</tt>. Otherwise, return + /// <tt>Fun()(x, s, d)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + template<typename Expr, typename State, typename Data> + struct impl + : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> + {}; + }; + + /// \brief Either call the PolymorphicFunctionObject with 2 + /// arguments, or invoke the PrimitiveTransform with 3 + /// arguments. + template<typename Fun, typename A0, typename A1> + struct call<Fun(A0, A1)> : transform<call<Fun(A0, A1)> > + { + template<typename Expr, typename State, typename Data, bool B> + struct impl2 + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; + typedef typename detail::poly_function_traits<Fun, Fun(a0, a1)>::result_type result_type; + + BOOST_FORCEINLINE + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename detail::poly_function_traits<Fun, Fun(a0, a1)>::function_type()( + detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) + , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d)) + ); + } + }; + + template<typename Expr, typename State, typename Data> + struct impl2<Expr, State, Data, true> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; + typedef typename Fun::template impl<a0, a1, Data>::result_type result_type; + + BOOST_FORCEINLINE + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename Fun::template impl<a0, a1, Data>()( + typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) + , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) + , d + ); + } + }; + + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt> and \c X + /// be the type of \c x. + /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt> and \c Y + /// be the type of \c y. + /// If \c Fun is a binary PolymorphicFunction object that accepts \c x + /// and \c y, then \c type is a typedef for + /// <tt>boost::result_of\<Fun(X, Y)\>::type</tt>. Otherwise, it is + /// a typedef for <tt>boost::result_of\<Fun(X, Y, Data)\>::type</tt>. + + /// Either call the PolymorphicFunctionObject with 2 arguments: + /// the result of applying the \c A0 transform, and the + /// result of applying the \c A1 transform; or invoke the + /// PrimitiveTransform with 3 arguments: the result of applying + /// the \c A0 transform, the result of applying the \c A1 + /// transform, and the data. + /// + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. + /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt>. + /// If \c Fun is a binary PolymorphicFunction object that accepts \c x + /// and \c y, return <tt>Fun()(x, y)</tt>. Otherwise, return + /// <tt>Fun()(x, y, d)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + template<typename Expr, typename State, typename Data> + struct impl + : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> + {}; + }; + + /// \brief Call the PolymorphicFunctionObject or the + /// PrimitiveTransform with the current expression, state + /// and data, transformed according to \c A0, \c A1, and + /// \c A2, respectively. + template<typename Fun, typename A0, typename A1, typename A2> + struct call<Fun(A0, A1, A2)> : transform<call<Fun(A0, A1, A2)> > + { + template<typename Expr, typename State, typename Data, bool B> + struct impl2 + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; + typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2; + typedef typename detail::poly_function_traits<Fun, Fun(a0, a1, a2)>::result_type result_type; + + BOOST_FORCEINLINE + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename detail::poly_function_traits<Fun, Fun(a0, a1, a2)>::function_type()( + detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)) + , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d)) + , detail::as_lvalue(typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d)) + ); + } + }; + + template<typename Expr, typename State, typename Data> + struct impl2<Expr, State, Data, true> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0; + typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1; + typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2; + typedef typename Fun::template impl<a0, a1, a2>::result_type result_type; + + BOOST_FORCEINLINE + result_type operator ()( + typename impl2::expr_param e + , typename impl2::state_param s + , typename impl2::data_param d + ) const + { + return typename Fun::template impl<a0, a1, a2>()( + typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) + , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) + , typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) + ); + } + }; + + /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. + /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt>. + /// Let \c z be <tt>when\<_, A2\>()(e, s, d)</tt>. + /// Return <tt>Fun()(x, y, z)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + + template<typename Expr, typename State, typename Data> + struct impl + : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> + {}; + }; + + #include <boost/proto/transform/detail/call.hpp> + + /// INTERNAL ONLY + /// + template<typename Fun> + struct is_callable<call<Fun> > + : mpl::true_ + {}; + +}} // namespace boost::proto + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/default.hpp b/3rdParty/Boost/src/boost/proto/transform/default.hpp new file mode 100644 index 0000000..cac2d6e --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/default.hpp @@ -0,0 +1,598 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file default.hpp +/// Contains definition of the _default transform, which gives operators their +/// usual C++ meanings and uses Boost.Typeof to deduce return types. +// +// 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_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008 +#define BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008 + +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/arithmetic/add.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_shifted.hpp> +#include <boost/preprocessor/repetition/enum_shifted_params.hpp> +#include <boost/ref.hpp> +#include <boost/get_pointer.hpp> +#include <boost/utility/enable_if.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/traits.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/proto/transform/arg.hpp> +#include <boost/proto/detail/decltype.hpp> + +namespace boost { namespace proto +{ + namespace detail + { + template<typename Grammar, typename Tag> + struct default_case + : not_<_> + {}; + + template<typename Grammar> + struct default_case<Grammar, tag::terminal> + : when<terminal<_>, _value> + {}; + + template<typename Grammar> + struct default_cases + { + template<typename Tag> + struct case_ + : default_case<Grammar, Tag> + {}; + }; + + #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \ + template<typename Grammar> \ + struct BOOST_PP_CAT(default_, TAG) \ + : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \ + { \ + template<typename Expr, typename State, typename Data> \ + struct impl \ + : transform_impl<Expr, State, Data> \ + { \ + private: \ + typedef typename result_of::child_c<Expr, 0>::type e0; \ + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \ + public: \ + BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \ + result_type operator ()( \ + typename impl::expr_param e \ + , typename impl::state_param s \ + , typename impl::data_param d \ + ) const \ + { \ + typename Grammar::template impl<e0, State, Data> t0; \ + return OP t0(proto::child_c<0>(e), s, d); \ + } \ + }; \ + }; \ + \ + template<typename Grammar> \ + struct default_case<Grammar, tag::TAG> \ + : when<unary_expr<tag::TAG, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \ + {}; \ + /**/ + + #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \ + template<typename Grammar> \ + struct BOOST_PP_CAT(default_, TAG) \ + : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \ + { \ + template<typename Expr, typename State, typename Data> \ + struct impl \ + : transform_impl<Expr, State, Data> \ + { \ + private: \ + typedef typename result_of::child_c<Expr, 0>::type e0; \ + typedef typename result_of::child_c<Expr, 1>::type e1; \ + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \ + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; \ + public: \ + BOOST_PROTO_DECLTYPE_( \ + proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \ + , result_type \ + ) \ + result_type operator ()( \ + typename impl::expr_param e \ + , typename impl::state_param s \ + , typename impl::data_param d \ + ) const \ + { \ + typename Grammar::template impl<e0, State, Data> t0; \ + typename Grammar::template impl<e1, State, Data> t1; \ + return t0(proto::child_c<0>(e), s, d) \ + OP t1(proto::child_c<1>(e), s, d); \ + } \ + }; \ + }; \ + \ + template<typename Grammar> \ + struct default_case<Grammar, tag::TAG> \ + : when<binary_expr<tag::TAG, Grammar, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \ + {}; \ + /**/ + + BOOST_PROTO_UNARY_DEFAULT_EVAL(+, unary_plus, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(-, negate, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(*, dereference, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(~, complement, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(&, address_of, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(!, logical_not, make) + BOOST_PROTO_UNARY_DEFAULT_EVAL(++, pre_inc, make_mutable) + BOOST_PROTO_UNARY_DEFAULT_EVAL(--, pre_dec, make_mutable) + + BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, shift_left, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, shift_right, make_mutable, make_mutable) + BOOST_PROTO_BINARY_DEFAULT_EVAL(*, multiplies, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(/, divides, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(%, modulus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(+, plus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(-, minus, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<, less, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>, greater, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, less_equal, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, greater_equal, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(==, equal_to, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, not_equal_to, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(||, logical_or, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, logical_and, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&, bitwise_and, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(|, bitwise_or, make, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(^, bitwise_xor, make, make) + + BOOST_PROTO_BINARY_DEFAULT_EVAL(=, assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, shift_left_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, shift_right_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, multiplies_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, divides_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, modulus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, plus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, minus_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, bitwise_and_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, bitwise_or_assign, make_mutable, make) + BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, bitwise_xor_assign, make_mutable, make) + + #undef BOOST_PROTO_UNARY_DEFAULT_EVAL + #undef BOOST_PROTO_BINARY_DEFAULT_EVAL + + /// INTERNAL ONLY + template<typename Grammar, typename Expr, typename State, typename Data> + struct is_member_function_invocation + : is_member_function_pointer< + typename uncvref< + typename Grammar::template impl< + typename result_of::child_c<Expr, 1>::type + , State + , Data + >::result_type + >::type + > + {}; + + /// INTERNAL ONLY + template<typename Grammar, typename Expr, typename State, typename Data, bool IsMemFunCall> + struct default_mem_ptr_impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + public: + typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type; + result_type operator ()( + typename default_mem_ptr_impl::expr_param e + , typename default_mem_ptr_impl::state_param s + , typename default_mem_ptr_impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + return detail::mem_ptr_fun<r0, r1>()( + t0(proto::child_c<0>(e), s, d) + , t1(proto::child_c<1>(e), s, d) + ); + } + }; + + /// INTERNAL ONLY + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_mem_ptr_impl<Grammar, Expr, State, Data, true> + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + public: + typedef detail::memfun<r0, r1> result_type; + result_type const operator ()( + typename default_mem_ptr_impl::expr_param e + , typename default_mem_ptr_impl::state_param s + , typename default_mem_ptr_impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + return detail::memfun<r0, r1>( + t0(proto::child_c<0>(e), s, d) + , t1(proto::child_c<1>(e), s, d) + ); + } + }; + + template<typename Grammar> + struct default_mem_ptr + : transform<default_mem_ptr<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : default_mem_ptr_impl< + Grammar + , Expr + , State + , Data + , is_member_function_invocation<Grammar, Expr, State, Data>::value + > + {}; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::mem_ptr> + : when<mem_ptr<Grammar, Grammar>, default_mem_ptr<Grammar> > + {}; + + template<typename Grammar> + struct default_post_inc + : transform<default_post_inc<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + public: + BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type) + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + return t0(proto::child_c<0>(e), s, d) ++; + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::post_inc> + : when<post_inc<Grammar>, default_post_inc<Grammar> > + {}; + + template<typename Grammar> + struct default_post_dec + : transform<default_post_dec<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + public: + BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type) + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + return t0(proto::child_c<0>(e), s, d) --; + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::post_dec> + : when<post_dec<Grammar>, default_post_dec<Grammar> > + {}; + + template<typename Grammar> + struct default_subscript + : transform<default_subscript<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + public: + BOOST_PROTO_DECLTYPE_( + proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ] + , result_type + ) + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + return t0(proto::child_c<0>(e), s, d) [ + t1(proto::child_c<1>(e), s, d) ]; + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::subscript> + : when<subscript<Grammar, Grammar>, default_subscript<Grammar> > + {}; + + template<typename Grammar> + struct default_if_else_ + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename result_of::child_c<Expr, 2>::type e2; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + typedef typename Grammar::template impl<e2, State, Data>::result_type r2; + public: + BOOST_PROTO_DECLTYPE_( + proto::detail::make<r0>() + ? proto::detail::make<r1>() + : proto::detail::make<r2>() + , result_type + ) + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + typename Grammar::template impl<e2, State, Data> t2; + return t0(proto::child_c<0>(e), s, d) + ? t1(proto::child_c<1>(e), s, d) + : t2(proto::child_c<2>(e), s, d); + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::if_else_> + : when<if_else_<Grammar, Grammar, Grammar>, default_if_else_<Grammar> > + {}; + + template<typename Grammar> + struct default_comma + : transform<default_comma<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + private: + typedef typename result_of::child_c<Expr, 0>::type e0; + typedef typename result_of::child_c<Expr, 1>::type e1; + typedef typename Grammar::template impl<e0, State, Data>::result_type r0; + typedef typename Grammar::template impl<e1, State, Data>::result_type r1; + public: + typedef typename proto::detail::comma_result<r0, r1>::type result_type; + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename Grammar::template impl<e0, State, Data> t0; + typename Grammar::template impl<e1, State, Data> t1; + return t0(proto::child_c<0>(e), s, d) + , t1(proto::child_c<1>(e), s, d); + } + }; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::comma> + : when<comma<Grammar, Grammar>, default_comma<Grammar> > + {}; + + template<typename Grammar, typename Expr, typename State, typename Data, long Arity> + struct default_function_impl; + + template<typename Grammar> + struct default_function + : transform<default_function<Grammar> > + { + template<typename Expr, typename State, typename Data> + struct impl + : default_function_impl< + Grammar + , Expr + , State + , Data + , transform_impl<Expr, State, Data>::expr::proto_arity_c + > + {}; + }; + + template<typename Grammar> + struct default_case<Grammar, tag::function> + : when<function<Grammar, vararg<Grammar> >, default_function<Grammar> > + {}; + + #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \ + typedef \ + typename result_of::child_c<DATA, N>::type \ + BOOST_PP_CAT(e, N); \ + \ + typedef \ + typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>::result_type \ + BOOST_PP_CAT(r, N); \ + /**/ + + #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \ + typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>()( \ + proto::child_c<N>(DATA), s, d \ + ) \ + /**/ + + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 1> + : transform_impl<Expr, State, Data> + { + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) + + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + + typedef + typename BOOST_PROTO_RESULT_OF<function_type()>::type + result_type; + + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(); + } + }; + + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 2> + : transform_impl<Expr, State, Data> + { + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr) + BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr) + + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + + typedef + typename detail::result_of_<function_type(r1)>::type + result_type; + + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke( + e + , s + , d + , is_member_function_pointer<function_type>() + , is_member_object_pointer<function_type>() + ); + } + + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + , mpl::false_ + ) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(BOOST_PROTO_DEFAULT_EVAL(~, 1, e)); + } + + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, e))) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, e) + )(); + } + + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, e))) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, e) + ); + } + }; + + #include <boost/proto/transform/detail/default_function_impl.hpp> + + #undef BOOST_PROTO_DEFAULT_EVAL_TYPE + #undef BOOST_PROTO_DEFAULT_EVAL + } + + template<typename Grammar /*= detail::_default*/> + struct _default + : switch_<detail::default_cases<Grammar> > + {}; + + template<typename Grammar> + struct is_callable<_default<Grammar> > + : mpl::true_ + {}; + + namespace detail + { + // Loopy indirection that allows proto::_default<> to be + // used without specifying a Grammar argument. + struct _default + : proto::_default<> + {}; + } + +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/call.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/call.hpp new file mode 100644 index 0000000..629f4de --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/call.hpp @@ -0,0 +1,110 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/call.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_NTH_RESULT_TYPE(Z, M, DATA) \ + typedef \ + typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data> \ + BOOST_PP_CAT(a, M); \ + typedef typename BOOST_PP_CAT(a, M)::result_type BOOST_PP_CAT(b, M); \ + /**/ + + #define BOOST_PROTO_NTH_RESULT(Z, M, DATA) \ + detail::as_lvalue(BOOST_PP_CAT(a, M)()(e, s, d)) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/call.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file call.hpp + /// Contains definition of the call<> transform. + // + // 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/transform/detail/call.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_NTH_RESULT + #undef BOOST_PROTO_NTH_RESULT_TYPE + +#else + + #define N BOOST_PP_ITERATION() + + #if N > 3 + /// \brief Call the PolymorphicFunctionObject \c Fun with the + /// current expression, state and data, transformed according + /// to \c A0 through \c AN. + template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct call<Fun(BOOST_PP_ENUM_PARAMS(N, A))> : transform<call<Fun(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + BOOST_PP_REPEAT(N, BOOST_PROTO_NTH_RESULT_TYPE, ~) + + typedef detail::poly_function_traits<Fun, Fun(BOOST_PP_ENUM_PARAMS(N, b))> function_traits; + typedef typename function_traits::result_type result_type; + + /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt> + /// for each \c x in <tt>[0,N]</tt>. + /// Return <tt>Fun()(a0, a1,... aN)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(BOOST_PP_ENUM(N, BOOST_PROTO_NTH_RESULT, ~)); + } + }; + }; + #endif + + #if N > 0 + /// \brief Call the PolymorphicFunctionObject \c Fun with the + /// current expression, state and data, transformed according + /// to \c A0 through \c AN. + template<typename Fun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct call<Fun(BOOST_PP_ENUM_PARAMS(N, A)...)> : transform<call<Fun(BOOST_PP_ENUM_PARAMS(N, A)...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value // BUGBUG this isn't right. Could be pack(_child), should use arity of child! + , BOOST_PP_CAT(A, BOOST_PP_DEC(N)) + , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))< + Fun + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A) + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + #endif + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/construct_funop.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/construct_funop.hpp new file mode 100644 index 0000000..661fbf8 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/construct_funop.hpp @@ -0,0 +1,44 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/construct_funop.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/construct_funop.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file construct_funop.hpp + /// Overloads of construct_\<\>::operator(). + // + // 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/transform/detail/construct_funop.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + #define N BOOST_PP_ITERATION() + + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + BOOST_FORCEINLINE + Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) const + { + return Type(BOOST_PP_ENUM_PARAMS(N, a)); + } + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/construct_pod_funop.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/construct_pod_funop.hpp new file mode 100644 index 0000000..667c987 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/construct_pod_funop.hpp @@ -0,0 +1,45 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/construct_pod_funop.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file construct_pod_funop.hpp + /// Overloads of construct_\<\>::operator(). + // + // 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/transform/detail/construct_pod_funop.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + #define N BOOST_PP_ITERATION() + + template<BOOST_PP_ENUM_PARAMS(N, typename A)> + BOOST_FORCEINLINE + Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) const + { + Type that = {BOOST_PP_ENUM_PARAMS(N, a)}; + return that; + } + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/default_function_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/default_function_impl.hpp new file mode 100644 index 0000000..a8f421c --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/default_function_impl.hpp @@ -0,0 +1,97 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/default_function_impl.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_DEF_FUN_INVOKE_ARG(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_function_impl.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file default_function_impl.hpp + /// Contains definition of the default_function_impl, the implementation of the + /// _default transform for function-like nodes. + // + // 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/transform/detail/default_function_impl.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_DEF_FUN_INVOKE_ARG + +#else + + #define N BOOST_PP_ITERATION() + + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, N> + : transform_impl<Expr, State, Data> + { + BOOST_PP_REPEAT(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr) + + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, r)) + >::type + result_type; + + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)( + BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, e) + ); + } + + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, e))) ->* + BOOST_PROTO_DEFAULT_EVAL(~, 0, e) + )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), BOOST_PROTO_DEF_FUN_INVOKE_ARG, e)); + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/expand_pack.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/expand_pack.hpp new file mode 100644 index 0000000..c87e380 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/expand_pack.hpp @@ -0,0 +1,46 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/expand_pack.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expand_pack.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file expand_pack.hpp + /// Contains helpers for pseudo-pack expansion. + // + // Copyright 2012 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, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/expand_pack.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + #define N BOOST_PP_ITERATION() + #define M0(Z, X, DATA) typename expand_pattern_helper<Tfx, BOOST_PP_CAT(A, X)>::type + #define M1(Z, X, DATA) expand_pattern_helper<Tfx, BOOST_PP_CAT(A, X)>::applied::value || + + template<typename Tfx, typename Ret BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct expand_pattern_helper<Tfx, Ret(BOOST_PP_ENUM_PARAMS(N, A))> + { + typedef Ret (*type)(BOOST_PP_ENUM(N, M0, ~)); + typedef mpl::bool_<BOOST_PP_REPEAT(N, M1, ~) false> applied; + }; + + #undef M1 + #undef M0 + #undef N +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/fold_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/fold_impl.hpp new file mode 100644 index 0000000..d469fff --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/fold_impl.hpp @@ -0,0 +1,143 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/fold_impl.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_CHILD_N_TYPE(N) \ + BOOST_PP_CAT(proto_child, N) \ + /**/ + + #define BOOST_PROTO_FOLD_STATE_TYPE(Z, N, DATA) \ + typedef \ + typename when<_, Fun>::template impl< \ + typename result_of::child_c<Expr, N>::type \ + , BOOST_PP_CAT(state, N) \ + , Data \ + >::result_type \ + BOOST_PP_CAT(state, BOOST_PP_INC(N)); \ + /**/ + + #define BOOST_PROTO_FOLD_STATE(Z, N, DATA) \ + BOOST_PP_CAT(state, BOOST_PP_INC(N)) \ + BOOST_PP_CAT(s, BOOST_PP_INC(N)) \ + = typename when<_, Fun>::template impl< \ + typename result_of::child_c<Expr, N>::type \ + , BOOST_PP_CAT(state, N) \ + , Data \ + >()( \ + proto::child_c<N>(e) \ + , BOOST_PP_CAT(s, N) \ + , d \ + ); \ + /**/ + + #define BOOST_PROTO_REVERSE_FOLD_STATE_TYPE(Z, N, DATA) \ + typedef \ + typename when<_, Fun>::template impl< \ + typename result_of::child_c< \ + Expr \ + , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \ + >::type \ + , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \ + , Data \ + >::result_type \ + BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))); \ + /**/ + + #define BOOST_PROTO_REVERSE_FOLD_STATE(Z, N, DATA) \ + BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \ + BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \ + = typename when<_, Fun>::template impl< \ + typename result_of::child_c< \ + Expr \ + , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \ + >::type \ + , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \ + , Data \ + >()( \ + proto::child_c<BOOST_PP_SUB(DATA, BOOST_PP_INC(N))>(e) \ + , BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, N)) \ + , d \ + ); \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/fold_impl.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file fold_impl.hpp + /// Contains definition of fold_impl<> and reverse_fold_impl<> templates. + // + // 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/transform/detail/fold_impl.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_REVERSE_FOLD_STATE + #undef BOOST_PROTO_REVERSE_FOLD_STATE_TYPE + #undef BOOST_PROTO_FOLD_STATE + #undef BOOST_PROTO_FOLD_STATE_TYPE + #undef BOOST_PROTO_CHILD_N_TYPE + +#else + + #define N BOOST_PP_ITERATION() + + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, N> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE_TYPE, N) + typedef BOOST_PP_CAT(state, N) result_type; + + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE, N) + return BOOST_PP_CAT(s, N); + } + }; + + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, N> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type BOOST_PP_CAT(state, N); + BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE_TYPE, N) + typedef state0 result_type; + + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + BOOST_PP_CAT(state, N) BOOST_PP_CAT(s, N) = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE, N) + return s0; + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/lazy.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/lazy.hpp new file mode 100644 index 0000000..fbd1365 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/lazy.hpp @@ -0,0 +1,79 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/lazy.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/lazy.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file lazy.hpp + /// Contains definition of the lazy<> transform. + // + // 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, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/lazy.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + #define N BOOST_PP_ITERATION() + + /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build + /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it. + /// + /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the + /// transform to be applied depends on the current state of the + /// transformation. The invocation of the <tt>make\<\></tt> transform + /// evaluates any nested transforms, and the resulting type is treated + /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>. + template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (BOOST_PP_ENUM_PARAMS(N, A)) + >::template impl<Expr, State, Data> + {}; + }; + + #if N > 0 + template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> + : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , BOOST_PP_CAT(A, BOOST_PP_DEC(N)) + , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))< + Object + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A) + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + #endif + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/make.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/make.hpp new file mode 100644 index 0000000..31a89cc --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/make.hpp @@ -0,0 +1,202 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/make.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_MAKE_IF(Z, M, DATA) \ + make_if_<BOOST_PP_CAT(A, M), Expr, State, Data> \ + /**/ + + #define BOOST_PROTO_MAKE_IF_TYPE(Z, M, DATA) \ + typename BOOST_PROTO_MAKE_IF(Z, M, DATA) ::type \ + /**/ + + #define BOOST_PROTO_MAKE_IF_APPLIED(Z, M, DATA) \ + BOOST_PROTO_MAKE_IF(Z, M, DATA) ::applied || \ + /**/ + + #define BOOST_PROTO_CONSTRUCT_ARG(Z, M, DATA) \ + detail::as_lvalue( \ + typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data>()(e, s, d) \ + ) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file make.hpp + /// Contains definition of the make<> transform. + // + // 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, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/make.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_CONSTRUCT_ARG + #undef BOOST_PROTO_MAKE_IF_APPLIED + #undef BOOST_PROTO_MAKE_IF_TYPE + #undef BOOST_PROTO_MAKE_IF + +#else + + #define N BOOST_PP_ITERATION() + + namespace detail + { + #if N > 0 + + template< + template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R + BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A) + , typename Expr, typename State, typename Data + > + struct make_< + R<BOOST_PP_ENUM_PARAMS(N, A)> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(N) + > + : nested_type_if< + R<BOOST_PP_ENUM(N, BOOST_PROTO_MAKE_IF_TYPE, ~)> + , (BOOST_PP_REPEAT(N, BOOST_PROTO_MAKE_IF_APPLIED, ~) false) + > + {}; + + template< + template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R + BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A) + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<BOOST_PP_ENUM_PARAMS(N, A)> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<BOOST_PP_ENUM(N, BOOST_PROTO_MAKE_IF_TYPE, ~)> type; + static bool const applied = true; + }; + + #endif + + template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct is_applyable<R(BOOST_PP_ENUM_PARAMS(N, A))> + : mpl::true_ + {}; + + template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct is_applyable<R(*)(BOOST_PP_ENUM_PARAMS(N, A))> + : mpl::true_ + {}; + + template<typename T, typename A> + struct construct_<proto::expr<T, A, N>, true> + { + typedef proto::expr<T, A, N> result_type; + + template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)> + BOOST_FORCEINLINE + result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const + { + return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a)); + } + }; + + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, N>, true> + { + typedef proto::basic_expr<T, A, N> result_type; + + template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)> + BOOST_FORCEINLINE + result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const + { + return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a)); + } + }; + + template<typename Type BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + BOOST_FORCEINLINE + Type construct(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) + { + return construct_<Type>()(BOOST_PP_ENUM_PARAMS(N, a)); + } + + } // namespace detail + + /// \brief A PrimitiveTransform which computes a type by evaluating any + /// nested transforms and then constructs an object of that type with the + /// current expression, state and data, transformed according + /// to \c A0 through \c AN. + template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make<Object(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<make<Object(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + /// \brief <tt>boost::result_of\<make\<Object\>(Expr, State, Data)\>::type</tt> + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt> + /// for each \c x in <tt>[0,N]</tt>. + /// Return <tt>result_type(a0, a1,... aN)</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(BOOST_PP_ENUM(N, BOOST_PROTO_CONSTRUCT_ARG, DATA)); + } + }; + }; + + #if N > 0 + /// \brief A PrimitiveTransform which computes a type by evaluating any + /// nested transforms and then constructs an object of that type with the + /// current expression, state and data, transformed according + /// to \c A0 through \c AN. + template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> + : transform<make<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , BOOST_PP_CAT(A, BOOST_PP_DEC(N)) + , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))< + Object + BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A) + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + #endif + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/make_gcc_workaround.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/make_gcc_workaround.hpp new file mode 100644 index 0000000..b3b7dea --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/make_gcc_workaround.hpp @@ -0,0 +1,100 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) + #include <boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp> + #endif + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_EXPR_MAKE_ARG(Z, M, DATA) \ + detail::as_lvalue( \ + typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data>()(e, s, d) \ + ) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_gcc_workaround.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file make_gcc_workaround.hpp + /// Special workaround code to make the make\<\> transform work on certain + /// versions of gcc. + // + // 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 + + #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) || \ + (defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)) + + #define BOOST_PP_ITERATION_PARAMS_1 \ + (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/make_gcc_workaround.hpp>)) + #include BOOST_PP_ITERATE() + + #endif + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_EXPR_MAKE_ARG + +#else + + #define N BOOST_PP_ITERATION() + + // work around GCC bug + template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + BOOST_PP_ENUM(N, BOOST_PROTO_EXPR_MAKE_ARG, DATA) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> + : transform<make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + BOOST_PP_ENUM(N, BOOST_PROTO_EXPR_MAKE_ARG, DATA) + ); + } + }; + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/pack.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/pack.hpp new file mode 100644 index 0000000..863e7a0 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/pack.hpp @@ -0,0 +1,97 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file pack.hpp +/// Contains helpers for pseudo-pack expansion. +// +// Copyright 2012 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_TRANSFORM_DETAIL_PACK_HPP_EAN_2012_07_11 +#define BOOST_PROTO_TRANSFORM_DETAIL_PACK_HPP_EAN_2012_07_11 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/punctuation/comma_if.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/iteration/local.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/proto/proto_fwd.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable: 4348) // redefinition of default parameter +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template<typename Fun> + struct msvc_fun_workaround; + + template<typename Tfx, typename T> + struct expand_pattern_helper + { + typedef T type; + typedef mpl::false_ applied; + }; + + template<typename Tfx, typename Fun> + struct expand_pattern_helper<Tfx, Fun *> + : expand_pattern_helper<Tfx, Fun> + {}; + + template<typename Tfx, typename T> + struct expand_pattern_helper<Tfx, pack(T)> + { + // BUGBUG fix me. See comment in transform/detail/call.hpp + BOOST_MPL_ASSERT_MSG( + (is_same<T, _>::value) + , PACK_EXPANSIONS_OF_EXPRESSIONS_OTHER_THAN_THE_CURRENT_NOT_YET_SUPPORTED + , (T) + ); + typedef Tfx type(T); + typedef mpl::true_ applied; + }; + + template<typename Tfx> + struct expand_pattern_helper<Tfx, pack(_)> + { + typedef Tfx type; + typedef mpl::true_ applied; + }; + + #include <boost/proto/transform/detail/expand_pack.hpp> + + template<long Arity, typename Fun, typename Cont> + struct expand_pattern; + + template<typename Fun, typename Cont> + struct expand_pattern<0, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_value, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_value, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION + , (Fun) + ); + }; + + #include <boost/proto/transform/detail/pack_impl.hpp> + } +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/pack_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/pack_impl.hpp new file mode 100644 index 0000000..d5f10af --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/pack_impl.hpp @@ -0,0 +1,72 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/pack_impl.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/pack_impl.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file pack_impl.hpp + /// Contains helpers for pseudo-pack expansion. + // + // Copyright 2012 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, (0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY), <boost/proto/transform/detail/pack_impl.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + #if BOOST_PP_ITERATION_DEPTH() == 1 + #define N BOOST_PP_ITERATION() + #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N) + #define M0(Z, X, D) typename expand_pattern_helper<proto::_child_c<X>, Fun>::type + + template<typename Fun, typename Cont> + struct expand_pattern<BOOST_PP_INC(N), Fun, Cont> + : Cont::template cat<BOOST_PP_ENUM(BOOST_PP_INC(N), M0, ~)> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + + template<typename Ret BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct BOOST_PP_CAT(expand_pattern_rest_, N) + { + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(M), typename C, void)> + struct cat; + + #define BOOST_PP_ITERATION_PARAMS_2 \ + (3, (1, M, <boost/proto/transform/detail/pack_impl.hpp>)) + #include BOOST_PP_ITERATE() + }; + #undef M0 + #undef M + #undef N + #else + #define I BOOST_PP_ITERATION() + #define J BOOST_PP_RELATIVE_ITERATION(1) + template<BOOST_PP_ENUM_PARAMS(I, typename C)> + struct cat<BOOST_PP_ENUM_PARAMS(I, C)> + { + typedef msvc_fun_workaround<Ret(BOOST_PP_ENUM_PARAMS(J, A) BOOST_PP_COMMA_IF(J) BOOST_PP_ENUM_PARAMS(I, C))> type; + }; + #undef J + #undef I + #endif +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/pass_through_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/pass_through_impl.hpp new file mode 100644 index 0000000..03ac568 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/pass_through_impl.hpp @@ -0,0 +1,104 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/pass_through_impl.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #define BOOST_PROTO_DEFINE_TRANSFORM_TYPE(Z, N, DATA) \ + typename Grammar::BOOST_PP_CAT(proto_child, N)::template impl< \ + typename result_of::child_c<Expr, N>::type \ + , State \ + , Data \ + >::result_type \ + /**/ + + #define BOOST_PROTO_DEFINE_TRANSFORM(Z, N, DATA) \ + typename Grammar::BOOST_PP_CAT(proto_child, N)::template impl< \ + typename result_of::child_c<Expr, N>::type \ + , State \ + , Data \ + >()( \ + e.proto_base().BOOST_PP_CAT(child, N), s, d \ + ) \ + /**/ + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/pass_through_impl.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file pass_through_impl.hpp + /// + /// Specializations of pass_through_impl, used in the implementation of the + /// pass_through transform. + // + // 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/transform/detail/pass_through_impl.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + + #undef BOOST_PROTO_DEFINE_TRANSFORM + #undef BOOST_PROTO_DEFINE_TRANSFORM_TYPE + +#else + + #define N BOOST_PP_ITERATION() + + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, N> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , BOOST_PP_CAT(list, N)< + BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_TRANSFORM_TYPE, ~) + > + >::type + expr_type; + + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_TRANSFORM, ~) + }; + // Without this, MSVC complains that "that" is uninitialized, + // and it actually triggers a runtime check in debug mode when + // built with VC8. + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/call.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/call.hpp new file mode 100644 index 0000000..54575cc --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/call.hpp @@ -0,0 +1,424 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file call.hpp + /// Contains definition of the call<> transform. + // + // 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 Fun , typename A0> + struct call<Fun(A0...)> : transform<call<Fun(A0...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A0 + , detail::expand_pattern_rest_0< + Fun + + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1> + struct call<Fun(A0 , A1...)> : transform<call<Fun(A0 , A1...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A1 + , detail::expand_pattern_rest_1< + Fun + , A0 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2> + struct call<Fun(A0 , A1 , A2...)> : transform<call<Fun(A0 , A1 , A2...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A2 + , detail::expand_pattern_rest_2< + Fun + , A0 , A1 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3> + struct call<Fun(A0 , A1 , A2 , A3)> : transform<call<Fun(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3> + struct call<Fun(A0 , A1 , A2 , A3...)> : transform<call<Fun(A0 , A1 , A2 , A3...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A3 + , detail::expand_pattern_rest_3< + Fun + , A0 , A1 , A2 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct call<Fun(A0 , A1 , A2 , A3 , A4)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct call<Fun(A0 , A1 , A2 , A3 , A4...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A4 + , detail::expand_pattern_rest_4< + Fun + , A0 , A1 , A2 , A3 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A5 + , detail::expand_pattern_rest_5< + Fun + , A0 , A1 , A2 , A3 , A4 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A6 + , detail::expand_pattern_rest_6< + Fun + , A0 , A1 , A2 , A3 , A4 , A5 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A7 + , detail::expand_pattern_rest_7< + Fun + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A8 + , detail::expand_pattern_rest_8< + Fun + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; typedef typename when<_, A9>::template impl<Expr, State, Data> a9; typedef typename a9::result_type b9; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8 , b9)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)) , detail::as_lvalue(a9()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A9 + , detail::expand_pattern_rest_9< + Fun + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_funop.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_funop.hpp new file mode 100644 index 0000000..91ab92c --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_funop.hpp @@ -0,0 +1,67 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file construct_funop.hpp + /// Overloads of construct_\<\>::operator(). + // + // 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 A0> + BOOST_FORCEINLINE + Type operator ()(A0 &a0) const + { + return Type(a0); + } + template<typename A0 , typename A1> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1) const + { + return Type(a0 , a1); + } + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const + { + return Type(a0 , a1 , a2); + } + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const + { + return Type(a0 , a1 , a2 , a3); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const + { + return Type(a0 , a1 , a2 , a3 , a4); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp new file mode 100644 index 0000000..55b9df5 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp @@ -0,0 +1,77 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file construct_pod_funop.hpp + /// Overloads of construct_\<\>::operator(). + // + // 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 A0> + BOOST_FORCEINLINE + Type operator ()(A0 &a0) const + { + Type that = {a0}; + return that; + } + template<typename A0 , typename A1> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1) const + { + Type that = {a0 , a1}; + return that; + } + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const + { + Type that = {a0 , a1 , a2}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const + { + Type that = {a0 , a1 , a2 , a3}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const + { + Type that = {a0 , a1 , a2 , a3 , a4}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; + return that; + } diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/default_function_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/default_function_impl.hpp new file mode 100644 index 0000000..72ff60e --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/default_function_impl.hpp @@ -0,0 +1,392 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file default_function_impl.hpp + /// Contains definition of the default_function_impl, the implementation of the + /// _default transform for function-like nodes. + // + // 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 Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 3> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 4> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 5> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 6> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 7> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5 , r6) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 8> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 9> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 10> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; typedef typename result_of::child_c< Expr, 9>::type e9; typedef typename Grammar::template impl<e9, State, Data>::result_type r9; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8 , r9) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , 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, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d )); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/expand_pack.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/expand_pack.hpp new file mode 100644 index 0000000..8f758a3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/expand_pack.hpp @@ -0,0 +1,73 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file expand_pack.hpp + /// Contains helpers for pseudo-pack expansion. + // + // Copyright 2012 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 Tfx, typename Ret > + struct expand_pattern_helper<Tfx, Ret()> + { + typedef Ret (*type)(); + typedef mpl::bool_< false> applied; + }; + template<typename Tfx, typename Ret , typename A0> + struct expand_pattern_helper<Tfx, Ret(A0)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1> + struct expand_pattern_helper<Tfx, Ret(A0 , A1)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type , typename expand_pattern_helper<Tfx, A8>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || expand_pattern_helper<Tfx, A8>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type , typename expand_pattern_helper<Tfx, A8>::type , typename expand_pattern_helper<Tfx, A9>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || expand_pattern_helper<Tfx, A8>::applied::value || expand_pattern_helper<Tfx, A9>::applied::value || false> applied; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/fold_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/fold_impl.hpp new file mode 100644 index 0000000..f365166 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/fold_impl.hpp @@ -0,0 +1,387 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file fold_impl.hpp + /// Contains definition of fold_impl<> and reverse_fold_impl<> templates. + // + // 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 State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 1> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; + typedef state1 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); + return s1; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 1> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state1; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state1 s1 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 2> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; + typedef state2 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); + return s2; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 2> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state2; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state2 s2 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 3> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; + typedef state3 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); + return s3; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 3> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state3; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state3 s3 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 4> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; + typedef state4 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); + return s4; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 4> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state4; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state4 s4 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 5> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; + typedef state5 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); + return s5; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 5> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state5; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state5 s5 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 6> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; + typedef state6 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); + return s6; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 6> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state6; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state6 s6 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 7> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; + typedef state7 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); + return s7; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 7> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state7; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state7 s7 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 8> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; + typedef state8 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); + return s8; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 8> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state8; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state8 s8 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 9> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; + typedef state9 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); + return s9; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 9> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state9; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state9 s9 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 10> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >::result_type state10; + typedef state10 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); state10 s10 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >()( proto::child_c< 9>(e) , s9 , d ); + return s10; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 10> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state10; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state10 s10 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >()( proto::child_c<9>(e) , s10 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/lazy.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/lazy.hpp new file mode 100644 index 0000000..c32d20f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/lazy.hpp @@ -0,0 +1,407 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file lazy.hpp + /// Contains definition of the lazy<> transform. + // + // 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 Object > + struct lazy<Object()> + : transform<lazy<Object()> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + () + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0> + struct lazy<Object(A0)> + : transform<lazy<Object(A0)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0> + struct lazy<Object(A0...)> + : transform<lazy<Object(A0...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A0 + , detail::expand_pattern_rest_0< + Object + + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1> + struct lazy<Object(A0 , A1)> + : transform<lazy<Object(A0 , A1)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1> + struct lazy<Object(A0 , A1...)> + : transform<lazy<Object(A0 , A1...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A1 + , detail::expand_pattern_rest_1< + Object + , A0 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2> + struct lazy<Object(A0 , A1 , A2)> + : transform<lazy<Object(A0 , A1 , A2)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2> + struct lazy<Object(A0 , A1 , A2...)> + : transform<lazy<Object(A0 , A1 , A2...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A2 + , detail::expand_pattern_rest_2< + Object + , A0 , A1 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> + struct lazy<Object(A0 , A1 , A2 , A3)> + : transform<lazy<Object(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> + struct lazy<Object(A0 , A1 , A2 , A3...)> + : transform<lazy<Object(A0 , A1 , A2 , A3...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A3 + , detail::expand_pattern_rest_3< + Object + , A0 , A1 , A2 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct lazy<Object(A0 , A1 , A2 , A3 , A4)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct lazy<Object(A0 , A1 , A2 , A3 , A4...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A4 + , detail::expand_pattern_rest_4< + Object + , A0 , A1 , A2 , A3 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A5 + , detail::expand_pattern_rest_5< + Object + , A0 , A1 , A2 , A3 , A4 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5 , A6) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A6 + , detail::expand_pattern_rest_6< + Object + , A0 , A1 , A2 , A3 , A4 , A5 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A7 + , detail::expand_pattern_rest_7< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A8 + , detail::expand_pattern_rest_8< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A9 + , detail::expand_pattern_rest_9< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make.hpp new file mode 100644 index 0000000..e581127 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make.hpp @@ -0,0 +1,1320 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file make.hpp + /// Contains definition of the make<> transform. + // + // 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 R > + struct is_applyable<R()> + : mpl::true_ + {}; + template<typename R > + struct is_applyable<R(*)()> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 0>, true> + { + typedef proto::expr<T, A, 0> result_type; + template<typename A0> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0) const + { + return result_type::make(a0); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 0>, true> + { + typedef proto::basic_expr<T, A, 0> result_type; + template<typename A0> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0) const + { + return result_type::make(a0); + } + }; + template<typename Type > + BOOST_FORCEINLINE + Type construct() + { + return construct_<Type>()(); + } + } + + + + + template<typename Object > + struct make<Object()> + : transform<make<Object()> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(); + } + }; + }; + namespace detail + { + template< + template<typename> class R + , typename A0 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename> class R + , typename A0 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0> + struct is_applyable<R(A0)> + : mpl::true_ + {}; + template<typename R , typename A0> + struct is_applyable<R(*)(A0)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 1>, true> + { + typedef proto::expr<T, A, 1> result_type; + template<typename A0> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0) const + { + return result_type::make(a0); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 1>, true> + { + typedef proto::basic_expr<T, A, 1> result_type; + template<typename A0> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0) const + { + return result_type::make(a0); + } + }; + template<typename Type , typename A0> + BOOST_FORCEINLINE + Type construct(A0 &a0) + { + return construct_<Type>()(a0); + } + } + + + + + template<typename Object , typename A0> + struct make<Object(A0)> + : transform<make<Object(A0)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0> + struct make<Object(A0...)> + : transform<make<Object(A0...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A0 + , detail::expand_pattern_rest_0< + Object + + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename> class R + , typename A0 , typename A1 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(2) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename> class R + , typename A0 , typename A1 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1> + struct is_applyable<R(A0 , A1)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1> + struct is_applyable<R(*)(A0 , A1)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 2>, true> + { + typedef proto::expr<T, A, 2> result_type; + template<typename A0 , typename A1> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1) const + { + return result_type::make(a0 , a1); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 2>, true> + { + typedef proto::basic_expr<T, A, 2> result_type; + template<typename A0 , typename A1> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1) const + { + return result_type::make(a0 , a1); + } + }; + template<typename Type , typename A0 , typename A1> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1) + { + return construct_<Type>()(a0 , a1); + } + } + + + + + template<typename Object , typename A0 , typename A1> + struct make<Object(A0 , A1)> + : transform<make<Object(A0 , A1)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1> + struct make<Object(A0 , A1...)> + : transform<make<Object(A0 , A1...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A1 + , detail::expand_pattern_rest_1< + Object + , A0 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(3) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2> + struct is_applyable<R(A0 , A1 , A2)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2> + struct is_applyable<R(*)(A0 , A1 , A2)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 3>, true> + { + typedef proto::expr<T, A, 3> result_type; + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const + { + return result_type::make(a0 , a1 , a2); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 3>, true> + { + typedef proto::basic_expr<T, A, 3> result_type; + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const + { + return result_type::make(a0 , a1 , a2); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2) + { + return construct_<Type>()(a0 , a1 , a2); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2> + struct make<Object(A0 , A1 , A2)> + : transform<make<Object(A0 , A1 , A2)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2> + struct make<Object(A0 , A1 , A2...)> + : transform<make<Object(A0 , A1 , A2...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A2 + , detail::expand_pattern_rest_2< + Object + , A0 , A1 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(4) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3> + struct is_applyable<R(A0 , A1 , A2 , A3)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3> + struct is_applyable<R(*)(A0 , A1 , A2 , A3)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 4>, true> + { + typedef proto::expr<T, A, 4> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const + { + return result_type::make(a0 , a1 , a2 , a3); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 4>, true> + { + typedef proto::basic_expr<T, A, 4> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const + { + return result_type::make(a0 , a1 , a2 , a3); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) + { + return construct_<Type>()(a0 , a1 , a2 , a3); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> + struct make<Object(A0 , A1 , A2 , A3)> + : transform<make<Object(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> + struct make<Object(A0 , A1 , A2 , A3...)> + : transform<make<Object(A0 , A1 , A2 , A3...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A3 + , detail::expand_pattern_rest_3< + Object + , A0 , A1 , A2 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(5) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 5>, true> + { + typedef proto::expr<T, A, 5> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 5>, true> + { + typedef proto::basic_expr<T, A, 5> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make<Object(A0 , A1 , A2 , A3 , A4)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make<Object(A0 , A1 , A2 , A3 , A4...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A4 + , detail::expand_pattern_rest_4< + Object + , A0 , A1 , A2 , A3 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(6) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 6>, true> + { + typedef proto::expr<T, A, 6> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 6>, true> + { + typedef proto::basic_expr<T, A, 6> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A5 + , detail::expand_pattern_rest_5< + Object + , A0 , A1 , A2 , A3 , A4 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5 , A6> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(7) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 7>, true> + { + typedef proto::expr<T, A, 7> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 7>, true> + { + typedef proto::basic_expr<T, A, 7> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A6 + , detail::expand_pattern_rest_6< + Object + , A0 , A1 , A2 , A3 , A4 , A5 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(8) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 8>, true> + { + typedef proto::expr<T, A, 8> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 8>, true> + { + typedef proto::basic_expr<T, A, 8> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A7 + , detail::expand_pattern_rest_7< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(9) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 9>, true> + { + typedef proto::expr<T, A, 9> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 9>, true> + { + typedef proto::basic_expr<T, A, 9> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A8 + , detail::expand_pattern_rest_8< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(10) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || make_if_<A9, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 10>, true> + { + typedef proto::expr<T, A, 10> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 10>, true> + { + typedef proto::basic_expr<T, A, 10> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A9 + , detail::expand_pattern_rest_9< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp new file mode 100644 index 0000000..a053c50 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp @@ -0,0 +1,481 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file make_gcc_workaround.hpp + /// Special workaround code to make the make\<\> transform work on certain + /// versions of gcc. + // + // 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 Tag, typename Args, long Arity > + struct make<proto::expr<Tag, Args, Arity>()> + : transform<make<proto::expr<Tag, Args, Arity>()> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + + ); + } + }; + }; + template<typename Tag, typename Args, long Arity > + struct make<proto::basic_expr<Tag, Args, Arity>()> + : transform<make<proto::basic_expr<Tag, Args, Arity>()> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0> + struct make<proto::expr<Tag, Args, Arity>(A0)> + : transform<make<proto::expr<Tag, Args, Arity>(A0)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0> + struct make<proto::basic_expr<Tag, Args, Arity>(A0)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pack_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pack_impl.hpp new file mode 100644 index 0000000..802bb6a --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pack_impl.hpp @@ -0,0 +1,442 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file pack_impl.hpp + /// Contains helpers for pseudo-pack expansion. + // + // Copyright 2012 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 Fun, typename Cont> + struct expand_pattern<1, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret > + struct expand_pattern_rest_0 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void , typename C9 = void , typename C10 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret( C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret( C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<2, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0> + struct expand_pattern_rest_1 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void , typename C9 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<3, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1> + struct expand_pattern_rest_2 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<4, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2> + struct expand_pattern_rest_3 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<5, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3> + struct expand_pattern_rest_4 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<6, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct expand_pattern_rest_5 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3 , C4)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<7, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct expand_pattern_rest_6 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2 , C3)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<8, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct expand_pattern_rest_7 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1 , C2)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<9, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct expand_pattern_rest_8 + { + template<typename C0 = void , typename C1 = void , typename C2 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0 , C1)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<10, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 9>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct expand_pattern_rest_9 + { + template<typename C0 = void , typename C1 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , C0)> type; + }; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pass_through_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pass_through_impl.hpp new file mode 100644 index 0000000..401b200 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pass_through_impl.hpp @@ -0,0 +1,419 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file pass_through_impl.hpp + /// + /// Specializations of pass_through_impl, used in the implementation of the + /// pass_through transform. + // + // 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 Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 1> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list1< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 2> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list2< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 3> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list3< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 4> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list4< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 5> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list5< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 6> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list6< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 7> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list7< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 8> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list8< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 9> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list9< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 10> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list10< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d ) , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >()( e.proto_base().child9, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/when.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/when.hpp new file mode 100644 index 0000000..9f5acc9 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/when.hpp @@ -0,0 +1,637 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file when.hpp + /// Definition of when transform. + // + // 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 Grammar, typename R > + struct when<Grammar, R()> + : detail::when_impl<Grammar, R, R()> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0> + struct when<Grammar, R(A0)> + : detail::when_impl<Grammar, R, R(A0)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0> + struct when<Grammar, R(A0...)> + : detail::when_impl<Grammar, R, R(A0...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1> + struct when<Grammar, R(A0 , A1)> + : detail::when_impl<Grammar, R, R(A0 , A1)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1> + struct when<Grammar, R(A0 , A1...)> + : detail::when_impl<Grammar, R, R(A0 , A1...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2> + struct when<Grammar, R(A0 , A1 , A2)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2> + struct when<Grammar, R(A0 , A1 , A2...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3> + struct when<Grammar, R(A0 , A1 , A2 , A3)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3> + struct when<Grammar, R(A0 , A1 , A2 , A3...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> + {}; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/when.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/when.hpp new file mode 100644 index 0000000..1362107 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/when.hpp @@ -0,0 +1,101 @@ +#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) + + #include <boost/proto/transform/detail/preprocessed/when.hpp> + +#elif !defined(BOOST_PP_IS_ITERATING) + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(preserve: 2, line: 0, output: "preprocessed/when.hpp") + #endif + + /////////////////////////////////////////////////////////////////////////////// + /// \file when.hpp + /// Definition of when transform. + // + // 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, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/when.hpp>)) + #include BOOST_PP_ITERATE() + + #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) + #pragma wave option(output: null) + #endif + +#else + + #define N BOOST_PP_ITERATION() + + /// \brief A grammar element and a PrimitiveTransform that associates + /// a transform with the grammar. + /// + /// Use <tt>when\<\></tt> to override a grammar's default transform + /// with a custom transform. It is for used when composing larger + /// transforms by associating smaller transforms with individual + /// rules in your grammar, as in the following transform which + /// counts the number of terminals in an expression. + /// + /// \code + /// // Count the terminals in an expression tree. + /// // Must be invoked with initial state == mpl::int_<0>(). + /// struct CountLeaves + /// : or_< + /// when<terminal<_>, mpl::next<_state>()> + /// , otherwise<fold<_, _state, CountLeaves> > + /// > + /// {}; + /// \endcode + /// + /// The <tt>when\<G, R(A0,A1,...)\></tt> form accepts either a + /// CallableTransform or an ObjectTransform as its second parameter. + /// <tt>when\<\></tt> uses <tt>is_callable\<R\>::value</tt> to + /// distinguish between the two, and uses <tt>call\<\></tt> to + /// evaluate CallableTransforms and <tt>make\<\></tt> to evaluate + /// ObjectTransforms. + template<typename Grammar, typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A))> + : detail::when_impl<Grammar, R, R(BOOST_PP_ENUM_PARAMS(N, A))> + {}; + + #if N > 0 + /// \brief A grammar element and a PrimitiveTransform that associates + /// a transform with the grammar. + /// + /// Use <tt>when\<\></tt> to override a grammar's default transform + /// with a custom transform. It is for used when composing larger + /// transforms by associating smaller transforms with individual + /// rules in your grammar, as in the following transform which + /// counts the number of terminals in an expression. + /// + /// \code + /// // Count the terminals in an expression tree. + /// // Must be invoked with initial state == mpl::int_<0>(). + /// struct CountLeaves + /// : or_< + /// when<terminal<_>, mpl::next<_state>()> + /// , otherwise<fold<_, _state, CountLeaves> > + /// > + /// {}; + /// \endcode + /// + /// The <tt>when\<G, R(A0,A1,...)\></tt> form accepts either a + /// CallableTransform or an ObjectTransform as its second parameter. + /// <tt>when\<\></tt> uses <tt>is_callable\<R\>::value</tt> to + /// distinguish between the two, and uses <tt>call\<\></tt> to + /// evaluate CallableTransforms and <tt>make\<\></tt> to evaluate + /// ObjectTransforms. + template<typename Grammar, typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)> + struct when<Grammar, R(BOOST_PP_ENUM_PARAMS(N, A)...)> + : detail::when_impl<Grammar, R, R(BOOST_PP_ENUM_PARAMS(N, A)...)> + {}; + #endif + + #undef N + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/env.hpp b/3rdParty/Boost/src/boost/proto/transform/env.hpp new file mode 100644 index 0000000..81309fa --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/env.hpp @@ -0,0 +1,515 @@ +/////////////////////////////////////////////////////////////////////////////// +// env.hpp +// Helpers for producing and consuming tranform env variables. +// +// Copyright 2012 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_TRANSFORM_ENV_HPP_EAN_18_07_2012 +#define BOOST_PROTO_TRANSFORM_ENV_HPP_EAN_18_07_2012 + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> +#include <boost/ref.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_reference.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/not.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/proto/detail/poly_function.hpp> +#include <boost/proto/detail/is_noncopyable.hpp> + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored +#endif + +namespace boost +{ + namespace proto + { + namespace detail + { + template<typename T> + struct value_type + { + typedef typename remove_const<T>::type value; + typedef typename add_reference<T>::type reference; + typedef typename mpl::if_c<is_noncopyable<T>::value, reference, value>::type type; + }; + + template<typename T> + struct value_type<T &> + { + typedef T &value; + typedef T &reference; + typedef T &type; + }; + } + + #define BOOST_PROTO_DEFINE_ENV_VAR(TAG, NAME) \ + struct TAG \ + { \ + template<typename Value> \ + boost::proto::env<TAG, Value &> const \ + operator =(boost::reference_wrapper<Value> &value) const \ + { \ + return boost::proto::env<TAG, Value &>(value.get()); \ + } \ + template<typename Value> \ + boost::proto::env<TAG, Value &> const \ + operator =(boost::reference_wrapper<Value> const &value) const \ + { \ + return boost::proto::env<TAG, Value &>(value.get()); \ + } \ + template<typename Value> \ + typename boost::disable_if_c< \ + boost::is_const<Value>::value \ + , boost::proto::env<TAG, typename boost::proto::detail::value_type<Value>::type> \ + >::type const operator =(Value &value) const \ + { \ + return boost::proto::env<TAG, typename boost::proto::detail::value_type<Value>::type>(value); \ + } \ + template<typename Value> \ + boost::proto::env<TAG, typename boost::proto::detail::value_type<Value const>::type> const \ + operator =(Value const &value) const \ + { \ + return boost::proto::env<TAG, typename boost::proto::detail::value_type<Value const>::type>(value); \ + } \ + }; \ + \ + TAG const NAME = {} \ + /**/ + + namespace envns_ + { + //////////////////////////////////////////////////////////////////////////////////////////// + // env + // A transform env is a slot-based storage mechanism, accessible by tag. + template<typename Key, typename Value, typename Base /*= empty_env*/> + struct env + : private Base + { + private: + Value value_; + + public: + typedef Value value_type; + typedef typename add_reference<Value>::type reference; + typedef typename add_reference<typename add_const<Value>::type>::type const_reference; + typedef void proto_environment_; ///< INTERNAL ONLY + + explicit env(const_reference value, Base const &base = Base()) + : Base(base) + , value_(value) + {} + + #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ <= 2) + /// INTERNAL ONLY + struct found + { + typedef Value type; + typedef typename add_reference<typename add_const<Value>::type>::type const_reference; + }; + + template<typename OtherKey, typename OtherValue = key_not_found> + struct lookup + : mpl::if_c< + is_same<OtherKey, Key>::value + , found + , typename Base::template lookup<OtherKey, OtherValue> + >::type + {}; + #else + /// INTERNAL ONLY + template<typename OtherKey, typename OtherValue = key_not_found> + struct lookup + : Base::template lookup<OtherKey, OtherValue> + {}; + + /// INTERNAL ONLY + template<typename OtherValue> + struct lookup<Key, OtherValue> + { + typedef Value type; + typedef typename add_reference<typename add_const<Value>::type>::type const_reference; + }; + #endif + + // For key-based lookups not intended to fail + using Base::operator[]; + const_reference operator[](Key) const + { + return this->value_; + } + + // For key-based lookups that can fail, use the default if key not found. + using Base::at; + template<typename T> + const_reference at(Key, T const &) const + { + return this->value_; + } + }; + + // define proto::data_type type and proto::data global + BOOST_PROTO_DEFINE_ENV_VAR(data_type, data); + } + + using envns_::data; + + namespace functional + { + //////////////////////////////////////////////////////////////////////////////////////// + // as_env + struct as_env + { + BOOST_PROTO_CALLABLE() + BOOST_PROTO_POLY_FUNCTION() + + /// INTERNAL ONLY + template<typename T, bool B = is_env<T>::value> + struct impl + { + typedef env<data_type, typename detail::value_type<T>::type> result_type; + + result_type const operator()(detail::arg<T> t) const + { + return result_type(t()); + } + }; + + /// INTERNAL ONLY + template<typename T> + struct impl<T, true> + { + typedef T result_type; + + typename add_const<T>::type operator()(detail::arg<T> t) const + { + return t(); + } + }; + + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef typename impl<typename detail::normalize_arg<T>::type>::result_type type; + }; + + template<typename T> + typename impl<typename detail::normalize_arg<T &>::type>::result_type const + operator()(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T)) const + { + return impl<typename detail::normalize_arg<T &>::type>()( + static_cast<typename detail::normalize_arg<T &>::reference>(t) + ); + } + + template<typename T> + typename impl<typename detail::normalize_arg<T const &>::type>::result_type const + operator()(T const &t) const + { + return impl<typename detail::normalize_arg<T const &>::type>()( + static_cast<typename detail::normalize_arg<T const &>::reference>(t) + ); + } + }; + + //////////////////////////////////////////////////////////////////////////////////////// + // has_env_var + template<typename Key> + struct has_env_var + : detail::poly_function<has_env_var<Key> > + { + BOOST_PROTO_CALLABLE() + + template<typename Env, bool IsEnv = is_env<Env>::value> + struct impl + { + typedef + mpl::not_< + is_same< + typename remove_reference<Env>::type::template lookup<Key>::type + , key_not_found + > + > + result_type; + + result_type operator()(detail::arg<Env>) const + { + return result_type(); + } + }; + + template<typename Env> + struct impl<Env, false> + { + typedef mpl::false_ result_type; + + result_type operator()(detail::arg<Env>) const + { + return result_type(); + } + }; + }; + + template<> + struct has_env_var<data_type> + : detail::poly_function<has_env_var<data_type> > + { + BOOST_PROTO_CALLABLE() + + template<typename Env, bool IsEnv = is_env<Env>::value> + struct impl + { + typedef + mpl::not_< + is_same< + typename remove_reference<Env>::type::template lookup<data_type>::type + , key_not_found + > + > + result_type; + + result_type operator()(detail::arg<Env>) const + { + return result_type(); + } + }; + + template<typename Env> + struct impl<Env, false> + { + typedef mpl::true_ result_type; + + result_type operator()(detail::arg<Env>) const + { + return result_type(); + } + }; + }; + + //////////////////////////////////////////////////////////////////////////////////////// + // env_var + template<typename Key> + struct env_var + : detail::poly_function<env_var<Key> > + { + BOOST_PROTO_CALLABLE() + + template<typename Env> + struct impl + { + typedef + typename remove_reference<Env>::type::template lookup<Key>::type + result_type; + + result_type operator()(detail::arg<Env> e) const + { + return e()[Key()]; + } + }; + }; + + template<> + struct env_var<data_type> + : detail::poly_function<env_var<data_type> > + { + BOOST_PROTO_CALLABLE() + + template<typename Env, bool B = is_env<Env>::value> + struct impl + { + typedef Env result_type; + + result_type operator()(detail::arg<Env> e) const + { + return e(); + } + }; + + template<typename Env> + struct impl<Env, true> + { + typedef + typename remove_reference<Env>::type::template lookup<data_type>::type + result_type; + + result_type operator()(detail::arg<Env> e) const + { + return e()[proto::data]; + } + }; + }; + } + + namespace result_of + { + template<typename T> + struct as_env + : BOOST_PROTO_RESULT_OF<functional::as_env(T)> + {}; + + template<typename Env, typename Key> + struct has_env_var + : BOOST_PROTO_RESULT_OF<functional::has_env_var<Key>(Env)>::type + {}; + + template<typename Env, typename Key> + struct env_var + : BOOST_PROTO_RESULT_OF<functional::env_var<Key>(Env)> + {}; + } + + //////////////////////////////////////////////////////////////////////////////////////////// + // as_env + template<typename T> + typename proto::result_of::as_env<T &>::type const as_env(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T)) + { + return proto::functional::as_env()(t); + } + + template<typename T> + typename proto::result_of::as_env<T const &>::type const as_env(T const &t) + { + return proto::functional::as_env()(t); + } + + //////////////////////////////////////////////////////////////////////////////////////////// + // has_env_var + template<typename Key, typename Env> + typename proto::result_of::has_env_var<Env &, Key>::type has_env_var(Env &e BOOST_PROTO_DISABLE_IF_IS_CONST(Env)) + { + return functional::has_env_var<Key>()(e); + } + + template<typename Key, typename Env> + typename proto::result_of::has_env_var<Env const &, Key>::type has_env_var(Env const &e) + { + return functional::has_env_var<Key>()(e); + } + + //////////////////////////////////////////////////////////////////////////////////////////// + // env_var + template<typename Key, typename Env> + typename proto::result_of::env_var<Env &, Key>::type env_var(Env &e BOOST_PROTO_DISABLE_IF_IS_CONST(Env)) + { + return functional::env_var<Key>()(e); + } + + template<typename Key, typename Env> + typename proto::result_of::env_var<Env const &, Key>::type env_var(Env const &e) + { + return functional::env_var<Key>()(e); + } + + namespace envns_ + { + //////////////////////////////////////////////////////////////////////////////////////// + // env operator, + template<typename T, typename T1, typename V1> + inline typename disable_if_c< + is_const<T>::value + , env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T &>::type)> + >::type const operator,(T &t, env<T1, V1> const &head) + { + return env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T &>::type)>( + head[T1()] + , proto::as_env(t) + ); + } + + template<typename T, typename T1, typename V1> + inline env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T const &>::type)> const + operator,(T const &t, env<T1, V1> const &head) + { + return env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T const &>::type)>( + head[T1()] + , proto::as_env(t) + ); + } + } + + //////////////////////////////////////////////////////////////////////////////////////////// + // _env_var + template<typename Key> + struct _env_var + : proto::transform<_env_var<Key> > + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + typedef typename impl::data::template lookup<Key>::type result_type; + BOOST_MPL_ASSERT_NOT((is_same<result_type, key_not_found>)); // lookup failed + + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::data::template lookup<Key>::const_reference) + operator ()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param d + ) const + { + return d[Key()]; + } + }; + }; + + struct _env + : transform<_env> + { + template<typename Expr, typename State, typename Data> + struct impl + : transform_impl<Expr, State, Data> + { + typedef Data result_type; + + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::data_param) + operator ()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param d + ) const + { + return d; + } + }; + }; + + /// INTERNAL ONLY + template<typename Key> + struct is_callable<_env_var<Key> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + template<typename Key> + struct is_callable<functional::has_env_var<Key> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + template<typename Key> + struct is_callable<functional::env_var<Key> > + : mpl::true_ + {}; + } +} + +#ifdef _MSC_VER +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/fold.hpp b/3rdParty/Boost/src/boost/proto/transform/fold.hpp new file mode 100644 index 0000000..52a35e3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/fold.hpp @@ -0,0 +1,250 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file fold.hpp +/// Contains definition of the fold<> and reverse_fold<> transforms. +// +// 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_TRANSFORM_FOLD_HPP_EAN_11_04_2007 +#define BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/fusion/include/fold.hpp> +#include <boost/fusion/include/reverse_fold.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/proto/transform/when.hpp> + +namespace boost { namespace proto +{ + namespace detail + { + template<typename Transform, typename Data> + struct as_callable + { + as_callable(Data d) + : d_(d) + {} + + template<typename Sig> + struct result; + + template<typename This, typename State, typename Expr> + struct result<This(State, Expr)> + { + typedef + typename when<_, Transform>::template impl<Expr, State, Data>::result_type + type; + }; + + template<typename State, typename Expr> + typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type + operator ()(State const &s, Expr &e) const + { + return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->d_); + } + + private: + Data d_; + }; + + template< + typename State0 + , typename Fun + , typename Expr + , typename State + , typename Data + , long Arity = arity_of<Expr>::value + > + struct fold_impl + {}; + + template< + typename State0 + , typename Fun + , typename Expr + , typename State + , typename Data + , long Arity = arity_of<Expr>::value + > + struct reverse_fold_impl + {}; + + #include <boost/proto/transform/detail/fold_impl.hpp> + + } // namespace detail + + /// \brief A PrimitiveTransform that invokes the <tt>fusion::fold\<\></tt> + /// algorithm to accumulate + template<typename Sequence, typename State0, typename Fun> + struct fold : transform<fold<Sequence, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + /// \brief A Fusion sequence. + typedef + typename remove_reference< + typename when<_, Sequence>::template impl<Expr, State, Data>::result_type + >::type + sequence; + + /// \brief An initial state for the fold. + typedef + typename remove_reference< + typename when<_, State0>::template impl<Expr, State, Data>::result_type + >::type + state0; + + /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt> + typedef + detail::as_callable<Fun, Data> + fun; + + typedef + typename fusion::result_of::fold< + sequence + , state0 + , fun + >::type + result_type; + + /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let + /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and + /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt> + /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this + /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename when<_, Sequence>::template impl<Expr, State, Data> seq; + detail::as_callable<Fun, Data> f(d); + return fusion::fold( + seq(e, s, d) + , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d) + , f + ); + } + }; + }; + + /// \brief A PrimitiveTransform that is the same as the + /// <tt>fold\<\></tt> transform, except that it folds + /// back-to-front instead of front-to-back. + template<typename Sequence, typename State0, typename Fun> + struct reverse_fold : transform<reverse_fold<Sequence, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + /// \brief A Fusion sequence. + typedef + typename remove_reference< + typename when<_, Sequence>::template impl<Expr, State, Data>::result_type + >::type + sequence; + + /// \brief An initial state for the fold. + typedef + typename remove_reference< + typename when<_, State0>::template impl<Expr, State, Data>::result_type + >::type + state0; + + /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt> + typedef + detail::as_callable<Fun, Data> + fun; + + typedef + typename fusion::result_of::reverse_fold< + sequence + , state0 + , fun + >::type + result_type; + + /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let + /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and + /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt> + /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this + /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typename when<_, Sequence>::template impl<Expr, State, Data> seq; + detail::as_callable<Fun, Data> f(d); + return fusion::reverse_fold( + seq(e, s, d) + , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d) + , f + ); + } + }; + }; + + // This specialization is only for improved compile-time performance + // in the commom case when the Sequence transform is \c proto::_. + // + /// INTERNAL ONLY + /// + template<typename State0, typename Fun> + struct fold<_, State0, Fun> : transform<fold<_, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl + : detail::fold_impl<State0, Fun, Expr, State, Data> + {}; + }; + + // This specialization is only for improved compile-time performance + // in the commom case when the Sequence transform is \c proto::_. + // + /// INTERNAL ONLY + /// + template<typename State0, typename Fun> + struct reverse_fold<_, State0, Fun> : transform<reverse_fold<_, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl + : detail::reverse_fold_impl<State0, Fun, Expr, State, Data> + {}; + }; + + /// INTERNAL ONLY + /// + template<typename Sequence, typename State, typename Fun> + struct is_callable<fold<Sequence, State, Fun> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Sequence, typename State, typename Fun> + struct is_callable<reverse_fold<Sequence, State, Fun> > + : mpl::true_ + {}; + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp b/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp new file mode 100644 index 0000000..ace2c21 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp @@ -0,0 +1,182 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file fold_tree.hpp +/// Contains definition of the fold_tree<> and reverse_fold_tree<> transforms. +// +// 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_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007 +#define BOOST_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007 + +#include <boost/type_traits/is_same.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/matches.hpp> +#include <boost/proto/transform/fold.hpp> +#include <boost/proto/transform/impl.hpp> + +namespace boost { namespace proto +{ + namespace detail + { + template<typename Tag> + struct has_tag + { + template<typename Expr, typename State, typename Data, typename EnableIf = Tag> + struct impl + { + typedef mpl::false_ result_type; + }; + + template<typename Expr, typename State, typename Data> + struct impl<Expr, State, Data, typename Expr::proto_tag> + { + typedef mpl::true_ result_type; + }; + + template<typename Expr, typename State, typename Data> + struct impl<Expr &, State, Data, typename Expr::proto_tag> + { + typedef mpl::true_ result_type; + }; + }; + + template<typename Tag, typename Fun> + struct fold_tree_ + : if_<has_tag<Tag>, fold<_, _state, fold_tree_<Tag, Fun> >, Fun> + {}; + + template<typename Tag, typename Fun> + struct reverse_fold_tree_ + : if_<has_tag<Tag>, reverse_fold<_, _state, reverse_fold_tree_<Tag, Fun> >, Fun> + {}; + } + + /// \brief A PrimitiveTransform that recursively applies the + /// <tt>fold\<\></tt> transform to sub-trees that all share a common + /// tag type. + /// + /// <tt>fold_tree\<\></tt> is useful for flattening trees into lists; + /// for example, you might use <tt>fold_tree\<\></tt> to flatten an + /// expression tree like <tt>a | b | c</tt> into a Fusion list like + /// <tt>cons(c, cons(b, cons(a)))</tt>. + /// + /// <tt>fold_tree\<\></tt> is easily understood in terms of a + /// <tt>recurse_if_\<\></tt> helper, defined as follows: + /// + /// \code + /// template<typename Tag, typename Fun> + /// struct recurse_if_ + /// : if_< + /// // If the current node has type type "Tag" ... + /// is_same<tag_of<_>, Tag>() + /// // ... recurse, otherwise ... + /// , fold<_, _state, recurse_if_<Tag, Fun> > + /// // ... apply the Fun transform. + /// , Fun + /// > + /// {}; + /// \endcode + /// + /// With <tt>recurse_if_\<\></tt> as defined above, + /// <tt>fold_tree\<Sequence, State0, Fun\>()(e, s, d)</tt> is + /// equivalent to + /// <tt>fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(e, s, d).</tt> + /// It has the effect of folding a tree front-to-back, recursing into + /// child nodes that share a tag type with the parent node. + template<typename Sequence, typename State0, typename Fun> + struct fold_tree + : transform<fold_tree<Sequence, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl + : fold< + Sequence + , State0 + , detail::fold_tree_<typename Expr::proto_tag, Fun> + >::template impl<Expr, State, Data> + {}; + + template<typename Expr, typename State, typename Data> + struct impl<Expr &, State, Data> + : fold< + Sequence + , State0 + , detail::fold_tree_<typename Expr::proto_tag, Fun> + >::template impl<Expr &, State, Data> + {}; + }; + + /// \brief A PrimitiveTransform that recursively applies the + /// <tt>reverse_fold\<\></tt> transform to sub-trees that all share + /// a common tag type. + /// + /// <tt>reverse_fold_tree\<\></tt> is useful for flattening trees into + /// lists; for example, you might use <tt>reverse_fold_tree\<\></tt> to + /// flatten an expression tree like <tt>a | b | c</tt> into a Fusion list + /// like <tt>cons(a, cons(b, cons(c)))</tt>. + /// + /// <tt>reverse_fold_tree\<\></tt> is easily understood in terms of a + /// <tt>recurse_if_\<\></tt> helper, defined as follows: + /// + /// \code + /// template<typename Tag, typename Fun> + /// struct recurse_if_ + /// : if_< + /// // If the current node has type type "Tag" ... + /// is_same<tag_of<_>, Tag>() + /// // ... recurse, otherwise ... + /// , reverse_fold<_, _state, recurse_if_<Tag, Fun> > + /// // ... apply the Fun transform. + /// , Fun + /// > + /// {}; + /// \endcode + /// + /// With <tt>recurse_if_\<\></tt> as defined above, + /// <tt>reverse_fold_tree\<Sequence, State0, Fun\>()(e, s, d)</tt> is + /// equivalent to + /// <tt>reverse_fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(e, s, d).</tt> + /// It has the effect of folding a tree back-to-front, recursing into + /// child nodes that share a tag type with the parent node. + template<typename Sequence, typename State0, typename Fun> + struct reverse_fold_tree + : transform<reverse_fold_tree<Sequence, State0, Fun> > + { + template<typename Expr, typename State, typename Data> + struct impl + : reverse_fold< + Sequence + , State0 + , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun> + >::template impl<Expr, State, Data> + {}; + + template<typename Expr, typename State, typename Data> + struct impl<Expr &, State, Data> + : reverse_fold< + Sequence + , State0 + , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun> + >::template impl<Expr &, State, Data> + {}; + }; + + /// INTERNAL ONLY + /// + template<typename Sequence, typename State0, typename Fun> + struct is_callable<fold_tree<Sequence, State0, Fun> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename Sequence, typename State0, typename Fun> + struct is_callable<reverse_fold_tree<Sequence, State0, Fun> > + : mpl::true_ + {}; + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/impl.hpp b/3rdParty/Boost/src/boost/proto/transform/impl.hpp new file mode 100644 index 0000000..5cd538b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/impl.hpp @@ -0,0 +1,352 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file impl.hpp +/// Contains definition of transform<> and transform_impl<> helpers. +// +// 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_TRANSFORM_IMPL_HPP_EAN_04_03_2008 +#define BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008 + +#include <boost/config.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_reference.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/detail/any.hpp> +#include <boost/proto/detail/static_const.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + namespace envns_ + { + //////////////////////////////////////////////////////////////////////////////////////////// + struct key_not_found + {}; + + //////////////////////////////////////////////////////////////////////////////////////////// + // empty_env + struct empty_env + { + typedef void proto_environment_; + + template<typename OtherTag, typename OtherValue = key_not_found> + struct lookup + { + typedef OtherValue type; + typedef + typename add_reference<typename add_const<OtherValue>::type>::type + const_reference; + }; + + key_not_found operator[](detail::any) const + { + return key_not_found(); + } + + template<typename T> + T const &at(detail::any, T const &t) const + { + return t; + } + }; + } + + //////////////////////////////////////////////////////////////////////////////////////////// + // is_env + template<typename T, typename Void> + struct is_env + : mpl::false_ + {}; + + template<typename T> + struct is_env<T, typename T::proto_environment_> + : mpl::true_ + {}; + + template<typename T> + struct is_env<T &, void> + : is_env<T> + {}; + +#ifdef BOOST_NO_RVALUE_REFERENCES + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) \ + BOOST_PROTO_CALLABLE() \ + typedef X proto_is_transform_; \ + typedef PrimitiveTransform transform_type; \ + \ + template<typename Sig> \ + struct result \ + { \ + typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; \ + }; \ + \ + template<typename Expr> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr &)>::result_type \ + operator ()(Expr &e) const \ + { \ + boost::proto::empty_state s = 0; \ + boost::proto::empty_env d; \ + return boost::proto::detail::apply_transform<transform_type(Expr &)>()(e, s, d); \ + } \ + \ + template<typename Expr> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr const &)>::result_type \ + operator ()(Expr const &e) const \ + { \ + boost::proto::empty_state s = 0; \ + boost::proto::empty_env d; \ + return boost::proto::detail::apply_transform<transform_type(Expr const &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr &, State &)>::result_type \ + operator ()(Expr &e, State &s) const \ + { \ + boost::proto::empty_env d; \ + return boost::proto::detail::apply_transform<transform_type(Expr &, State &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr const &, State &)>::result_type \ + operator ()(Expr const &e, State &s) const \ + { \ + boost::proto::empty_env d; \ + return boost::proto::detail::apply_transform<transform_type(Expr const &, State &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>::result_type \ + operator ()(Expr &e, State const &s) const \ + { \ + boost::proto::empty_env d; \ + return boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>::result_type \ + operator ()(Expr const &e, State const &s) const \ + { \ + boost::proto::empty_env d; \ + return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State, typename Data> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>::result_type \ + operator ()(Expr &e, State &s, Data &d) const \ + { \ + return boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State, typename Data> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr const &, State &, Data &)>::result_type \ + operator ()(Expr const &e, State &s, Data &d) const \ + { \ + return boost::proto::detail::apply_transform<transform_type(Expr const &, State &, Data &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State, typename Data> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>::result_type \ + operator ()(Expr &e, State const &s, Data &d) const \ + { \ + return boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State, typename Data> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data &)>::result_type \ + operator ()(Expr const &e, State const &s, Data &d) const \ + { \ + return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data &)>()(e, s, d); \ + } \ + /**/ + +#else + + /// INTERNAL ONLY + /// + #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) \ + BOOST_PROTO_CALLABLE() \ + typedef X proto_is_transform_; \ + typedef PrimitiveTransform transform_type; \ + \ + template<typename Sig> \ + struct result \ + { \ + typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; \ + }; \ + \ + template<typename Expr> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr const &)>::result_type \ + operator ()(Expr &&e) const \ + { \ + boost::proto::empty_state s = 0; \ + boost::proto::empty_env d; \ + return boost::proto::detail::apply_transform<transform_type(Expr const &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>::result_type \ + operator ()(Expr &&e, State &&s) const \ + { \ + boost::proto::empty_env d; \ + return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>()(e, s, d); \ + } \ + \ + template<typename Expr, typename State, typename Data> \ + BOOST_FORCEINLINE \ + typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data const &)>::result_type \ + operator ()(Expr &&e, State &&s, Data &&d) const \ + { \ + return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data const &)>()(e, s, d); \ + } \ + /**/ + +#endif + + #define BOOST_PROTO_TRANSFORM(PrimitiveTransform) \ + BOOST_PROTO_TRANSFORM_(PrimitiveTransform, void) \ + /**/ + + namespace detail + { + template<typename Sig> + struct apply_transform; + + template<typename PrimitiveTransform, typename Expr> + struct apply_transform<PrimitiveTransform(Expr)> + : PrimitiveTransform::template impl<Expr, empty_state, empty_env> + {}; + + template<typename PrimitiveTransform, typename Expr, typename State> + struct apply_transform<PrimitiveTransform(Expr, State)> + : PrimitiveTransform::template impl<Expr, State, empty_env> + {}; + + template<typename PrimitiveTransform, typename Expr, typename State, typename Data> + struct apply_transform<PrimitiveTransform(Expr, State, Data)> + : PrimitiveTransform::template impl<Expr, State, Data> + {}; + } + + template<typename PrimitiveTransform, typename X> + struct transform + { + BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl + { + typedef Expr const expr; + typedef Expr const &expr_param; + typedef State const state; + typedef State const &state_param; + typedef Data const data; + typedef Data const &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr &, State, Data> + { + typedef Expr expr; + typedef Expr &expr_param; + typedef State const state; + typedef State const &state_param; + typedef Data const data; + typedef Data const &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr, State &, Data> + { + typedef Expr const expr; + typedef Expr const &expr_param; + typedef State state; + typedef State &state_param; + typedef Data const data; + typedef Data const &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr, State, Data &> + { + typedef Expr const expr; + typedef Expr const &expr_param; + typedef State const state; + typedef State const &state_param; + typedef Data data; + typedef Data &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr &, State &, Data> + { + typedef Expr expr; + typedef Expr &expr_param; + typedef State state; + typedef State &state_param; + typedef Data const data; + typedef Data const &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr &, State, Data &> + { + typedef Expr expr; + typedef Expr &expr_param; + typedef State const state; + typedef State const &state_param; + typedef Data data; + typedef Data &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr, State &, Data &> + { + typedef Expr const expr; + typedef Expr const &expr_param; + typedef State state; + typedef State &state_param; + typedef Data data; + typedef Data &data_param; + }; + + template<typename Expr, typename State, typename Data> + struct transform_impl<Expr &, State &, Data &> + { + typedef Expr expr; + typedef Expr &expr_param; + typedef State state; + typedef State &state_param; + typedef Data data; + typedef Data &data_param; + }; + +}} // namespace boost::proto + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/integral_c.hpp b/3rdParty/Boost/src/boost/proto/transform/integral_c.hpp new file mode 100644 index 0000000..200462b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/integral_c.hpp @@ -0,0 +1,111 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file integral_c.hpp +/// Contains definition of the integral_c transform and friends. +// +// Copyright 2011 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_TRANSFORM_INTEGRAL_C_HPP_EAN_04_28_2011 +#define BOOST_PROTO_TRANSFORM_INTEGRAL_C_HPP_EAN_04_28_2011 + +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/transform/impl.hpp> + +namespace boost { namespace proto +{ + + /// \brief A PrimitiveTransform that returns a specified + /// integral constant + /// + template<typename T, T I> + struct integral_c : transform<integral_c<T, I> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef T result_type; + + /// \return \c I + /// \throw nothrow + T operator()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param + ) const + { + return I; + } + }; + }; + + /// \brief A PrimitiveTransform that returns a specified + /// char + /// + template<char I> + struct char_ + : integral_c<char, I> + {}; + + /// \brief A PrimitiveTransform that returns a specified + /// int + /// + template<int I> + struct int_ + : integral_c<int, I> + {}; + + /// \brief A PrimitiveTransform that returns a specified + /// long + /// + template<long I> + struct long_ + : integral_c<long, I> + {}; + + /// \brief A PrimitiveTransform that returns a specified + /// std::size_t + /// + template<std::size_t I> + struct size_t + : integral_c<std::size_t, I> + {}; + + /// INTERNAL ONLY + /// + template<typename T, T I> + struct is_callable<integral_c<T, I> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<char I> + struct is_callable<char_<I> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<int I> + struct is_callable<int_<I> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<long I> + struct is_callable<long_<I> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<std::size_t I> + struct is_callable<size_t<I> > + : mpl::true_ + {}; + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/lazy.hpp b/3rdParty/Boost/src/boost/proto/transform/lazy.hpp new file mode 100644 index 0000000..e2d43ab --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/lazy.hpp @@ -0,0 +1,59 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file lazy.hpp +/// Contains definition of the lazy<> transform. +// +// 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_TRANSFORM_LAZY_HPP_EAN_12_02_2007 +#define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007 + +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/transform/make.hpp> +#include <boost/proto/transform/call.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/proto/transform/detail/pack.hpp> + +namespace boost { namespace proto +{ + /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build + /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it. + /// + /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the + /// transform to be applied depends on the current state of the + /// transformation. The invocation of the <tt>make\<\></tt> transform + /// evaluates any nested transforms, and the resulting type is treated + /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>. + template<typename Object> + struct lazy : transform<lazy<Object> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + >::template impl<Expr, State, Data> + {}; + }; + + /// INTERNAL ONLY + template<typename Fun> + struct lazy<detail::msvc_fun_workaround<Fun> > + : lazy<Fun> + {}; + + #include <boost/proto/transform/detail/lazy.hpp> + + /// INTERNAL ONLY + /// + template<typename Object> + struct is_callable<lazy<Object> > + : mpl::true_ + {}; + +}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/make.hpp b/3rdParty/Boost/src/boost/proto/transform/make.hpp new file mode 100644 index 0000000..140ca1d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/make.hpp @@ -0,0 +1,284 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file make.hpp +/// Contains definition of the make<> transform. +// +// 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_TRANSFORM_MAKE_HPP_EAN_12_02_2007 +#define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007 + +#include <boost/detail/workaround.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/selection/max.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/aux_/has_type.hpp> +#include <boost/proto/detail/template_arity.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/args.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/proto/transform/detail/pack.hpp> +#include <boost/proto/detail/as_lvalue.hpp> +#include <boost/proto/detail/ignore_unused.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template<typename T> + struct is_applyable + : mpl::and_<is_callable<T>, is_transform<T> > + {}; + + template<typename T, bool HasType = mpl::aux::has_type<T>::value> + struct nested_type + { + typedef typename T::type type; + }; + + template<typename T> + struct nested_type<T, false> + { + typedef T type; + }; + + template<typename T, bool Applied> + struct nested_type_if + { + typedef T type; + static bool const applied = false; + }; + + template<typename T> + struct nested_type_if<T, true> + : nested_type<T> + { + static bool const applied = true; + }; + + template< + typename R + , typename Expr, typename State, typename Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<R>::value) + > + struct make_ + { + typedef R type; + static bool const applied = false; + }; + + template< + typename R + , typename Expr, typename State, typename Data + , bool IsApplyable = is_applyable<R>::value + > + struct make_if_ + : make_<R, Expr, State, Data> + {}; + + template<typename R, typename Expr, typename State, typename Data> + struct make_if_<R, Expr, State, Data, true> + : uncvref<typename when<_, R>::template impl<Expr, State, Data>::result_type> + { + static bool const applied = true; + }; + + #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0) + // work around GCC bug + template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data> + struct make_if_<proto::expr<Tag, Args, N>, Expr, State, Data, false> + { + typedef proto::expr<Tag, Args, N> type; + static bool const applied = false; + }; + + // work around GCC bug + template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data> + struct make_if_<proto::basic_expr<Tag, Args, N>, Expr, State, Data, false> + { + typedef proto::basic_expr<Tag, Args, N> type; + static bool const applied = false; + }; + #endif + + template<typename Type, bool IsAggregate = detail::is_aggregate_<Type>::value> + struct construct_ + { + typedef Type result_type; + + BOOST_FORCEINLINE + Type operator ()() const + { + return Type(); + } + + // Other overloads generated by the preprocessor + #include <boost/proto/transform/detail/construct_funop.hpp> + }; + + template<typename Type> + struct construct_<Type, true> + { + typedef Type result_type; + + BOOST_FORCEINLINE + Type operator ()() const + { + return Type(); + } + + // Other overloads generated by the preprocessor + #include <boost/proto/transform/detail/construct_pod_funop.hpp> + }; + + } + + /// \brief A PrimitiveTransform which prevents another PrimitiveTransform + /// from being applied in an \c ObjectTransform. + /// + /// When building higher order transforms with <tt>make\<\></tt> or + /// <tt>lazy\<\></tt>, you sometimes would like to build types that + /// are parameterized with Proto transforms. In such lambda-style + /// transforms, Proto will unhelpfully find all nested transforms + /// and apply them, even if you don't want them to be applied. Consider + /// the following transform, which will replace the \c _ in + /// <tt>Bar<_>()</tt> with <tt>proto::terminal\<int\>::type</tt>: + /// + /// \code + /// template<typename T> + /// struct Bar + /// {}; + /// + /// struct Foo + /// : proto::when<_, Bar<_>() > + /// {}; + /// + /// proto::terminal<int>::type i = {0}; + /// + /// int main() + /// { + /// Foo()(i); + /// std::cout << typeid(Foo()(i)).name() << std::endl; + /// } + /// \endcode + /// + /// If you actually wanted to default-construct an object of type + /// <tt>Bar\<_\></tt>, you would have to protect the \c _ to prevent + /// it from being applied. You can use <tt>proto::protect\<\></tt> + /// as follows: + /// + /// \code + /// // OK: replace anything with Bar<_>() + /// struct Foo + /// : proto::when<_, Bar<protect<_> >() > + /// {}; + /// \endcode + template<typename PrimitiveTransform> + struct protect : transform<protect<PrimitiveTransform> > + { + template<typename, typename, typename> + struct impl + { + typedef PrimitiveTransform result_type; + }; + }; + + /// \brief A PrimitiveTransform which computes a type by evaluating any + /// nested transforms and then constructs an object of that type. + /// + /// The <tt>make\<\></tt> transform checks to see if \c Object is a template. + /// If it is, the template type is disassembled to find nested transforms. + /// Proto considers the following types to represent transforms: + /// + /// \li Function types + /// \li Function pointer types + /// \li Types for which <tt>proto::is_callable\< type \>::value</tt> is \c true + /// + /// <tt>boost::result_of\<make\<T\<X0,X1,...\> \>(Expr, State, Data)\>::type</tt> + /// is evaluated as follows. For each \c X in <tt>X0,X1,...</tt>, do: + /// + /// \li If \c X is a template like <tt>U\<Y0,Y1,...\></tt>, then let <tt>X'</tt> + /// be <tt>boost::result_of\<make\<U\<Y0,Y1,...\> \>(Expr, State, Data)\>::type</tt> + /// (which evaluates this procedure recursively). Note whether any + /// substitutions took place during this operation. + /// \li Otherwise, if \c X is a transform, then let <tt>X'</tt> be + /// <tt>boost::result_of\<when\<_, X\>(Expr, State, Data)\>::type</tt>. + /// Note that a substitution took place. + /// \li Otherwise, let <tt>X'</tt> be \c X, and note that no substitution + /// took place. + /// \li If any substitutions took place in any of the above steps and + /// <tt>T\<X0',X1',...\></tt> has a nested <tt>::type</tt> typedef, + /// the result type is <tt>T\<X0',X1',...\>::type</tt>. + /// \li Otherwise, the result type is <tt>T\<X0',X1',...\></tt>. + /// + /// Note that <tt>when\<\></tt> is implemented in terms of <tt>call\<\></tt> + /// and <tt>make\<\></tt>, so the above procedure is evaluated recursively. + template<typename Object> + struct make : transform<make<Object> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + /// \return <tt>result_type()</tt> + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param + ) const + { + return result_type(); + } + }; + }; + + /// INTERNAL ONLY + template<typename Fun> + struct make<detail::msvc_fun_workaround<Fun> > + : make<Fun> + {}; + + // Other specializations generated by the preprocessor. + #include <boost/proto/transform/detail/make.hpp> + #include <boost/proto/transform/detail/make_gcc_workaround.hpp> + + /// INTERNAL ONLY + /// + template<typename Object> + struct is_callable<make<Object> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<typename PrimitiveTransform> + struct is_callable<protect<PrimitiveTransform> > + : mpl::true_ + {}; + +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp b/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp new file mode 100644 index 0000000..9c43008 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp @@ -0,0 +1,145 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file pass_through.hpp +/// +/// Definition of the pass_through transform, which is the default transform +/// of all of the expression generator metafunctions such as unary_plus<>, plus<> +/// and nary_expr<>. +// +// 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_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006 +#define BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/args.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/proto/detail/ignore_unused.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template< + typename Grammar + , typename Domain + , typename Expr + , typename State + , typename Data + , long Arity = arity_of<Expr>::value + > + struct pass_through_impl + {}; + + #include <boost/proto/transform/detail/pass_through_impl.hpp> + + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 0> + : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// \param e An expression + /// \return \c e + /// \throw nothrow + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename pass_through_impl::expr_param) + operator()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param + , typename pass_through_impl::data_param + ) const + { + return e; + } + }; + + } // namespace detail + + /// \brief A PrimitiveTransform that transforms the child expressions + /// of an expression node according to the corresponding children of + /// a Grammar. + /// + /// Given a Grammar such as <tt>plus\<T0, T1\></tt>, an expression type + /// that matches the grammar such as <tt>plus\<E0, E1\>::type</tt>, a + /// state \c S and a data \c V, the result of applying the + /// <tt>pass_through\<plus\<T0, T1\> \></tt> transform is: + /// + /// \code + /// plus< + /// T0::result<T0(E0, S, V)>::type + /// , T1::result<T1(E1, S, V)>::type + /// >::type + /// \endcode + /// + /// The above demonstrates how child transforms and child expressions + /// are applied pairwise, and how the results are reassembled into a new + /// expression node with the same tag type as the original. + /// + /// The explicit use of <tt>pass_through\<\></tt> is not usually needed, + /// since the expression generator metafunctions such as + /// <tt>plus\<\></tt> have <tt>pass_through\<\></tt> as their default + /// transform. So, for instance, these are equivalent: + /// + /// \code + /// // Within a grammar definition, these are equivalent: + /// when< plus<X, Y>, pass_through< plus<X, Y> > > + /// when< plus<X, Y>, plus<X, Y> > + /// when< plus<X, Y> > // because of when<class X, class Y=X> + /// plus<X, Y> // because plus<> is both a + /// // grammar and a transform + /// \endcode + /// + /// For example, consider the following transform that promotes all + /// \c float terminals in an expression to \c double. + /// + /// \code + /// // This transform finds all float terminals in an expression and promotes + /// // them to doubles. + /// struct Promote + /// : or_< + /// when<terminal<float>, terminal<double>::type(_value) > + /// // terminal<>'s default transform is a no-op: + /// , terminal<_> + /// // nary_expr<> has a pass_through<> transform: + /// , nary_expr<_, vararg<Promote> > + /// > + /// {}; + /// \endcode + template<typename Grammar, typename Domain /* = deduce_domain*/> + struct pass_through + : transform<pass_through<Grammar, Domain> > + { + template<typename Expr, typename State, typename Data> + struct impl + : detail::pass_through_impl<Grammar, Domain, Expr, State, Data> + {}; + }; + + /// INTERNAL ONLY + /// + template<typename Grammar, typename Domain> + struct is_callable<pass_through<Grammar, Domain> > + : mpl::true_ + {}; + +}} // namespace boost::proto + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/proto/transform/when.hpp b/3rdParty/Boost/src/boost/proto/transform/when.hpp new file mode 100644 index 0000000..d1defb8 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/when.hpp @@ -0,0 +1,267 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file when.hpp +/// Definition of when transform. +// +// 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_TRANSFORM_WHEN_HPP_EAN_10_29_2007 +#define BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007 + +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/mpl/at.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/map.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/transform/call.hpp> +#include <boost/proto/transform/make.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/proto/transform/env.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + namespace detail + { + template<typename Grammar, typename R, typename Fun> + struct when_impl + : transform<when<Grammar, Fun> > + { + typedef Grammar first; + typedef Fun second; + typedef typename Grammar::proto_grammar proto_grammar; + + // Note: do not evaluate is_callable<R> in this scope. + // R may be an incomplete type at this point. + + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + // OK to evaluate is_callable<R> here. R should be compete by now. + typedef + typename mpl::if_c< + is_callable<R>::value + , proto::call<Fun> // "R" is a function to call + , proto::make<Fun> // "R" is an object to construct + >::type + which; + + typedef typename which::template impl<Expr, State, Data>::result_type result_type; + + /// Evaluate <tt>R(A0,A1,...)</tt> as a transform either with + /// <tt>call\<\></tt> or with <tt>make\<\></tt> depending on + /// whether <tt>is_callable\<R\>::value</tt> is \c true or + /// \c false. + /// + /// \param e The current expression + /// \param s The current state + /// \param d An arbitrary data + /// \pre <tt>matches\<Expr, Grammar\>::value</tt> is \c true + /// \return <tt>which()(e, s, d)</tt> + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return typename which::template impl<Expr, State, Data>()(e, s, d); + } + }; + }; + } + + /// \brief A grammar element and a PrimitiveTransform that associates + /// a transform with the grammar. + /// + /// Use <tt>when\<\></tt> to override a grammar's default transform + /// with a custom transform. It is for used when composing larger + /// transforms by associating smaller transforms with individual + /// rules in your grammar, as in the following transform which + /// counts the number of terminals in an expression. + /// + /// \code + /// // Count the terminals in an expression tree. + /// // Must be invoked with initial state == mpl::int_<0>(). + /// struct CountLeaves + /// : or_< + /// when<terminal<_>, mpl::next<_state>()> + /// , otherwise<fold<_, _state, CountLeaves> > + /// > + /// {}; + /// \endcode + /// + /// In <tt>when\<G, T\></tt>, when \c T is a class type it is a + /// PrimitiveTransform and the following equivalencies hold: + /// + /// <tt>boost::result_of\<when\<G,T\>(E,S,V)\>::type</tt> is the same as + /// <tt>boost::result_of\<T(E,S,V)\>::type</tt>. + /// + /// <tt>when\<G,T\>()(e,s,d)</tt> is the same as + /// <tt>T()(e,s,d)</tt>. + template<typename Grammar, typename PrimitiveTransform /*= Grammar*/> + struct when + : PrimitiveTransform + { + typedef Grammar first; + typedef PrimitiveTransform second; + typedef typename Grammar::proto_grammar proto_grammar; + }; + + /// \brief A specialization that treats function pointer Transforms as + /// if they were function type Transforms. + /// + /// This specialization requires that \c Fun is actually a function type. + /// + /// This specialization is required for nested transforms such as + /// <tt>when\<G, T0(T1(_))\></tt>. In C++, functions that are used as + /// parameters to other functions automatically decay to funtion + /// pointer types. In other words, the type <tt>T0(T1(_))</tt> is + /// indistinguishable from <tt>T0(T1(*)(_))</tt>. This specialization + /// is required to handle these nested function pointer type transforms + /// properly. + template<typename Grammar, typename Fun> + struct when<Grammar, Fun *> + : when<Grammar, Fun> + {}; + + /// \brief Syntactic sugar for <tt>when\<_, Fun\></tt>, for use + /// in grammars to handle all the cases not yet handled. + /// + /// Use <tt>otherwise\<T\></tt> in your grammars as a synonym for + /// <tt>when\<_, T\></tt> as in the following transform which + /// counts the number of terminals in an expression. + /// + /// \code + /// // Count the terminals in an expression tree. + /// // Must be invoked with initial state == mpl::int_<0>(). + /// struct CountLeaves + /// : or_< + /// when<terminal<_>, mpl::next<_state>()> + /// , otherwise<fold<_, _state, CountLeaves> > + /// > + /// {}; + /// \endcode + template<typename Fun> + struct otherwise + : when<_, Fun> + {}; + + namespace envns_ + { + // Define the transforms global + BOOST_PROTO_DEFINE_ENV_VAR(transforms_type, transforms); + } + + using envns_::transforms; + + /// \brief This specialization uses the Data parameter as a collection + /// of transforms that can be indexed by the specified rule. + /// + /// Use <tt>when\<T, external_transform\></tt> in your code when you would like + /// to define a grammar once and use it to evaluate expressions with + /// many different sets of transforms. The transforms are found by + /// using the Data parameter as a map from rules to transforms. + /// + /// See \c action_map for an example. + template<typename Grammar> + struct when<Grammar, external_transform> + : proto::transform<when<Grammar, external_transform> > + { + typedef Grammar first; + typedef external_transform second; + typedef typename Grammar::proto_grammar proto_grammar; + + template<typename Expr, typename State, typename Data> + struct impl + : remove_reference< + typename mpl::eval_if_c< + proto::result_of::has_env_var<Data, transforms_type>::value + , proto::result_of::env_var<Data, transforms_type> + , proto::result_of::env_var<Data, data_type> + >::type + >::type::template when<Grammar>::template impl<Expr, State, Data> + {}; + }; + + /// \brief For defining a map of Rule/Transform pairs for use with + /// <tt>when\<T, external_transform\></tt> to make transforms external to the grammar + /// + /// The following code defines a grammar with a couple of external transforms. + /// It also defines an action_map that maps from rules to transforms. It then + /// passes that transforms map at the Data parameter to the grammar. In this way, + /// the behavior of the grammar can be modified post-hoc by passing a different + /// action_map. + /// + /// \code + /// struct int_terminal + /// : proto::terminal<int> + /// {}; + /// + /// struct char_terminal + /// : proto::terminal<char> + /// {}; + /// + /// struct my_grammar + /// : proto::or_< + /// proto::when< int_terminal, proto::external_transform > + /// , proto::when< char_terminal, proto::external_transform > + /// , proto::when< + /// proto::plus< my_grammar, my_grammar > + /// , proto::fold< _, int(), my_grammar > + /// > + /// > + /// {}; + /// + /// struct my_transforms + /// : proto::external_transforms< + /// proto::when<int_terminal, print(proto::_value)> + /// , proto::when<char_terminal, print(proto::_value)> + /// > + /// {}; + /// + /// proto::literal<int> i(1); + /// proto::literal<char> c('a'); + /// my_transforms trx; + /// + /// // Evaluate "i+c" using my_grammar with the specified transforms: + /// my_grammar()(i + c, 0, trx); + /// \endcode + template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_LIMIT_MAP_SIZE, typename T, mpl::na)> + struct external_transforms + { + typedef mpl::map<BOOST_PP_ENUM_PARAMS(BOOST_MPL_LIMIT_MAP_SIZE, T)> map_type; + + template<typename Rule> + struct when + : proto::when<_, typename mpl::at<map_type, Rule>::type> + {}; + }; + + // Other specializations of proto::when are generated by the preprocessor... + #include <boost/proto/transform/detail/when.hpp> + + /// INTERNAL ONLY + /// + template<typename Grammar, typename Transform> + struct is_callable<when<Grammar, Transform> > + : mpl::true_ + {}; + +}} // namespace boost::proto + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif |