Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/transform/detail/preprocessed')
12 files changed, 5126 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/call.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/call.hpp new file mode 100644 index 0000000..54575cc --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/call.hpp @@ -0,0 +1,424 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file call.hpp + /// Contains definition of the call<> transform. + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + + + template<typename Fun , typename A0> + struct call<Fun(A0...)> : transform<call<Fun(A0...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A0 + , detail::expand_pattern_rest_0< + Fun + + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1> + struct call<Fun(A0 , A1...)> : transform<call<Fun(A0 , A1...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A1 + , detail::expand_pattern_rest_1< + Fun + , A0 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2> + struct call<Fun(A0 , A1 , A2...)> : transform<call<Fun(A0 , A1 , A2...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A2 + , detail::expand_pattern_rest_2< + Fun + , A0 , A1 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3> + struct call<Fun(A0 , A1 , A2 , A3)> : transform<call<Fun(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3> + struct call<Fun(A0 , A1 , A2 , A3...)> : transform<call<Fun(A0 , A1 , A2 , A3...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A3 + , detail::expand_pattern_rest_3< + Fun + , A0 , A1 , A2 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct call<Fun(A0 , A1 , A2 , A3 , A4)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct call<Fun(A0 , A1 , A2 , A3 , A4...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A4 + , detail::expand_pattern_rest_4< + Fun + , A0 , A1 , A2 , A3 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A5 + , detail::expand_pattern_rest_5< + Fun + , A0 , A1 , A2 , A3 , A4 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A6 + , detail::expand_pattern_rest_6< + Fun + , A0 , A1 , A2 , A3 , A4 , A5 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A7 + , detail::expand_pattern_rest_7< + Fun + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A8 + , detail::expand_pattern_rest_8< + Fun + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; typedef typename when<_, A9>::template impl<Expr, State, Data> a9; typedef typename a9::result_type b9; + typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8 , b9)> function_traits; + typedef typename function_traits::result_type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + typedef typename function_traits::function_type function_type; + return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)) , detail::as_lvalue(a9()(e, s, d))); + } + }; + }; + + + + template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A9 + , detail::expand_pattern_rest_9< + Fun + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_funop.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_funop.hpp new file mode 100644 index 0000000..91ab92c --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_funop.hpp @@ -0,0 +1,67 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file construct_funop.hpp + /// Overloads of construct_\<\>::operator(). + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + template<typename A0> + BOOST_FORCEINLINE + Type operator ()(A0 &a0) const + { + return Type(a0); + } + template<typename A0 , typename A1> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1) const + { + return Type(a0 , a1); + } + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const + { + return Type(a0 , a1 , a2); + } + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const + { + return Type(a0 , a1 , a2 , a3); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const + { + return Type(a0 , a1 , a2 , a3 , a4); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const + { + return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp new file mode 100644 index 0000000..55b9df5 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp @@ -0,0 +1,77 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file construct_pod_funop.hpp + /// Overloads of construct_\<\>::operator(). + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + template<typename A0> + BOOST_FORCEINLINE + Type operator ()(A0 &a0) const + { + Type that = {a0}; + return that; + } + template<typename A0 , typename A1> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1) const + { + Type that = {a0 , a1}; + return that; + } + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const + { + Type that = {a0 , a1 , a2}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const + { + Type that = {a0 , a1 , a2 , a3}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const + { + Type that = {a0 , a1 , a2 , a3 , a4}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8}; + return that; + } + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const + { + Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9}; + return that; + } diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/default_function_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/default_function_impl.hpp new file mode 100644 index 0000000..72ff60e --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/default_function_impl.hpp @@ -0,0 +1,392 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file default_function_impl.hpp + /// Contains definition of the default_function_impl, the implementation of the + /// _default transform for function-like nodes. + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 3> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 4> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 5> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 6> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 7> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5 , r6) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 8> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 9> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d )); + } + }; + template<typename Grammar, typename Expr, typename State, typename Data> + struct default_function_impl<Grammar, Expr, State, Data, 10> + : transform_impl<Expr, State, Data> + { + typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; typedef typename result_of::child_c< Expr, 9>::type e9; typedef typename Grammar::template impl<e9, State, Data>::result_type r9; + typedef + typename proto::detail::result_of_fixup<r0>::type + function_type; + typedef + typename BOOST_PROTO_RESULT_OF< + function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8 , r9) + >::type + result_type; + result_type operator ()( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + ) const + { + return this->invoke(e, s, d, is_member_function_pointer<function_type>()); + } + private: + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::false_ + ) const + { + return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )( + typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d ) + ); + } + result_type invoke( + typename default_function_impl::expr_param e + , typename default_function_impl::state_param s + , typename default_function_impl::data_param d + , mpl::true_ + ) const + { + BOOST_PROTO_USE_GET_POINTER(); + typedef typename detail::class_member_traits<function_type>::class_type class_type; + return ( + BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* + typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d ) + )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d )); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/expand_pack.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/expand_pack.hpp new file mode 100644 index 0000000..8f758a3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/expand_pack.hpp @@ -0,0 +1,73 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file expand_pack.hpp + /// Contains helpers for pseudo-pack expansion. + // + // Copyright 2012 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + template<typename Tfx, typename Ret > + struct expand_pattern_helper<Tfx, Ret()> + { + typedef Ret (*type)(); + typedef mpl::bool_< false> applied; + }; + template<typename Tfx, typename Ret , typename A0> + struct expand_pattern_helper<Tfx, Ret(A0)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1> + struct expand_pattern_helper<Tfx, Ret(A0 , A1)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type , typename expand_pattern_helper<Tfx, A8>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || expand_pattern_helper<Tfx, A8>::applied::value || false> applied; + }; + template<typename Tfx, typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct expand_pattern_helper<Tfx, Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + { + typedef Ret (*type)(typename expand_pattern_helper<Tfx, A0>::type , typename expand_pattern_helper<Tfx, A1>::type , typename expand_pattern_helper<Tfx, A2>::type , typename expand_pattern_helper<Tfx, A3>::type , typename expand_pattern_helper<Tfx, A4>::type , typename expand_pattern_helper<Tfx, A5>::type , typename expand_pattern_helper<Tfx, A6>::type , typename expand_pattern_helper<Tfx, A7>::type , typename expand_pattern_helper<Tfx, A8>::type , typename expand_pattern_helper<Tfx, A9>::type); + typedef mpl::bool_<expand_pattern_helper<Tfx, A0>::applied::value || expand_pattern_helper<Tfx, A1>::applied::value || expand_pattern_helper<Tfx, A2>::applied::value || expand_pattern_helper<Tfx, A3>::applied::value || expand_pattern_helper<Tfx, A4>::applied::value || expand_pattern_helper<Tfx, A5>::applied::value || expand_pattern_helper<Tfx, A6>::applied::value || expand_pattern_helper<Tfx, A7>::applied::value || expand_pattern_helper<Tfx, A8>::applied::value || expand_pattern_helper<Tfx, A9>::applied::value || false> applied; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/fold_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/fold_impl.hpp new file mode 100644 index 0000000..f365166 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/fold_impl.hpp @@ -0,0 +1,387 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file fold_impl.hpp + /// Contains definition of fold_impl<> and reverse_fold_impl<> templates. + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 1> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; + typedef state1 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); + return s1; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 1> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state1; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state1 s1 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 2> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; + typedef state2 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); + return s2; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 2> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state2; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state2 s2 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 3> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; + typedef state3 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); + return s3; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 3> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state3; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state3 s3 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 4> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; + typedef state4 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); + return s4; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 4> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state4; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state4 s4 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 5> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; + typedef state5 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); + return s5; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 5> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state5; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state5 s5 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 6> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; + typedef state6 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); + return s6; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 6> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state6; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state6 s6 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 7> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; + typedef state7 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); + return s7; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 7> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state7; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state7 s7 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 8> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; + typedef state8 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); + return s8; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 8> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state8; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state8 s8 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 9> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; + typedef state9 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); + return s9; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 9> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state9; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state9 s9 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct fold_impl<State0, Fun, Expr, State, Data, 10> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0; + typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >::result_type state10; + typedef state10 result_type; + result_type operator ()( + typename fold_impl::expr_param e + , typename fold_impl::state_param s + , typename fold_impl::data_param d + ) const + { + state0 s0 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); state10 s10 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >()( proto::child_c< 9>(e) , s9 , d ); + return s10; + } + }; + template<typename State0, typename Fun, typename Expr, typename State, typename Data> + struct reverse_fold_impl<State0, Fun, Expr, State, Data, 10> + : transform_impl<Expr, State, Data> + { + typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state10; + typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0; + typedef state0 result_type; + result_type operator ()( + typename reverse_fold_impl::expr_param e + , typename reverse_fold_impl::state_param s + , typename reverse_fold_impl::data_param d + ) const + { + state10 s10 = + typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d); + state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >()( proto::child_c<9>(e) , s10 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d ); + return s0; + } + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/lazy.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/lazy.hpp new file mode 100644 index 0000000..c32d20f --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/lazy.hpp @@ -0,0 +1,407 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file lazy.hpp + /// Contains definition of the lazy<> transform. + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + + + + + + + + template<typename Object > + struct lazy<Object()> + : transform<lazy<Object()> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + () + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0> + struct lazy<Object(A0)> + : transform<lazy<Object(A0)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0> + struct lazy<Object(A0...)> + : transform<lazy<Object(A0...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A0 + , detail::expand_pattern_rest_0< + Object + + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1> + struct lazy<Object(A0 , A1)> + : transform<lazy<Object(A0 , A1)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1> + struct lazy<Object(A0 , A1...)> + : transform<lazy<Object(A0 , A1...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A1 + , detail::expand_pattern_rest_1< + Object + , A0 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2> + struct lazy<Object(A0 , A1 , A2)> + : transform<lazy<Object(A0 , A1 , A2)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2> + struct lazy<Object(A0 , A1 , A2...)> + : transform<lazy<Object(A0 , A1 , A2...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A2 + , detail::expand_pattern_rest_2< + Object + , A0 , A1 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> + struct lazy<Object(A0 , A1 , A2 , A3)> + : transform<lazy<Object(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> + struct lazy<Object(A0 , A1 , A2 , A3...)> + : transform<lazy<Object(A0 , A1 , A2 , A3...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A3 + , detail::expand_pattern_rest_3< + Object + , A0 , A1 , A2 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct lazy<Object(A0 , A1 , A2 , A3 , A4)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct lazy<Object(A0 , A1 , A2 , A3 , A4...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A4 + , detail::expand_pattern_rest_4< + Object + , A0 , A1 , A2 , A3 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A5 + , detail::expand_pattern_rest_5< + Object + , A0 , A1 , A2 , A3 , A4 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5 , A6) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A6 + , detail::expand_pattern_rest_6< + Object + , A0 , A1 , A2 , A3 , A4 , A5 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A7 + , detail::expand_pattern_rest_7< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A8 + , detail::expand_pattern_rest_8< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + + + + + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : call< + typename make<Object>::template impl<Expr, State, Data>::result_type + (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) + >::template impl<Expr, State, Data> + {}; + }; + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> + : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : lazy< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A9 + , detail::expand_pattern_rest_9< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make.hpp new file mode 100644 index 0000000..e581127 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make.hpp @@ -0,0 +1,1320 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file make.hpp + /// Contains definition of the make<> transform. + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + namespace detail + { + template<typename R > + struct is_applyable<R()> + : mpl::true_ + {}; + template<typename R > + struct is_applyable<R(*)()> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 0>, true> + { + typedef proto::expr<T, A, 0> result_type; + template<typename A0> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0) const + { + return result_type::make(a0); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 0>, true> + { + typedef proto::basic_expr<T, A, 0> result_type; + template<typename A0> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0) const + { + return result_type::make(a0); + } + }; + template<typename Type > + BOOST_FORCEINLINE + Type construct() + { + return construct_<Type>()(); + } + } + + + + + template<typename Object > + struct make<Object()> + : transform<make<Object()> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(); + } + }; + }; + namespace detail + { + template< + template<typename> class R + , typename A0 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename> class R + , typename A0 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0> + struct is_applyable<R(A0)> + : mpl::true_ + {}; + template<typename R , typename A0> + struct is_applyable<R(*)(A0)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 1>, true> + { + typedef proto::expr<T, A, 1> result_type; + template<typename A0> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0) const + { + return result_type::make(a0); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 1>, true> + { + typedef proto::basic_expr<T, A, 1> result_type; + template<typename A0> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0) const + { + return result_type::make(a0); + } + }; + template<typename Type , typename A0> + BOOST_FORCEINLINE + Type construct(A0 &a0) + { + return construct_<Type>()(a0); + } + } + + + + + template<typename Object , typename A0> + struct make<Object(A0)> + : transform<make<Object(A0)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0> + struct make<Object(A0...)> + : transform<make<Object(A0...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A0 + , detail::expand_pattern_rest_0< + Object + + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename> class R + , typename A0 , typename A1 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(2) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename> class R + , typename A0 , typename A1 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1> + struct is_applyable<R(A0 , A1)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1> + struct is_applyable<R(*)(A0 , A1)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 2>, true> + { + typedef proto::expr<T, A, 2> result_type; + template<typename A0 , typename A1> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1) const + { + return result_type::make(a0 , a1); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 2>, true> + { + typedef proto::basic_expr<T, A, 2> result_type; + template<typename A0 , typename A1> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1) const + { + return result_type::make(a0 , a1); + } + }; + template<typename Type , typename A0 , typename A1> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1) + { + return construct_<Type>()(a0 , a1); + } + } + + + + + template<typename Object , typename A0 , typename A1> + struct make<Object(A0 , A1)> + : transform<make<Object(A0 , A1)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1> + struct make<Object(A0 , A1...)> + : transform<make<Object(A0 , A1...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A1 + , detail::expand_pattern_rest_1< + Object + , A0 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(3) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2> + struct is_applyable<R(A0 , A1 , A2)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2> + struct is_applyable<R(*)(A0 , A1 , A2)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 3>, true> + { + typedef proto::expr<T, A, 3> result_type; + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const + { + return result_type::make(a0 , a1 , a2); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 3>, true> + { + typedef proto::basic_expr<T, A, 3> result_type; + template<typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const + { + return result_type::make(a0 , a1 , a2); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2) + { + return construct_<Type>()(a0 , a1 , a2); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2> + struct make<Object(A0 , A1 , A2)> + : transform<make<Object(A0 , A1 , A2)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2> + struct make<Object(A0 , A1 , A2...)> + : transform<make<Object(A0 , A1 , A2...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A2 + , detail::expand_pattern_rest_2< + Object + , A0 , A1 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(4) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3> + struct is_applyable<R(A0 , A1 , A2 , A3)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3> + struct is_applyable<R(*)(A0 , A1 , A2 , A3)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 4>, true> + { + typedef proto::expr<T, A, 4> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const + { + return result_type::make(a0 , a1 , a2 , a3); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 4>, true> + { + typedef proto::basic_expr<T, A, 4> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const + { + return result_type::make(a0 , a1 , a2 , a3); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) + { + return construct_<Type>()(a0 , a1 , a2 , a3); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> + struct make<Object(A0 , A1 , A2 , A3)> + : transform<make<Object(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3> + struct make<Object(A0 , A1 , A2 , A3...)> + : transform<make<Object(A0 , A1 , A2 , A3...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A3 + , detail::expand_pattern_rest_3< + Object + , A0 , A1 , A2 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(5) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 5>, true> + { + typedef proto::expr<T, A, 5> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 5>, true> + { + typedef proto::basic_expr<T, A, 5> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make<Object(A0 , A1 , A2 , A3 , A4)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make<Object(A0 , A1 , A2 , A3 , A4...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A4 + , detail::expand_pattern_rest_4< + Object + , A0 , A1 , A2 , A3 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(6) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 6>, true> + { + typedef proto::expr<T, A, 6> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 6>, true> + { + typedef proto::basic_expr<T, A, 6> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A5 + , detail::expand_pattern_rest_5< + Object + , A0 , A1 , A2 , A3 , A4 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5 , A6> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(7) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 7>, true> + { + typedef proto::expr<T, A, 7> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 7>, true> + { + typedef proto::basic_expr<T, A, 7> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A6 + , detail::expand_pattern_rest_6< + Object + , A0 , A1 , A2 , A3 , A4 , A5 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(8) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 8>, true> + { + typedef proto::expr<T, A, 8> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 8>, true> + { + typedef proto::basic_expr<T, A, 8> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A7 + , detail::expand_pattern_rest_7< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(9) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 9>, true> + { + typedef proto::expr<T, A, 9> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 9>, true> + { + typedef proto::basic_expr<T, A, 9> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A8 + , detail::expand_pattern_rest_8< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; + namespace detail + { + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 + , typename Expr, typename State, typename Data + > + struct make_< + R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(10) + > + : nested_type_if< + R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> + , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || make_if_<A9, Expr, State, Data> ::applied || false) + > + {}; + template< + template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R + , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 + , typename Expr, typename State, typename Data + > + struct make_< + noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> > + , Expr, State, Data + BOOST_PROTO_TEMPLATE_ARITY_PARAM(1) + > + { + typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> type; + static bool const applied = true; + }; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : mpl::true_ + {}; + template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : mpl::true_ + {}; + template<typename T, typename A> + struct construct_<proto::expr<T, A, 10>, true> + { + typedef proto::expr<T, A, 10> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } + }; + template<typename T, typename A> + struct construct_<proto::basic_expr<T, A, 10>, true> + { + typedef proto::basic_expr<T, A, 10> result_type; + template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const + { + return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } + }; + template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + BOOST_FORCEINLINE + Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) + { + return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9); + } + } + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + + typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type; + + + + + + + + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + proto::detail::ignore_unused(e); + proto::detail::ignore_unused(s); + proto::detail::ignore_unused(d); + return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) )); + } + }; + }; + + + + + template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> + : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> > + { + template<typename Expr, typename State, typename Data> + struct impl + : make< + typename detail::expand_pattern< + proto::arity_of<Expr>::value + , A9 + , detail::expand_pattern_rest_9< + Object + , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 + > + >::type + >::template impl<Expr, State, Data> + {}; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp new file mode 100644 index 0000000..a053c50 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp @@ -0,0 +1,481 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file make_gcc_workaround.hpp + /// Special workaround code to make the make\<\> transform work on certain + /// versions of gcc. + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + template<typename Tag, typename Args, long Arity > + struct make<proto::expr<Tag, Args, Arity>()> + : transform<make<proto::expr<Tag, Args, Arity>()> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + + ); + } + }; + }; + template<typename Tag, typename Args, long Arity > + struct make<proto::basic_expr<Tag, Args, Arity>()> + : transform<make<proto::basic_expr<Tag, Args, Arity>()> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0> + struct make<proto::expr<Tag, Args, Arity>(A0)> + : transform<make<proto::expr<Tag, Args, Arity>(A0)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0> + struct make<proto::basic_expr<Tag, Args, Arity>(A0)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; + template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef proto::basic_expr<Tag, Args, Arity> result_type; + BOOST_FORCEINLINE + result_type operator ()( + typename impl::expr_param e + , typename impl::state_param s + , typename impl::data_param d + ) const + { + return proto::basic_expr<Tag, Args, Arity>::make( + detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ) + ); + } + }; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pack_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pack_impl.hpp new file mode 100644 index 0000000..802bb6a --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pack_impl.hpp @@ -0,0 +1,442 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file pack_impl.hpp + /// Contains helpers for pseudo-pack expansion. + // + // Copyright 2012 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + template<typename Fun, typename Cont> + struct expand_pattern<1, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret > + struct expand_pattern_rest_0 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void , typename C9 = void , typename C10 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret( C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret( C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9> + { + typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<2, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0> + struct expand_pattern_rest_1 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void , typename C9 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8> + { + typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<3, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1> + struct expand_pattern_rest_2 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<4, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2> + struct expand_pattern_rest_3 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> + struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<5, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3> + struct expand_pattern_rest_4 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> + struct cat<C0 , C1 , C2 , C3 , C4 , C5> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4 , C5)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<6, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct expand_pattern_rest_5 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> + struct cat<C0 , C1 , C2 , C3 , C4> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3 , C4)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<7, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct expand_pattern_rest_6 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2)> type; + }; + template<typename C0 , typename C1 , typename C2 , typename C3> + struct cat<C0 , C1 , C2 , C3> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2 , C3)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<8, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct expand_pattern_rest_7 + { + template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1)> type; + }; + template<typename C0 , typename C1 , typename C2> + struct cat<C0 , C1 , C2> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1 , C2)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<9, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct expand_pattern_rest_8 + { + template<typename C0 = void , typename C1 = void , typename C2 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0)> type; + }; + template<typename C0 , typename C1> + struct cat<C0 , C1> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0 , C1)> type; + }; + }; + template<typename Fun, typename Cont> + struct expand_pattern<10, Fun, Cont> + : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 9>, Fun>::type> + { + BOOST_MPL_ASSERT_MSG( + (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) + , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN + , (Fun) + ); + }; + template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct expand_pattern_rest_9 + { + template<typename C0 = void , typename C1 = void> + struct cat; + template<typename C0> + struct cat<C0> + { + typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , C0)> type; + }; + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pass_through_impl.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pass_through_impl.hpp new file mode 100644 index 0000000..401b200 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/pass_through_impl.hpp @@ -0,0 +1,419 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file pass_through_impl.hpp + /// + /// Specializations of pass_through_impl, used in the implementation of the + /// pass_through transform. + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 1> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list1< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 2> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list2< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 3> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list3< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 4> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list4< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 5> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list5< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 6> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list6< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 7> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list7< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 8> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list8< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 9> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list9< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; + template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> + struct pass_through_impl<Grammar, Domain, Expr, State, Data, 10> + : transform_impl<Expr, State, Data> + { + typedef typename pass_through_impl::expr unref_expr; + typedef + typename mpl::if_c< + is_same<Domain, deduce_domain>::value + , typename unref_expr::proto_domain + , Domain + >::type + result_domain; + typedef + typename base_expr< + result_domain + , typename unref_expr::proto_tag + , list10< + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >::result_type + > + >::type + expr_type; + typedef typename result_domain::proto_generator proto_generator; + typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type; + BOOST_FORCEINLINE + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const) + operator ()( + typename pass_through_impl::expr_param e + , typename pass_through_impl::state_param s + , typename pass_through_impl::data_param d + ) const + { + expr_type const that = { + typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d ) , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >()( e.proto_base().child9, s, d ) + }; + + + + detail::ignore_unused(&that); + return proto_generator()(that); + } + }; diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/when.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/when.hpp new file mode 100644 index 0000000..9f5acc9 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/detail/preprocessed/when.hpp @@ -0,0 +1,637 @@ + /////////////////////////////////////////////////////////////////////////////// + /// \file when.hpp + /// Definition of when transform. + // + // Copyright 2008 Eric Niebler. Distributed under the Boost + // Software License, Version 1.0. (See accompanying file + // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R > + struct when<Grammar, R()> + : detail::when_impl<Grammar, R, R()> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0> + struct when<Grammar, R(A0)> + : detail::when_impl<Grammar, R, R(A0)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0> + struct when<Grammar, R(A0...)> + : detail::when_impl<Grammar, R, R(A0...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1> + struct when<Grammar, R(A0 , A1)> + : detail::when_impl<Grammar, R, R(A0 , A1)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1> + struct when<Grammar, R(A0 , A1...)> + : detail::when_impl<Grammar, R, R(A0 , A1...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2> + struct when<Grammar, R(A0 , A1 , A2)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2> + struct when<Grammar, R(A0 , A1 , A2...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3> + struct when<Grammar, R(A0 , A1 , A2 , A3)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3> + struct when<Grammar, R(A0 , A1 , A2 , A3...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> + {}; + + + + + + + + + + + + + + + + + + + + + + + + + + + template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9> + struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> + : detail::when_impl<Grammar, R, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> + {}; |