Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/detail/preprocessed')
25 files changed, 12837 insertions, 0 deletions
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 + > + {}; |