boost/lambda
2
0
Fork 0
mirror of https://github.com/boostorg/lambda.git synced 2026-01-22 05:12:51 +00:00
Code Issues Projects Releases Wiki Activity

adding bind<ret>(...) syntax

Browse Source 
[SVN r12095]
This commit is contained in:
Jaakko Järvi
2001-12-17 22:44:14 +00:00
parent 08bdbd1b69
commit aef38586e2
1 changed files with 32 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
include/boost/lambda/detail/actions.hpp
View File

@@ -44,7 +44,18 @@ template <class RET> class explicit_return_type_action {};
struct protect_action {};
template <class Action> class return_void_action;
template <int I> class function_action;
namespace detail {
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 {};
// lambda_functor_action arise when the target function in a bind expression
// is a lambda functor. We must use a separate action type to notify
@@ -56,99 +67,99 @@ template <int I> class lambda_functor_action : public function_action<I> {};
// ---------------------------------------------------------
template<> class function_action<1> {
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_const<A1>::type>::apply(a1);
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>(a1);
}
};
template<> class function_action<2> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2);
}
};
template<> class function_action<3> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2, a3);
}
};
template<> class function_action<4> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2, a3, a4);
}
};
template<> class function_action<5> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2, a3, a4, a5);
}
};
template<> class function_action<6> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2, a3, a4, a5, a6);
}
};
template<> class function_action<7> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2, a3, a4, a5, a6, a7);
}
};
template<> class function_action<8> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2, a3, a4, a5, a6, a7, a8);
}
};
template<> class function_action<9> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2, a3, a4, a5, a6, a7, a8, a9);
}
};
template<> class function_action<10> {
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_const<A1>::type>::apply
return function_adaptor<typename boost::remove_const<A1>::type>::template apply<RET>
(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
}
};