Swiftdiff options
| author | Kevin Smith <git@kismith.co.uk> | 2013-01-12 18:41:34 (GMT) |
|---|---|---|
| committer | Swift Review <review@swift.im> | 2013-01-13 10:36:26 (GMT) |
| commit | f3bc816af1b0d61452de973963e453bf3b3f95a2 (patch) | |
| tree | e895f8afa3580e6cff6f5ad2017d45bf147a17c2 /3rdParty/Boost/src/boost/proto/detail | |
| parent | 188fc285c6555eadd3c9d50ab8a94adcade78d89 (diff) | |
| download | swift-f3bc816af1b0d61452de973963e453bf3b3f95a2.zip swift-f3bc816af1b0d61452de973963e453bf3b3f95a2.tar.bz2 | |
Adding in the spirit Boost stuff
Change-Id: I4f127ce61667243b64081b0aa309028d5077045f
Diffstat (limited to '3rdParty/Boost/src/boost/proto/detail')
63 files changed, 17123 insertions, 0 deletions
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 |