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

Function objects with overloaded operator& are now supported.

Browse Source 
[SVN r31506]
This commit is contained in:
Peter Dimov
2005-10-30 21:38:36 +00:00
parent a9deb8c577
commit 2d6ccb09a7
1 changed files with 54 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
include/boost/bind.hpp
View File

@@ -113,38 +113,23 @@ template<class T> class type {};
// unwrap // unwrap
template<class F> inline F & unwrap(F * f, long) template<class F> struct unwrapper
{ {
return *f; static inline F & unwrap( F & f, long )
} {
return f;
}
template<class F> inline F & unwrap(reference_wrapper<F> * f, int) template<class F2> static inline F2 & unwrap( reference_wrapper<F2> const & f, int )
{ {
return f->get(); return f->get();
} }
template<class F> inline F & unwrap(reference_wrapper<F> const * f, int) template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
{ {
return f->get(); return _mfi::dm<R, T>( pm );
} }
};
#if !( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, <= 0x3004) )
template<class R, class T> inline _mfi::dm<R, T> unwrap(R T::* * pm, int)
{
return _mfi::dm<R, T>(*pm);
}
#if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
// IBM/VisualAge 6.0 is not able to handle this overload.
template<class R, class T> inline _mfi::dm<R, T> unwrap(R T::* const * pm, int)
{
return _mfi::dm<R, T>(*pm);
}
#endif
#endif
// listN // listN
@@ -166,22 +151,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A &, long) template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
{ {
return unwrap(&f, 0)(); return unwrapper<F>::unwrap(f, 0)();
} }
template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
{ {
return unwrap(&f, 0)(); return unwrapper<F const>::unwrap(f, 0)();
} }
template<class F, class A> void operator()(type<void>, F & f, A &, int) template<class F, class A> void operator()(type<void>, F & f, A &, int)
{ {
unwrap(&f, 0)(); unwrapper<F>::unwrap(f, 0)();
} }
template<class F, class A> void operator()(type<void>, F const & f, A &, int) const template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
{ {
unwrap(&f, 0)(); unwrapper<F const>::unwrap(f, 0)();
} }
template<class V> void accept(V &) const template<class V> void accept(V &) const
@@ -216,22 +201,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{ {
return unwrap(&f, 0)(a[a1_]); return unwrapper<F>::unwrap(f, 0)(a[a1_]);
} }
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) 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 unwrapper<F const>::unwrap(f, 0)(a[a1_]);
} }
template<class F, class A> void operator()(type<void>, F & f, A & a, int) template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{ {
unwrap(&f, 0)(a[a1_]); unwrapper<F>::unwrap(f, 0)(a[a1_]);
} }
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{ {
unwrap(&f, 0)(a[a1_]); unwrapper<F const>::unwrap(f, 0)(a[a1_]);
} }
template<class V> void accept(V & v) const template<class V> void accept(V & v) const
@@ -273,22 +258,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 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 unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_]);
} }
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) 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 unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_]);
} }
template<class F, class A> void operator()(type<void>, F & f, A & a, int) template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{ {
unwrap(&f, 0)(a[a1_], a[a2_]); unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_]);
} }
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{ {
unwrap(&f, 0)(a[a1_], a[a2_]); unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_]);
} }
template<class V> void accept(V & v) const template<class V> void accept(V & v) const
@@ -334,22 +319,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 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 unwrapper<F>::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, long) 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 unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
} }
template<class F, class A> void operator()(type<void>, F & f, A & a, int) template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{ {
unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]); unwrapper<F>::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 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_]); unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
} }
template<class V> void accept(V & v) const template<class V> void accept(V & v) const
@@ -399,22 +384,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 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 unwrapper<F>::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, long) 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 unwrapper<F const>::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) 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_]); unwrapper<F>::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 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_]); unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
} }
template<class V> void accept(V & v) const template<class V> void accept(V & v) const
@@ -470,22 +455,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 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 unwrapper<F>::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, long) 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 unwrapper<F const>::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) 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_]); unwrapper<F>::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 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_]); unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
} }
template<class V> void accept(V & v) const template<class V> void accept(V & v) const
@@ -545,22 +530,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 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 unwrapper<F>::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, long) 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 unwrapper<F const>::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) 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_]); unwrapper<F>::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 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_]); unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
} }
template<class V> void accept(V & v) const template<class V> void accept(V & v) const
@@ -624,22 +609,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 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 unwrapper<F>::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, long) 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 unwrapper<F const>::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) 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_]); unwrapper<F>::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 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_]); unwrapper<F 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 template<class V> void accept(V & v) const
@@ -708,22 +693,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 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 unwrapper<F>::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, long) 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 unwrapper<F const>::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) 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_]); unwrapper<F>::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 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_]); unwrapper<F 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 template<class V> void accept(V & v) const
@@ -796,22 +781,22 @@ public:
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long) 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 unwrapper<F>::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, long) 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 unwrapper<F const>::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) 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_]); unwrapper<F>::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 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_]); unwrapper<F 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 template<class V> void accept(V & v) const