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

Next round of MSVC 6/7 fixes.

Browse Source 
[SVN r22453]
This commit is contained in:
Peter Dimov
2004-03-07 16:39:15 +00:00
parent 6fbbcd0d3c
commit 807bbfd434
3 changed files with 241 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

520
include/boost/bind.hpp
View File

@@ -10,7 +10,7 @@
//
// bind.hpp - binds function objects to arguments
//
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
// Copyright (c) 2001 David Abrahams
//
// Permission to copy, use, modify, sell and distribute this software
@@ -26,6 +26,7 @@
#include <boost/mem_fn.hpp>
#include <boost/type.hpp>
#include <boost/bind/arg.hpp>
#include <boost/detail/workaround.hpp>
// Borland-specific bug, visit_each() silently fails to produce code
@@ -112,43 +113,23 @@ template<class T> class type {};
// unwrap
template<class F> inline F & unwrap(F & f, long)
template<class F> inline F & unwrap(F * f, long)
{
return f;
return *f;
}
template<class F> inline F * unwrap(F * f, int)
template<class F> inline F & unwrap(reference_wrapper<F> * f, int)
{
return f;
return f->get();
}
template<class F> inline F & unwrap(reference_wrapper<F> & f, int)
template<class F> inline F & unwrap(reference_wrapper<F> const * f, int)
{
return f;
}
template<class F> inline F & unwrap(reference_wrapper<F> const & f, int)
{
return f;
return f->get();
}
// listN
#ifdef BOOST_NO_VOID_RETURNS
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;
#endif
class list0
{
public:
@@ -165,14 +146,24 @@ 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 &)
template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
{
return unwrap(f, 0)();
return unwrap(&f, 0)();
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A &) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
{
return unwrap(f, 0)();
return unwrap(&f, 0)();
}
template<class F, class A> void operator()(type<void>, F & f, A &, int)
{
unwrap(&f, 0)();
}
template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
{
unwrap(&f, 0)();
}
template<class V> void accept(V &) const
@@ -183,16 +174,6 @@ public:
{
return true;
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator0<R> type;
};
#endif
};
template<class A1> class list1
@@ -215,14 +196,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_]);
return unwrap(&f, 0)(a[a1_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_]);
return unwrap(&f, 0)(a[a1_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_]);
}
template<class V> void accept(V & v) const
@@ -235,19 +226,8 @@ public:
return ref_compare(a1_, rhs.a1_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator1<R> type;
};
#else
private:
#endif
A1 a1_;
};
@@ -273,14 +253,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_], a[a2_]);
return unwrap(&f, 0)(a[a1_], a[a2_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_], a[a2_]);
return unwrap(&f, 0)(a[a1_], a[a2_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_], a[a2_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_], a[a2_]);
}
template<class V> void accept(V & v) const
@@ -294,19 +284,8 @@ public:
return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator2<R> type;
};
#else
private:
#endif
A1 a1_;
A2 a2_;
};
@@ -335,14 +314,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]);
}
template<class V> void accept(V & v) const
@@ -357,19 +346,8 @@ public:
return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator3<R> type;
};
#else
private:
#endif
A1 a1_;
A2 a2_;
A3 a3_;
@@ -401,14 +379,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
}
template<class V> void accept(V & v) const
@@ -426,19 +414,8 @@ public:
ref_compare(a4_, rhs.a4_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator4<R> type;
};
#else
private:
#endif
A1 a1_;
A2 a2_;
A3 a3_;
@@ -473,14 +450,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
}
template<class V> void accept(V & v) const
@@ -499,19 +486,8 @@ public:
ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator5<R> type;
};
#else
private:
#endif
A1 a1_;
A2 a2_;
A3 a3_;
@@ -549,14 +525,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
}
template<class V> void accept(V & v) const
@@ -576,19 +562,8 @@ public:
ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator6<R> type;
};
#else
private:
#endif
A1 a1_;
A2 a2_;
A3 a3_;
@@ -629,14 +604,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
}
template<class V> void accept(V & v) const
@@ -658,19 +643,8 @@ public:
ref_compare(a7_, rhs.a7_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator7<R> type;
};
#else
private:
#endif
A1 a1_;
A2 a2_;
A3 a3_;
@@ -714,14 +688,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
}
template<class V> void accept(V & v) const
@@ -744,19 +728,8 @@ public:
ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator8<R> type;
};
#else
private:
#endif
A1 a1_;
A2 a2_;
A3 a3_;
@@ -803,14 +776,24 @@ 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)
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a) const
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
}
template<class V> void accept(V & v) const
@@ -834,19 +817,8 @@ public:
ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0) && ref_compare(a9_, rhs.a9_, 0);
}
#ifdef BOOST_NO_VOID_RETURNS
template<class R> struct evaluator
{
typedef evaluator9<R> type;
};
#else
private:
#endif
A1 a1_;
A2 a2_;
A3 a3_;
@@ -858,190 +830,6 @@ private:
A9 a9_;
};
#ifdef BOOST_NO_VOID_RETURNS
template <class R> struct evaluator0
{
template<class L, class F, class A>
static R eval(L &, F & f, A &)
{
return unwrap(f, 0)();
}
};
template <> struct evaluator0<void>
{
template<class L, class F, class A>
static void eval(L &, F & f, A &)
{
unwrap(f, 0)();
}
};
template <class R> struct evaluator1
{
template<class L, class F, class A>
static R eval(L & l, F & f, A & a)
{
return unwrap(f, 0)(a[l.a1_]);
}
};
template <> struct evaluator1<void>
{
template<class L, class F, class A>
static void eval(L & l, F & f, A & a)
{
unwrap(f, 0)(a[l.a1_]);
}
};
template <class R> struct evaluator2
{
template<class L, class F, class A>
static R eval(L & l, F & f, A & a)
{
return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
}
};
template <> struct evaluator2<void>
{
template<class L, class F, class A>
static void eval(L & l, F & f, A & a)
{
unwrap(f, 0)(a[l.a1_], a[l.a2_]);
}
};
template <class R> struct evaluator3
{
template<class L, class F, class A>
static R eval(L & l, F & f, A & a)
{
return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
}
};
template <> struct evaluator3<void>
{
template<class L, class F, class A>
static void eval(L & l, F & f, A & a)
{
unwrap(f, 0)(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 & l, F & f, A & a)
{
return unwrap(f, 0)(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 & l, F & f, A & a)
{
unwrap(f, 0)(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 & l, F & f, A & a)
{
return unwrap(f, 0)(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 & l, F & f, A & a)
{
unwrap(f, 0)(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 & l, F & f, A & a)
{
return unwrap(f, 0)(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 & l, F & f, A & a)
{
unwrap(f, 0)(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 & l, F & f, A & a)
{
return unwrap(f, 0)(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 & l, F & f, A & a)
{
unwrap(f, 0)(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 & l, F & f, A & a)
{
return unwrap(f, 0)(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 & l, F & f, A & a)
{
unwrap(f, 0)(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 & l, F & f, A & a)
{
return unwrap(f, 0)(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 & l, F & f, A & a)
{
unwrap(f, 0)(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_]);
}
};
#endif
// bind_t
#ifndef BOOST_NO_VOID_RETURNS
@@ -1054,9 +842,9 @@ public:
bind_t(F f, L const & l): f_(f), l_(l) {}
#define BOOST_BIND_EVALUATE return l_(type<result_type>(), f_, a)
#define BOOST_BIND_RETURN return
#include <boost/bind/bind_template.hpp>
#undef BOOST_BIND_EVALUATE
#undef BOOST_BIND_RETURN
};
@@ -1073,9 +861,9 @@ public:
implementation(F f, L const & l): f_(f), l_(l) {}
#define BOOST_BIND_EVALUATE return L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
#define BOOST_BIND_RETURN return
#include <boost/bind/bind_template.hpp>
#undef BOOST_BIND_EVALUATE
#undef BOOST_BIND_RETURN
};
@@ -1096,9 +884,9 @@ public:
implementation(F f, L const & l): f_(f), l_(l) {}
#define BOOST_BIND_EVALUATE L::BOOST_NESTED_TEMPLATE evaluator<result_type>::type::eval(l_, f_, a);
#define BOOST_BIND_RETURN
#include <boost/bind/bind_template.hpp>
#undef BOOST_BIND_EVALUATE
#undef BOOST_BIND_RETURN
};

46
include/boost/bind/bind_template.hpp
View File

@@ -3,7 +3,7 @@
//
// Do not include this header directly.
//
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
//
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
@@ -18,131 +18,131 @@
result_type operator()()
{
list0 a;
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
result_type operator()() const
{
list0 a;
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1> result_type operator()(A1 & a1)
{
list1<A1 &> a(a1);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1> result_type operator()(A1 & a1) const
{
list1<A1 &> a(a1);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
{
list2<A1 &, A2 &> a(a1, a2);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
{
list2<A1 &, A2 &> a(a1, a2);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
{
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
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);
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A> result_type eval(A & a)
{
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A> result_type eval(A & a) const
{
BOOST_BIND_EVALUATE;
BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class V> void accept(V & v) const

87
test/bind_stateful_test.cpp
View File

@@ -44,6 +44,11 @@ public:
{
}
int state() const
{
return state_;
}
int operator()()
{
return state_ += 17041;
@@ -140,38 +145,74 @@ int f8(int & state_, int x1, int x2, int x3, int x4, int x5, int x6, int x7, int
return state_ += x1+x2+x3+x4+x5+x6+x7+x8;
}
template<class F> void test(F f, int r)
template<class F> void test(F f, int a, int b)
{
BOOST_TEST( f() == r );
BOOST_TEST( f() == 2*r );
BOOST_TEST( f() == 3*r );
BOOST_TEST( f() == a + b );
BOOST_TEST( f() == a + 2*b );
BOOST_TEST( f() == a + 3*b );
}
void stateful_function_object_test()
{
test( boost::bind<int>( X() ), 17041 );
test( boost::bind<int>( X(), 1 ), 1 );
test( boost::bind<int>( X(), 1, 2 ), 1+2 );
test( boost::bind<int>( X(), 1, 2, 3 ), 1+2+3 );
test( boost::bind<int>( X(), 1, 2, 3, 4 ), 1+2+3+4 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5 ), 1+2+3+4+5 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6 ), 1+2+3+4+5+6 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7 ), 1+2+3+4+5+6+7 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8 ), 1+2+3+4+5+6+7+8 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), 1+2+3+4+5+6+7+8+9 );
test( boost::bind<int>( X() ), 0, 17041 );
test( boost::bind<int>( X(), 1 ), 0, 1 );
test( boost::bind<int>( X(), 1, 2 ), 0, 1+2 );
test( boost::bind<int>( X(), 1, 2, 3 ), 0, 1+2+3 );
test( boost::bind<int>( X(), 1, 2, 3, 4 ), 0, 1+2+3+4 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5 ), 0, 1+2+3+4+5 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6 ), 0, 1+2+3+4+5+6 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7 ), 0, 1+2+3+4+5+6+7 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8 ), 0, 1+2+3+4+5+6+7+8 );
test( boost::bind<int>( X(), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), 0, 1+2+3+4+5+6+7+8+9 );
X x;
int n = x.state();
test( boost::bind<int>( boost::ref(x) ), n, 17041 );
n += 3*17041;
test( boost::bind<int>( boost::ref(x), 1 ), n, 1 );
n += 3*1;
test( boost::bind<int>( boost::ref(x), 1, 2 ), n, 1+2 );
n += 3*(1+2);
test( boost::bind<int>( boost::ref(x), 1, 2, 3 ), n, 1+2+3 );
n += 3*(1+2+3);
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4 ), n, 1+2+3+4 );
n += 3*(1+2+3+4);
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5 ), n, 1+2+3+4+5 );
n += 3*(1+2+3+4+5);
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6 ), n, 1+2+3+4+5+6 );
n += 3*(1+2+3+4+5+6);
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7 ), n, 1+2+3+4+5+6+7 );
n += 3*(1+2+3+4+5+6+7);
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8 ), n, 1+2+3+4+5+6+7+8 );
n += 3*(1+2+3+4+5+6+7+8);
test( boost::bind<int>( boost::ref(x), 1, 2, 3, 4, 5, 6, 7, 8, 9 ), n, 1+2+3+4+5+6+7+8+9 );
n += 3*(1+2+3+4+5+6+7+8+9);
BOOST_TEST( x.state() == n );
}
void stateful_function_test()
{
test( boost::bind( f0, 0 ), 17041 );
test( boost::bind( f1, 0, 1 ), 1 );
test( boost::bind( f2, 0, 1, 2 ), 1+2 );
test( boost::bind( f3, 0, 1, 2, 3 ), 1+2+3 );
test( boost::bind( f4, 0, 1, 2, 3, 4 ), 1+2+3+4 );
test( boost::bind( f5, 0, 1, 2, 3, 4, 5 ), 1+2+3+4+5 );
test( boost::bind( f6, 0, 1, 2, 3, 4, 5, 6 ), 1+2+3+4+5+6 );
test( boost::bind( f7, 0, 1, 2, 3, 4, 5, 6, 7 ), 1+2+3+4+5+6+7 );
test( boost::bind( f8, 0, 1, 2, 3, 4, 5, 6, 7, 8 ), 1+2+3+4+5+6+7+8 );
test( boost::bind( f0, 0 ), 0, 17041 );
test( boost::bind( f1, 0, 1 ), 0, 1 );
test( boost::bind( f2, 0, 1, 2 ), 0, 1+2 );
test( boost::bind( f3, 0, 1, 2, 3 ), 0, 1+2+3 );
test( boost::bind( f4, 0, 1, 2, 3, 4 ), 0, 1+2+3+4 );
test( boost::bind( f5, 0, 1, 2, 3, 4, 5 ), 0, 1+2+3+4+5 );
test( boost::bind( f6, 0, 1, 2, 3, 4, 5, 6 ), 0, 1+2+3+4+5+6 );
test( boost::bind( f7, 0, 1, 2, 3, 4, 5, 6, 7 ), 0, 1+2+3+4+5+6+7 );
test( boost::bind( f8, 0, 1, 2, 3, 4, 5, 6, 7, 8 ), 0, 1+2+3+4+5+6+7+8 );
}
int main()