feedc0de/boost_bind
1
0
Fork 0
forked from boostorg/bind
Code Pull Requests Activity

integrated void_returns work

Browse Source 
[SVN r11702]
This commit is contained in:
Dave Abrahams
2001-11-14 23:39:32 +00:00
parent 27a040d7ee
commit 7bdfb4acfc
1 changed files with 502 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

592
include/boost/bind.hpp
View File

@@ -9,6 +9,7 @@
// bind.hpp - binds function objects to arguments
//
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
// Copyright (c) 2001 David Abrahams
//
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
@@ -77,6 +78,17 @@ template<class T> class type {};
// listN
template <class R> struct evaluator0;
template <class R> struct evaluator1;
template <class R> struct evaluator2;
template <class R> struct evaluator3;
template <class R> struct evaluator4;
template <class R> struct evaluator5;
template <class R> struct evaluator6;
template <class R> struct evaluator7;
template <class R> struct evaluator8;
template <class R> struct evaluator9;
class list0
{
public:
@@ -93,11 +105,12 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & /* a */) const
template <class R>
struct evaluator
{
return f();
}
typedef evaluator0<R> type;
};
template<class V> void accept(V &) const
{
}
@@ -125,20 +138,21 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_]);
}
typedef evaluator1<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
}
private:
A1 a1_;
private:
list1 & operator= (list1 const &);
};
@@ -161,22 +175,23 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_], a[a2_]);
}
typedef evaluator2<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
v(a2_);
}
private:
A1 a1_;
A2 a2_;
private:
list2 & operator= (list2 const &);
};
@@ -200,11 +215,12 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_], a[a2_], a[a3_]);
}
typedef evaluator3<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
@@ -212,12 +228,12 @@ public:
v(a3_);
}
private:
A1 a1_;
A2 a2_;
A3 a3_;
private:
list3 & operator= (list3 const &);
};
@@ -242,11 +258,12 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_], a[a2_], a[a3_], a[a4_]);
}
typedef evaluator4<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
@@ -255,13 +272,13 @@ public:
v(a4_);
}
private:
A1 a1_;
A2 a2_;
A3 a3_;
A4 a4_;
private:
list4 & operator= (list4 const &);
};
@@ -287,11 +304,12 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
}
typedef evaluator5<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
@@ -301,14 +319,14 @@ public:
v(a5_);
}
private:
A1 a1_;
A2 a2_;
A3 a3_;
A4 a4_;
A5 a5_;
private:
list5 & operator= (list5 const &);
};
@@ -335,11 +353,12 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
}
typedef evaluator6<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
@@ -350,8 +369,6 @@ public:
v(a6_);
}
private:
A1 a1_;
A2 a2_;
A3 a3_;
@@ -359,6 +376,8 @@ private:
A5 a5_;
A6 a6_;
private:
list6 & operator= (list6 const &);
};
@@ -386,11 +405,12 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
}
typedef evaluator7<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
@@ -402,8 +422,6 @@ public:
v(a7_);
}
private:
A1 a1_;
A2 a2_;
A3 a3_;
@@ -412,6 +430,8 @@ private:
A6 a6_;
A7 a7_;
private:
list7 & operator= (list7 const &);
};
@@ -440,11 +460,12 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
}
typedef evaluator8<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
@@ -457,8 +478,6 @@ public:
v(a8_);
}
private:
A1 a1_;
A2 a2_;
A3 a3_;
@@ -468,6 +487,8 @@ private:
A7 a7_;
A8 a8_;
private:
list8 & operator= (list8 const &);
};
@@ -497,11 +518,12 @@ public:
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
template <class R>
struct evaluator
{
return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
}
typedef evaluator9<R> type;
};
template<class V> void accept(V & v) const
{
v(a1_);
@@ -515,8 +537,6 @@ public:
v(a9_);
}
private:
A1 a1_;
A2 a2_;
A3 a3_;
@@ -527,147 +547,353 @@ private:
A8 a8_;
A9 a9_;
private:
list9 & operator= (list9 const &);
};
// bind_t
template<class R, class F, class L> class bind_t
template <class R> struct evaluator0
{
public:
template<class L, class F, class A>
static R eval(L const&, F f, A &)
{
return f();
}
};
template <> struct evaluator0<void>
{
template<class L, class F, class A>
static void eval(L const&, F f, A &)
{
f();
}
};
template <class R> struct evaluator1
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_]);
}
};
template <> struct evaluator1<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_]);
}
};
template <class R> struct evaluator2
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_], a[l.a2_]);
}
};
template <> struct evaluator2<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_], a[l.a2_]);
}
};
template <class R> struct evaluator3
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_], a[l.a2_], a[l.a3_]);
}
};
template <> struct evaluator3<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_], a[l.a2_], a[l.a3_]);
}
};
template <class R> struct evaluator4
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
}
};
template <> struct evaluator4<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
}
};
template <class R> struct evaluator5
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
}
};
template <> struct evaluator5<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
}
};
template <class R> struct evaluator6
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
}
};
template <> struct evaluator6<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
}
};
template <class R> struct evaluator7
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
}
};
template <> struct evaluator7<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
}
};
template <class R> struct evaluator8
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
}
};
template <> struct evaluator8<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
}
};
template <class R> struct evaluator9
{
template<class L, class F, class A>
static R eval(L const& l, F f, A & a)
{
return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
}
};
template <> struct evaluator9<void>
{
template<class L, class F, class A>
static void eval(L const& l, F f, A & a)
{
f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
}
};
template <class R>
struct bind_t_generator
{
template<class F, class L>
struct implementation
{
typedef typename result_traits<R, F>::type result_type;
bind_t(F f, L const & l): f_(f), l_(l) {}
implementation(F f, L const & l): f_(f), l_(l) {}
result_type operator()()
{
list0 a;
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
result_type operator()() const
{
list0 a;
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1> result_type operator()(A1 & a1)
{
list1<A1 &> a(a1);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1> result_type operator()(A1 & a1) const
{
list1<A1 &> a(a1);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
{
list2<A1 &, A2 &> a(a1, a2);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
{
list2<A1 &, A2 &> a(a1, a2);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
{
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
{
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
{
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
{
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
{
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
{
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
{
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
{
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
{
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
{
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
{
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
{
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
{
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
{
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A> result_type eval(A & a)
{
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class A> result_type eval(A & a) const
{
return l_(type<result_type>(), f_, a);
typedef typename L::template evaluator<result_type>::type evaluator;
return evaluator::eval(l_, f_, a);
}
template<class V> void accept(V & v) const
@@ -681,7 +907,193 @@ private:
F f_;
L l_;
bind_t & operator= (bind_t const &);
implementation & operator= (implementation const &);
};
};
template <>
struct bind_t_generator<void>
{
template<class F, class L>
struct implementation
{
typedef typename result_traits<void, F>::type result_type;
implementation(F f, L const & l): f_(f), l_(l) {}
result_type operator()()
{
list0 a;
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
result_type operator()() const
{
list0 a;
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1> result_type operator()(A1 & a1)
{
list1<A1 &> a(a1);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1> result_type operator()(A1 & a1) const
{
list1<A1 &> a(a1);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
{
list2<A1 &, A2 &> a(a1, a2);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
{
list2<A1 &, A2 &> a(a1, a2);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
{
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
{
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
{
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
{
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
{
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
{
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
{
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
{
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
{
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
{
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
{
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
{
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
{
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
{
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A> result_type eval(A & a)
{
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class A> result_type eval(A & a) const
{
typedef typename L::template evaluator<result_type>::type evaluator;
evaluator::eval(l_, f_, a);
}
template<class V> void accept(V & v) const
{
v(f_);
l_.accept(v);
}
private:
F f_;
L l_;
implementation & operator= (implementation const &);
};
};
template<class R, class F, class L> class bind_t
: public bind_t_generator<R>::template implementation<F, L>
{
typedef typename bind_t_generator<R>::template implementation<F, L> base;
public:
bind_t(F f, L const & l): base(f, l) {}
};
// add_value