// Boost Lambda Library lambda_functor_base.hpp ----------------------------- | |
// | |
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) | |
// | |
// Distributed under the Boost Software License, Version 1.0. (See | |
// accompanying file LICENSE_1_0.txt or copy at | |
// http://www.boost.org/LICENSE_1_0.txt) | |
// | |
// For more information, see www.boost.org | |
// ------------------------------------------------------------ | |
#ifndef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP | |
#define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP | |
#include "boost/type_traits/add_reference.hpp" | |
#include "boost/type_traits/add_const.hpp" | |
#include "boost/type_traits/remove_const.hpp" | |
#include "boost/lambda/detail/lambda_fwd.hpp" | |
#include "boost/lambda/detail/lambda_traits.hpp" | |
namespace boost { | |
namespace lambda { | |
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) | |
#pragma warning(push) | |
#pragma warning(disable:4512) //assignment operator could not be generated | |
#endif | |
// for return type deductions we wrap bound argument to this class, | |
// which fulfils the base class contract for lambda_functors | |
template <class T> | |
class identity { | |
T elem; | |
public: | |
typedef T element_t; | |
// take all parameters as const references. Note that non-const references | |
// stay as they are. | |
typedef typename boost::add_reference< | |
typename boost::add_const<T>::type | |
>::type par_t; | |
explicit identity(par_t t) : elem(t) {} | |
template <typename SigArgs> | |
struct sig { typedef typename boost::remove_const<element_t>::type type; }; | |
template<class RET, CALL_TEMPLATE_ARGS> | |
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return elem; } | |
}; | |
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) | |
#pragma warning(pop) | |
#endif | |
template <class T> | |
inline lambda_functor<identity<T&> > var(T& t) { return identity<T&>(t); } | |
// for lambda functors, var is an identity operator. It was forbidden | |
// at some point, but we might want to var something that can be a | |
// non-lambda functor or a lambda functor. | |
template <class T> | |
lambda_functor<T> var(const lambda_functor<T>& t) { return t; } | |
template <class T> struct var_type { | |
typedef lambda_functor<identity<T&> > type; | |
}; | |
template <class T> | |
inline | |
lambda_functor<identity<typename bound_argument_conversion<const T>::type> > | |
constant(const T& t) { | |
return identity<typename bound_argument_conversion<const T>::type>(t); | |
} | |
template <class T> | |
lambda_functor<T> constant(const lambda_functor<T>& t) { return t; } | |
template <class T> struct constant_type { | |
typedef | |
lambda_functor< | |
identity<typename bound_argument_conversion<const T>::type> | |
> type; | |
}; | |
template <class T> | |
inline lambda_functor<identity<const T&> > constant_ref(const T& t) { | |
return identity<const T&>(t); | |
} | |
template <class T> | |
lambda_functor<T> constant_ref(const lambda_functor<T>& t) { return t; } | |
template <class T> struct constant_ref_type { | |
typedef | |
lambda_functor<identity<const T&> > type; | |
}; | |
// as_lambda_functor turns any types to lambda functors | |
// non-lambda_functors will be bound argument types | |
template <class T> | |
struct as_lambda_functor { | |
typedef typename | |
detail::remove_reference_and_cv<T>::type plain_T; | |
typedef typename | |
detail::IF<is_lambda_functor<plain_T>::value, | |
plain_T, | |
lambda_functor< | |
identity<typename bound_argument_conversion<T>::type> | |
> | |
>::RET type; | |
}; | |
// turns arbitrary objects into lambda functors | |
template <class T> | |
inline | |
lambda_functor<identity<typename bound_argument_conversion<const T>::type> > | |
to_lambda_functor(const T& t) { | |
return identity<typename bound_argument_conversion<const T>::type>(t); | |
} | |
template <class T> | |
inline lambda_functor<T> | |
to_lambda_functor(const lambda_functor<T>& t) { | |
return t; | |
} | |
namespace detail { | |
// In a call constify_rvals<T>::go(x) | |
// x should be of type T. If T is a non-reference type, do | |
// returns x as const reference. | |
// Otherwise the type doesn't change. | |
// The purpose of this class is to avoid | |
// 'cannot bind temporaries to non-const references' errors. | |
template <class T> struct constify_rvals { | |
template<class U> | |
static inline const U& go(const U& u) { return u; } | |
}; | |
template <class T> struct constify_rvals<T&> { | |
template<class U> | |
static inline U& go(U& u) { return u; } | |
}; | |
// check whether one of the elements of a tuple (cons list) is of type | |
// null_type. Needed, because the compiler goes ahead and instantiates | |
// sig template for nullary case even if the nullary operator() is not | |
// called | |
template <class T> struct is_null_type | |
{ BOOST_STATIC_CONSTANT(bool, value = false); }; | |
template <> struct is_null_type<null_type> | |
{ BOOST_STATIC_CONSTANT(bool, value = true); }; | |
template<class Tuple> struct has_null_type { | |
BOOST_STATIC_CONSTANT(bool, value = (is_null_type<typename Tuple::head_type>::value || has_null_type<typename Tuple::tail_type>::value)); | |
}; | |
template<> struct has_null_type<null_type> { | |
BOOST_STATIC_CONSTANT(bool, value = false); | |
}; | |
// helpers ------------------- | |
template<class Args, class SigArgs> | |
class deduce_argument_types_ { | |
typedef typename as_lambda_functor<typename Args::head_type>::type lf_t; | |
typedef typename lf_t::inherited::template sig<SigArgs>::type el_t; | |
public: | |
typedef | |
boost::tuples::cons< | |
el_t, | |
typename deduce_argument_types_<typename Args::tail_type, SigArgs>::type | |
> type; | |
}; | |
template<class SigArgs> | |
class deduce_argument_types_<null_type, SigArgs> { | |
public: | |
typedef null_type type; | |
}; | |
// // note that tuples cannot have plain function types as elements. | |
// // Hence, all other types will be non-const, except references to | |
// // functions. | |
// template <class T> struct remove_reference_except_from_functions { | |
// typedef typename boost::remove_reference<T>::type t; | |
// typedef typename detail::IF<boost::is_function<t>::value, T, t>::RET type; | |
// }; | |
template<class Args, class SigArgs> | |
class deduce_non_ref_argument_types_ { | |
typedef typename as_lambda_functor<typename Args::head_type>::type lf_t; | |
typedef typename lf_t::inherited::template sig<SigArgs>::type el_t; | |
public: | |
typedef | |
boost::tuples::cons< | |
// typename detail::remove_reference_except_from_functions<el_t>::type, | |
typename boost::remove_reference<el_t>::type, | |
typename deduce_non_ref_argument_types_<typename Args::tail_type, SigArgs>::type | |
> type; | |
}; | |
template<class SigArgs> | |
class deduce_non_ref_argument_types_<null_type, SigArgs> { | |
public: | |
typedef null_type type; | |
}; | |
// ------------- | |
// take stored Args and Open Args, and return a const list with | |
// deduced elements (real return types) | |
template<class Args, class SigArgs> | |
class deduce_argument_types { | |
typedef typename deduce_argument_types_<Args, SigArgs>::type t1; | |
public: | |
typedef typename detail::IF< | |
has_null_type<t1>::value, null_type, t1 | |
>::RET type; | |
}; | |
// take stored Args and Open Args, and return a const list with | |
// deduced elements (references are stripped from the element types) | |
template<class Args, class SigArgs> | |
class deduce_non_ref_argument_types { | |
typedef typename deduce_non_ref_argument_types_<Args, SigArgs>::type t1; | |
public: | |
typedef typename detail::IF< | |
has_null_type<t1>::value, null_type, t1 | |
>::RET type; | |
}; | |
template <int N, class Args, class SigArgs> | |
struct nth_return_type_sig { | |
typedef typename | |
as_lambda_functor< | |
typename boost::tuples::element<N, Args>::type | |
// typename tuple_element_as_reference<N, Args>::type | |
>::type lf_type; | |
typedef typename lf_type::inherited::template sig<SigArgs>::type type; | |
}; | |
template<int N, class Tuple> struct element_or_null { | |
typedef typename boost::tuples::element<N, Tuple>::type type; | |
}; | |
template<int N> struct element_or_null<N, null_type> { | |
typedef null_type type; | |
}; | |
} // end detail | |
// -- lambda_functor base --------------------- | |
// the explicit_return_type_action case ----------------------------------- | |
template<class RET, class Args> | |
class lambda_functor_base<explicit_return_type_action<RET>, Args> | |
{ | |
public: | |
Args args; | |
typedef RET result_type; | |
explicit lambda_functor_base(const Args& a) : args(a) {} | |
template <class SigArgs> struct sig { typedef RET type; }; | |
template<class RET_, CALL_TEMPLATE_ARGS> | |
RET call(CALL_FORMAL_ARGS) const | |
{ | |
return detail::constify_rvals<RET>::go( | |
detail::r_select<RET>::go(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)); | |
} | |
}; | |
// the protect_action case ----------------------------------- | |
template<class Args> | |
class lambda_functor_base<protect_action, Args> | |
{ | |
public: | |
Args args; | |
public: | |
explicit lambda_functor_base(const Args& a) : args(a) {} | |
template<class RET, CALL_TEMPLATE_ARGS> | |
RET call(CALL_FORMAL_ARGS) const | |
{ | |
CALL_USE_ARGS; | |
return boost::tuples::get<0>(args); | |
} | |
template<class SigArgs> struct sig { | |
// typedef typename detail::tuple_element_as_reference<0, SigArgs>::type type; | |
typedef typename boost::tuples::element<0, Args>::type type; | |
}; | |
}; | |
// Do nothing -------------------------------------------------------- | |
class do_nothing_action {}; | |
template<class Args> | |
class lambda_functor_base<do_nothing_action, Args> { | |
// Args args; | |
public: | |
// explicit lambda_functor_base(const Args& a) {} | |
lambda_functor_base() {} | |
template<class RET, CALL_TEMPLATE_ARGS> RET call(CALL_FORMAL_ARGS) const { | |
return CALL_USE_ARGS; | |
} | |
template<class SigArgs> struct sig { typedef void type; }; | |
}; | |
// These specializations provide a shorter notation to define actions. | |
// These lambda_functor_base instances take care of the recursive evaluation | |
// of the arguments and pass the evaluated arguments to the apply function | |
// of an action class. To make action X work with these classes, one must | |
// instantiate the lambda_functor_base as: | |
// lambda_functor_base<action<ARITY, X>, Args> | |
// Where ARITY is the arity of the apply function in X | |
// The return type is queried as: | |
// return_type_N<X, EvaluatedArgumentTypes>::type | |
// for which there must be a specialization. | |
// Function actions, casts, throws,... all go via these classes. | |
template<class Act, class Args> | |
class lambda_functor_base<action<0, Act>, Args> | |
{ | |
public: | |
// Args args; not needed | |
explicit lambda_functor_base(const Args& /*a*/) {} | |
template<class SigArgs> struct sig { | |
typedef typename return_type_N<Act, null_type>::type type; | |
}; | |
template<class RET, CALL_TEMPLATE_ARGS> | |
RET call(CALL_FORMAL_ARGS) const { | |
CALL_USE_ARGS; | |
return Act::template apply<RET>(); | |
} | |
}; | |
#if defined BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART | |
#error "Multiple defines of BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART" | |
#endif | |
#define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(ARITY) \ | |
template<class Act, class Args> \ | |
class lambda_functor_base<action<ARITY, Act>, Args> \ | |
{ \ | |
public: \ | |
Args args; \ | |
\ | |
explicit lambda_functor_base(const Args& a) : args(a) {} \ | |
\ | |
template<class SigArgs> struct sig { \ | |
typedef typename \ | |
detail::deduce_argument_types<Args, SigArgs>::type rets_t; \ | |
public: \ | |
typedef typename \ | |
return_type_N_prot<Act, rets_t>::type type; \ | |
}; \ | |
\ | |
\ | |
template<class RET, CALL_TEMPLATE_ARGS> \ | |
RET call(CALL_FORMAL_ARGS) const { \ | |
using boost::tuples::get; \ | |
using detail::constify_rvals; \ | |
using detail::r_select; \ | |
using detail::element_or_null; \ | |
using detail::deduce_argument_types; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(1) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(2) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(3) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
typedef typename element_or_null<2, rets_t>::type rt2; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(4) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
typedef typename element_or_null<2, rets_t>::type rt2; | |
typedef typename element_or_null<3, rets_t>::type rt3; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(5) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
typedef typename element_or_null<2, rets_t>::type rt2; | |
typedef typename element_or_null<3, rets_t>::type rt3; | |
typedef typename element_or_null<4, rets_t>::type rt4; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(6) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
typedef typename element_or_null<2, rets_t>::type rt2; | |
typedef typename element_or_null<3, rets_t>::type rt3; | |
typedef typename element_or_null<4, rets_t>::type rt4; | |
typedef typename element_or_null<5, rets_t>::type rt5; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(7) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
typedef typename element_or_null<2, rets_t>::type rt2; | |
typedef typename element_or_null<3, rets_t>::type rt3; | |
typedef typename element_or_null<4, rets_t>::type rt4; | |
typedef typename element_or_null<5, rets_t>::type rt5; | |
typedef typename element_or_null<6, rets_t>::type rt6; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(8) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
typedef typename element_or_null<2, rets_t>::type rt2; | |
typedef typename element_or_null<3, rets_t>::type rt3; | |
typedef typename element_or_null<4, rets_t>::type rt4; | |
typedef typename element_or_null<5, rets_t>::type rt5; | |
typedef typename element_or_null<6, rets_t>::type rt6; | |
typedef typename element_or_null<7, rets_t>::type rt7; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(9) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
typedef typename element_or_null<2, rets_t>::type rt2; | |
typedef typename element_or_null<3, rets_t>::type rt3; | |
typedef typename element_or_null<4, rets_t>::type rt4; | |
typedef typename element_or_null<5, rets_t>::type rt5; | |
typedef typename element_or_null<6, rets_t>::type rt6; | |
typedef typename element_or_null<7, rets_t>::type rt7; | |
typedef typename element_or_null<8, rets_t>::type rt8; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt8>::go(r_select<rt8>::go(get<8>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(10) | |
typedef typename | |
deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; | |
typedef typename element_or_null<0, rets_t>::type rt0; | |
typedef typename element_or_null<1, rets_t>::type rt1; | |
typedef typename element_or_null<2, rets_t>::type rt2; | |
typedef typename element_or_null<3, rets_t>::type rt3; | |
typedef typename element_or_null<4, rets_t>::type rt4; | |
typedef typename element_or_null<5, rets_t>::type rt5; | |
typedef typename element_or_null<6, rets_t>::type rt6; | |
typedef typename element_or_null<7, rets_t>::type rt7; | |
typedef typename element_or_null<8, rets_t>::type rt8; | |
typedef typename element_or_null<9, rets_t>::type rt9; | |
return Act::template apply<RET>( | |
constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt8>::go(r_select<rt8>::go(get<8>(args), CALL_ACTUAL_ARGS)), | |
constify_rvals<rt9>::go(r_select<rt9>::go(get<9>(args), CALL_ACTUAL_ARGS)) | |
); | |
} | |
}; | |
#undef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART | |
} // namespace lambda | |
} // namespace boost | |
#endif |