add boost on mac
This commit is contained in:
Bassem Girgis
@@ -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>
|
||||
{};
|
||||
};
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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 ));
|
||||
}
|
||||
};
|
||||
@@ -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;
|
||||
};
|
||||
@@ -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;
|
||||
}
|
||||
};
|
||||
@@ -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>
|
||||
{};
|
||||
};
|
||||
1320
macx64/include/boost/proto/transform/detail/preprocessed/make.hpp
Normal file
1320
macx64/include/boost/proto/transform/detail/preprocessed/make.hpp
Normal file
File diff suppressed because it is too large
Load Diff
@@ -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) )
|
||||
);
|
||||
}
|
||||
};
|
||||
};
|
||||
@@ -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;
|
||||
};
|
||||
};
|
||||
@@ -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);
|
||||
}
|
||||
};
|
||||
@@ -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...)>
|
||||
{};
|
||||
Reference in New Issue
Block a user