Support for ref() as a first argument, allowing noncopyable function objects.

[SVN r14115]

include/boost/bind.hpp

@@ -59,6 +59,11 @@ template<class F> struct result_traits<unspecified, F>
     typedef typename F::result_type type;
 };
 
+template<class F> struct result_traits< unspecified, reference_wrapper<F> >
+{
+    typedef typename F::result_type type;
+};
+
 #endif
 
 // bind_t forward declaration for listN
@@ -85,6 +90,23 @@ private:
 
 template<class T> class type {};
 
+// unwrap
+
+template<class F> inline F & unwrap(F & f, long)
+{
+    return f;
+}
+
+template<class F> inline F & unwrap(reference_wrapper<F> & f, int)
+{
+    return f;
+}
+
+template<class F> inline F & unwrap(reference_wrapper<F> const & f, int)
+{
+    return f;
+}
+
 // listN
 
 #ifdef BOOST_NO_VOID_RETURNS
@@ -120,7 +142,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A &) const
     {
-        return f();
+        return unwrap(f, 0)();
     }
 
     template<class V> void accept(V &) const
@@ -160,7 +182,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_]);
+        return unwrap(f, 0)(a[a1_]);
     }
 
     template<class V> void accept(V & v) const
@@ -208,7 +230,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_]);
+        return unwrap(f, 0)(a[a1_], a[a2_]);
     }
 
     template<class V> void accept(V & v) const
@@ -260,7 +282,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
     }
 
     template<class V> void accept(V & v) const
@@ -316,7 +338,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_], a[a4_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
     }
 
     template<class V> void accept(V & v) const
@@ -376,7 +398,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(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 V> void accept(V & v) const
@@ -440,7 +462,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(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 V> void accept(V & v) const
@@ -508,7 +530,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(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 V> void accept(V & v) const
@@ -580,7 +602,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(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 V> void accept(V & v) const
@@ -656,7 +678,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(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 V> void accept(V & v) const
@@ -703,7 +725,7 @@ template <class R> struct evaluator0
     template<class L, class F, class A>
     static R eval(L const&, F f, A &)
     {
-        return f();
+        return unwrap(f, 0)();
     }
 };
 
@@ -712,7 +734,7 @@ template <> struct evaluator0<void>
     template<class L, class F, class A>
     static void eval(L const&, F f, A &)
     {
-        f();
+        unwrap(f, 0)();
     }
 };
 
@@ -721,7 +743,7 @@ 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_]);
+        return unwrap(f, 0)(a[l.a1_]);
     }
 };
 
@@ -730,7 +752,7 @@ 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_]);
+        unwrap(f, 0)(a[l.a1_]);
     }
 };
 
@@ -739,7 +761,7 @@ 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_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
     }
 };
 
@@ -748,7 +770,7 @@ 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_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_]);
     }
 };
 
@@ -757,7 +779,7 @@ 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_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
     }
 };
 
@@ -766,7 +788,7 @@ 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_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
     }
 };
 
@@ -775,7 +797,7 @@ 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_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
     }
 };
 
@@ -784,7 +806,7 @@ 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_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
     }
 };
 
@@ -793,7 +815,7 @@ 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_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
     }
 };
 
@@ -802,7 +824,7 @@ 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_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
     }
 };
 
@@ -811,7 +833,7 @@ 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_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
     }
 };
 
@@ -820,7 +842,7 @@ 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_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
     }
 };
 
@@ -829,7 +851,7 @@ 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_]);
+        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_]);
     }
 };
 
@@ -838,7 +860,7 @@ 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_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
     }
 };
 
@@ -847,7 +869,7 @@ 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_]);
+        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_]);
     }
 };
 
@@ -856,7 +878,7 @@ 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_]);
+        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_]);
     }
 };
 
@@ -865,7 +887,7 @@ 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_]);
+        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_]);
     }
 };
 
@@ -874,7 +896,7 @@ 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_]);
+        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_]);
     }
 };