175 lines
5.6 KiB
Plaintext
175 lines
5.6 KiB
Plaintext
// -- Boost Lambda Library - actions.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_ACTIONS_HPP
|
|
#define BOOST_LAMBDA_ACTIONS_HPP
|
|
|
|
namespace boost {
|
|
namespace lambda {
|
|
|
|
|
|
|
|
template<int Arity, class Act> class action;
|
|
|
|
// these need to be defined here, since the corresponding lambda
|
|
// functions are members of lambda_functor classes
|
|
|
|
class assignment_action {};
|
|
class subscript_action {};
|
|
|
|
template <class Action> class other_action;
|
|
|
|
// action for specifying the explicit return type
|
|
template <class RET> class explicit_return_type_action {};
|
|
|
|
// action for preventing the expansion of a lambda expression
|
|
struct protect_action {};
|
|
|
|
// must be defined here, comma is a special case
|
|
struct comma_action {};
|
|
|
|
|
|
// actions, for which the existence of protect is checked in return type
|
|
// deduction.
|
|
|
|
template <class Action> struct is_protectable {
|
|
BOOST_STATIC_CONSTANT(bool, value = false);
|
|
};
|
|
|
|
// NOTE: comma action is protectable. Other protectable actions
|
|
// are listed in operator_actions.hpp
|
|
|
|
template<> struct is_protectable<other_action<comma_action> > {
|
|
BOOST_STATIC_CONSTANT(bool, value = true);
|
|
};
|
|
|
|
|
|
namespace detail {
|
|
|
|
// this type is used in return type deductions to signal that deduction
|
|
// did not find a result. It does not necessarily mean an error, it commonly
|
|
// means that something else should be tried.
|
|
class unspecified {};
|
|
}
|
|
|
|
// function action is a special case: bind functions can be called with
|
|
// the return type specialized explicitly e.g. bind<int>(foo);
|
|
// If this call syntax is used, the return type is stored in the latter
|
|
// argument of function_action template. Otherwise the argument gets the type
|
|
// 'unspecified'.
|
|
// This argument is only relevant in the return type deduction code
|
|
template <int I, class Result_type = detail::unspecified>
|
|
class function_action {};
|
|
|
|
template<class T> class function_action<1, T> {
|
|
public:
|
|
template<class RET, class A1>
|
|
static RET apply(A1& a1) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<2, T> {
|
|
public:
|
|
template<class RET, class A1, class A2>
|
|
static RET apply(A1& a1, A2& a2) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<3, T> {
|
|
public:
|
|
template<class RET, class A1, class A2, class A3>
|
|
static RET apply(A1& a1, A2& a2, A3& a3) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2, a3);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<4, T> {
|
|
public:
|
|
template<class RET, class A1, class A2, class A3, class A4>
|
|
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2, a3, a4);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<5, T> {
|
|
public:
|
|
template<class RET, class A1, class A2, class A3, class A4, class A5>
|
|
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2, a3, a4, a5);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<6, T> {
|
|
public:
|
|
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
|
class A6>
|
|
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2, a3, a4, a5, a6);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<7, T> {
|
|
public:
|
|
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
|
class A6, class A7>
|
|
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2, a3, a4, a5, a6, a7);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<8, T> {
|
|
public:
|
|
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
|
class A6, class A7, class A8>
|
|
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
|
A8& a8) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<9, T> {
|
|
public:
|
|
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
|
class A6, class A7, class A8, class A9>
|
|
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
|
A8& a8, A9& a9) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
|
}
|
|
};
|
|
|
|
template<class T> class function_action<10, T> {
|
|
public:
|
|
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
|
class A6, class A7, class A8, class A9, class A10>
|
|
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
|
A8& a8, A9& a9, A10& a10) {
|
|
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
|
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
|
}
|
|
};
|
|
|
|
} // namespace lambda
|
|
} // namespace boost
|
|
|
|
#endif
|