GNOME.org
 

[libsigc++2/variadic: 6/6] *mem_functor(): Remove the numbered versions, leaving just variadic ones.

commit 074ed7a7fd67aec49555e646259d7326b26567d8
Author: Murray Cumming <murrayc murrayc com>
Date:   Thu Jan 7 17:14:14 2016 +0100

    *mem_functor(): Remove the numbered versions, leaving just variadic ones.
    
    Do not generate *mem_functor0 through *mem_functor7. Instead just
    generate variadic *mem_functor<>.
    We do still generate mem_functor, const_mem_functor and
    const_volatile_mem_functor, which seems messy.

 sigc++/adaptors/macros/retype.h.m4        |    6 +-
 sigc++/functors/macros/functor_trait.h.m4 |    8 +-
 sigc++/functors/macros/mem_fun.h.m4       |  148 +++++++++++++----------------
 sigc++/macros/signal.h.m4                 |    4 +-
 tests/test_accumulated.cc                 |    4 +-
 tests/test_disconnect.cc                  |    4 +-
 tests/test_mem_fun.cc                     |   12 +-
 tests/test_signal.cc                      |    2 +-
 tests/test_size.cc                        |    4 +-
 tests/test_trackable.cc                   |    2 +-
 tests/test_trackable_move.cc              |    4 +-
 11 files changed, 91 insertions(+), 107 deletions(-)
---
diff --git a/sigc++/adaptors/macros/retype.h.m4 b/sigc++/adaptors/macros/retype.h.m4
index 0f3ab41..ced5cf9 100644
--- a/sigc++/adaptors/macros/retype.h.m4
+++ b/sigc++/adaptors/macros/retype.h.m4
@@ -67,9 +67,9 @@ define([RETYPE_MEM_FUNCTOR],[dnl
  * @ingroup retype
  */
 template <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))>
-inline retype_functor<LIST($2[]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>, LOOP(T_arg%1, $1)) >
-retype(const $2[]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>& _A_functor)
-{ return retype_functor<LIST($2[]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>, LOOP(T_arg%1, $1)) 



+inline retype_functor<LIST($2[]mem_functor<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>, LOOP(T_arg%1, $1)) >
+retype(const $2[]mem_functor<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>& _A_functor)
+{ return retype_functor<LIST($2[]mem_functor<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>, LOOP(T_arg%1, $1)) >
     (_A_functor); }
 
 ])
diff --git a/sigc++/functors/macros/functor_trait.h.m4 b/sigc++/functors/macros/functor_trait.h.m4
index 4c9d613..743a639 100644
--- a/sigc++/functors/macros/functor_trait.h.m4
+++ b/sigc++/functors/macros/functor_trait.h.m4
@@ -27,19 +27,19 @@ struct functor_trait<T_return (*)(LOOP(T_arg%1, $1)), false, false>
 
 ])
 define([FUNCTOR_MEM_FUN],[dnl
-template <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))> class mem_functor$1;
-template <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))> class const_mem_functor$1;
+template <LIST(class T_return, class T_obj, class... T_arg)> class mem_functor;
+template <LIST(class T_return, class T_obj, class... T_arg)> class const_mem_functor;
 template <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj)>
 struct functor_trait<T_return (T_obj::*)(LOOP(T_arg%1, $1)), false, false>
 {
   typedef T_return result_type;
-  typedef mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> functor_type;
+  typedef mem_functor<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> functor_type;
 };
 template <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj)>
 struct functor_trait<T_return (T_obj::*)(LOOP(T_arg%1, $1)) const, false, false>
 {
   typedef T_return result_type;
-  typedef const_mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> functor_type;
+  typedef const_mem_functor<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> functor_type;
 };
 
 ])
diff --git a/sigc++/functors/macros/mem_fun.h.m4 b/sigc++/functors/macros/mem_fun.h.m4
index 9cb6270..3b4e430 100644
--- a/sigc++/functors/macros/mem_fun.h.m4
+++ b/sigc++/functors/macros/mem_fun.h.m4
@@ -19,49 +19,46 @@ divert(-1)
 include(template.macros.m4)
 
 define([MEMBER_FUNCTOR],[dnl
-/** [$2]mem_functor$1 wraps $4 methods with $1 argument(s).
- * Use the convenience function mem_fun() to create an instance of [$2]mem_functor$1.
+/** [$1]mem_functor wraps $3 methods with argument(s).
+ * Use the convenience function mem_fun() to create an instance of [$1]mem_functor.
  *
  * The following template arguments are used:dnl
-FOR(1,$1,[
- * - @e T_arg%1 Argument type used in the definition of operator()().])
+ * - @e T_arg... Argument types used in the definition of operator()().
  * - @e T_return The return type of operator()().
  * - @e T_obj The object type.
  *
  * @ingroup mem_fun
  */
-template <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))>
-class [$2]mem_functor$1 : public functor_base
+template <LIST(class T_return, class T_obj, class... T_arg)>
+class [$1]mem_functor : public functor_base
 {
 public:
-  typedef T_return (T_obj::*function_type)(LOOP(T_arg%1, $1)) $4;
+  typedef T_return (T_obj::*function_type)(T_arg...) $3;
   typedef T_return result_type;
 
   /// Constructs an invalid functor.
-  [$2]mem_functor$1() : func_ptr_(nullptr) {}
+  [$1]mem_functor() : func_ptr_(nullptr) {}
 
-  /** Constructs a [$2]mem_functor$1 object that wraps the passed method.
+  /** Constructs a [$1]mem_functor object that wraps the passed method.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
-  explicit [$2]mem_functor$1(function_type _A_func) : func_ptr_(_A_func) {}
+  explicit [$1]mem_functor(function_type _A_func) : func_ptr_(_A_func) {}
 
   /** Execute the wrapped method operating on the passed instance.
    * @param _A_obj Pointer to instance the method should operate on.dnl
-FOR(1, $1,[
-   * @param _A_a%1 Argument to be passed on to the method.])
+   * @param _A_a... Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
-  T_return operator()(LIST($3 T_obj* _A_obj, LOOP(type_trait_take_t<T_arg%1> _A_a%1, $1))) const
-    { return (_A_obj->*(this->func_ptr_))(LOOP(_A_a%1, $1)); }
+  T_return operator()(LIST($2 T_obj* _A_obj, type_trait_take_t<T_arg>... _A_a)) const
+    { return (_A_obj->*(this->func_ptr_))(_A_a...); }
 
   /** Execute the wrapped method operating on the passed instance.
    * @param _A_obj Reference to instance the method should operate on.dnl
-FOR(1, $1,[
-   * @param _A_a%1 Argument to be passed on to the method.])
+   * @param _A_a... Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
-  T_return operator()(LIST($3 T_obj& _A_obj, LOOP(type_trait_take_t<T_arg%1> _A_a%1, $1))) const
-    { return (_A_obj.*func_ptr_)(LOOP(_A_a%1, $1)); }
+  T_return operator()(LIST($2 T_obj& _A_obj, type_trait_take_t<T_arg>... _A_a)) const
+    { return (_A_obj.*func_ptr_)(_A_a...); }
 
 protected:
   function_type func_ptr_;
@@ -70,71 +67,69 @@ protected:
 ])
 define([BOUND_MEMBER_FUNCTOR],[dnl
 
-/** bound_[$2]mem_functor$1 encapsulates a $4 method with $1 arguments and an object instance.
- * Use the convenience function mem_fun() to create an instance of bound_[$2]mem_functor$1.
+/** bound_[$1]mem_functor encapsulates a $3 method with arguments and an object instance.
+ * Use the convenience function mem_fun() to create an instance of bound_[$1]mem_functor.
  *
  * The following template arguments are used:dnl
-FOR(1,$1,[
- * - @e T_arg%1 Argument type used in the definition of operator()().])
+ * - @e T_arg... Argument type used in the definition of operator()().
  * - @e T_return The return type of operator()().
  * - @e T_obj The object type.
  *
  * @ingroup mem_fun
  */
-template <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))>
-class bound_[$2]mem_functor$1
-  : public [$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>
+template <LIST(class T_return, class T_obj, class... T_arg)>
+class bound_[$1]mem_functor
+  : public [$1]mem_functor<LIST(T_return, T_obj, T_arg...)>
 {
-  typedef [$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> base_type_;
+  typedef [$1]mem_functor<LIST(T_return, T_obj, T_arg...)> base_type_;
 public:
   typedef typename base_type_::function_type function_type;
 
-  /** Constructs a bound_[$2]mem_functor$1 object that wraps the passed method.
+  /** Constructs a bound_[$1]mem_functor object that wraps the passed method.
    * @param _A_obj Pointer to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
-  bound_[$2]mem_functor$1($3 T_obj* _A_obj, function_type _A_func)
+  bound_[$1]mem_functor($2 T_obj* _A_obj, function_type _A_func)
     : base_type_(_A_func),
       obj_(*_A_obj)
     {}
 
-  /** Constructs a bound_[$2]mem_functor$1 object that wraps the passed method.
+  /** Constructs a bound_[$1]mem_functor object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
-  bound_[$2]mem_functor$1($3 T_obj& _A_obj, function_type _A_func)
+  bound_[$1]mem_functor($2 T_obj& _A_obj, function_type _A_func)
     : base_type_(_A_func),
       obj_(_A_obj)
     {}
 
   /** Execute the wrapped method operating on the stored instance.dnl
-FOR(1, $1,[
-   * @param _A_a%1 Argument to be passed on to the method.])
+   * @param _A_a... Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
-  T_return operator()(LOOP(type_trait_take_t<T_arg%1> _A_a%1, $1)) const
-    { return (obj_.invoke().*(this->func_ptr_))(LOOP(_A_a%1, $1)); }
+  T_return operator()(type_trait_take_t<T_arg>... _A_a) const
+    { return (obj_.invoke().*(this->func_ptr_))(_A_a...); }
 
 //protected:
   // Reference to stored object instance.
   // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  [$2]limit_reference<T_obj> obj_;
+  [$1]limit_reference<T_obj> obj_;
 };
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 //template specialization of visitor<>::do_visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
- * The function overload for sigc::bound_[$2]mem_functor performs a functor
- * on the object instance stored in the sigc::bound_[$2]mem_functor object.
+ * The function overload for sigc::bound_[$1]mem_functor performs a functor
+ * on the object instance stored in the sigc::bound_[$1]mem_functor object.
  *
  * @ingroup mem_fun
  */
-template <LIST(class T_return, class T_obj, LOOP(class T_arg%1, $1))>
-struct visitor<bound_[$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))> >
+template <LIST(class T_return, class T_obj, class... T_arg)>
+struct visitor<bound_[$1]mem_functor<LIST(T_return, T_obj, T_arg...)> >
 {
   template <class T_action>
   static void do_visit_each(const T_action& _A_action,
-                            const bound_[$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>& 
_A_target)
+                            const bound_[$1]mem_functor<LIST(T_return, T_obj, T_arg...)>& _A_target)
   {
     sigc::visit_each(_A_action, _A_target.obj_);
   }
@@ -143,42 +138,42 @@ struct visitor<bound_[$2]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>
 ])
 
 define([MEM_FUN],[dnl
-/** Creates a functor of type sigc::[$3]mem_functor$1 which wraps a $5 method.
+/** Creates a functor of type sigc::[$1]mem_functor which wraps a $3 method.
  * @param _A_func Pointer to method that should be wrapped.
  * @return Functor that executes _A_func on invokation.
  *
  * @ingroup mem_fun
  */
-template <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj)>
-inline [$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>
-mem_fun[]ifelse($2,, $1)(T_return (T_obj::*_A_func)(LOOP(T_arg%1,$1)) $5)
-{ return [$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>(_A_func); }
+template <LIST(class T_return, class T_obj, class... T_arg)>
+inline [$1]mem_functor<LIST(T_return, T_obj, T_arg...)>
+mem_fun(T_return (T_obj::*_A_func)(T_arg...) $3)
+{ return [$1]mem_functor<LIST(T_return, T_obj, T_arg...)>(_A_func); }
 
 ])
 define([BOUND_MEM_FUN],[dnl
-/** Creates a functor of type sigc::bound_[$3]mem_functor$1 which encapsulates a method and an object 
instance.
+/** Creates a functor of type sigc::bound_[$1]mem_functor which encapsulates a method and an object instance.
  * @param _A_obj Pointer to object instance the functor should operate on.
  * @param _A_func Pointer to method that should be wrapped.
  * @return Functor that executes @e _A_func on invokation.
  *
  * @ingroup mem_fun
  */
-template <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj, class T_obj2)>
-inline bound_[$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>
-mem_fun[]ifelse($2,, $1)(/*$4*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(LOOP(T_arg%1,$1)) $5)
-{ return bound_[$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>(_A_obj, _A_func); }
+template <LIST(class T_return, class T_obj, class T_obj2, class... T_arg)>
+inline bound_[$1]mem_functor<LIST(T_return, T_obj, T_arg...)>
+mem_fun(/*$2*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg...) $3)
+{ return bound_[$1]mem_functor<LIST(T_return, T_obj, T_arg...)>(_A_obj, _A_func); }
 
-/** Creates a functor of type sigc::bound_[$3]mem_functor$1 which encapsulates a method and an object 
instance.
+/** Creates a functor of type sigc::bound_[$1]mem_functor which encapsulates a method and an object instance.
  * @param _A_obj Reference to object instance the functor should operate on.
  * @param _A_func Pointer to method that should be wrapped.
  * @return Functor that executes @e _A_func on invokation.
  *
  * @ingroup mem_fun
  */
-template <LIST(LOOP(class T_arg%1, $1), class T_return, class T_obj, class T_obj2)>
-inline bound_[$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>
-mem_fun[]ifelse($2,, $1)(/*$4*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(LOOP(T_arg%1,$1)) $5)
-{ return bound_[$3]mem_functor$1<LIST(T_return, T_obj, LOOP(T_arg%1, $1))>(_A_obj, _A_func); }
+template <LIST(class T_return, class T_obj, class T_obj2, class... T_arg)>
+inline bound_[$1]mem_functor<LIST(T_return, T_obj, T_arg...)>
+mem_fun(/*$2*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg...) $3)
+{ return bound_[$1]mem_functor<LIST(T_return, T_obj, T_arg...)>(_A_obj, _A_func); }
 
 ])
 
@@ -245,33 +240,22 @@ namespace sigc {
  * @ingroup sigcfunctors
  */
 
-FOR(0,CALL_SIZE,[[MEMBER_FUNCTOR(%1,[],[],[])]])dnl
-FOR(0,CALL_SIZE,[[MEMBER_FUNCTOR(%1,[const_],[const],[const])]])dnl
-FOR(0,CALL_SIZE,[[MEMBER_FUNCTOR(%1,[volatile_],[],[volatile])]])dnl
-FOR(0,CALL_SIZE,[[MEMBER_FUNCTOR(%1,[const_volatile_],[const],[const volatile])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEMBER_FUNCTOR(%1,[],[],[])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEMBER_FUNCTOR(%1,[const_],[const],[const])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEMBER_FUNCTOR(%1,[volatile_],[],[volatile])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEMBER_FUNCTOR(%1,[const_volatile_],[const],[const volatile])]])dnl
+MEMBER_FUNCTOR([],[],[])
+MEMBER_FUNCTOR([const_],[const],[const])
+MEMBER_FUNCTOR([volatile_],[],[volatile])
+MEMBER_FUNCTOR([const_volatile_],[const],[const volatile])
+BOUND_MEMBER_FUNCTOR([],[],[])
+BOUND_MEMBER_FUNCTOR([const_],[const],[const])
+BOUND_MEMBER_FUNCTOR([volatile_],[],[volatile])
+BOUND_MEMBER_FUNCTOR([const_volatile_],[const],[const volatile])
 
-// numbered
-FOR(0,CALL_SIZE,[[MEM_FUN(%1,,[],[],[])]])dnl
-FOR(0,CALL_SIZE,[[MEM_FUN(%1,,[const_],[const],[const])]])dnl
-FOR(0,CALL_SIZE,[[MEM_FUN(%1,,[volatile_],[],[volatile])]])dnl
-FOR(0,CALL_SIZE,[[MEM_FUN(%1,,[const_volatile_],[const],[const volatile])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,,[],[],[])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,,[const_],[const],[const])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,,[volatile_],[],[volatile])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,,[const_volatile_],[const],[const volatile])]])dnl
-
-// unnumbered
-FOR(0,CALL_SIZE,[[MEM_FUN(%1,1,[],[],[])]])dnl
-FOR(0,CALL_SIZE,[[MEM_FUN(%1,1,[const_],[const],[const])]])dnl
-FOR(0,CALL_SIZE,[[MEM_FUN(%1,1,[volatile_],[],[volatile])]])dnl
-FOR(0,CALL_SIZE,[[MEM_FUN(%1,1,[const_volatile_],[const],[const volatile])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,1,[],[],[])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,1,[const_],[const],[const])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,1,[volatile_],[],[volatile])]])dnl
-FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,1,[const_volatile_],[const],[const volatile])]])dnl
+MEM_FUN([],[],[])
+MEM_FUN([const_],[const],[const])
+MEM_FUN([volatile_],[],[volatile])
+MEM_FUN([const_volatile_],[const],[const volatile])
+BOUND_MEM_FUN([],[],[])
+BOUND_MEM_FUN([const_],[const],[const])
+BOUND_MEM_FUN([volatile_],[],[volatile])
+BOUND_MEM_FUN([const_volatile_],[const],[const volatile])
 
 } /* namespace sigc */
diff --git a/sigc++/macros/signal.h.m4 b/sigc++/macros/signal.h.m4
index b9e2a2b..f8feb7b 100644
--- a/sigc++/macros/signal.h.m4
+++ b/sigc++/macros/signal.h.m4
@@ -378,8 +378,8 @@ FOR(1, $1,[
    * yields the same result.
    * @return A functor that calls emit() on this signal.
    */
-  bound_const_mem_functor$1<LIST(result_type, signal$1, LOOP(type_trait_take_t<T_arg%1>, $1))> make_slot() 
const
-    { return bound_const_mem_functor$1<LIST(result_type, signal$1, LOOP(type_trait_take_t<T_arg%1>, 
$1))>(this, &signal$1::emit); }
+  bound_const_mem_functor<LIST(result_type, signal$1, LOOP(type_trait_take_t<T_arg%1>, $1))> make_slot() 
const
+    { return bound_const_mem_functor<LIST(result_type, signal$1, LOOP(type_trait_take_t<T_arg%1>, 
$1))>(this, &signal$1::emit); }
 
   /** Creates an STL-style interface for the signal's list of slots.
    * This interface supports iteration, insertion and removal of slots.
diff --git a/tests/test_accumulated.cc b/tests/test_accumulated.cc
index 06e6606..436ace4 100644
--- a/tests/test_accumulated.cc
+++ b/tests/test_accumulated.cc
@@ -89,11 +89,11 @@ int main(int argc, char* argv[])
 
   A a;
   sig.connect(sigc::ptr_fun(&foo));
-  sig.connect(sigc::mem_fun1(&a, &A::foo));
+  sig.connect(sigc::mem_fun(&a, &A::foo));
   sig.connect(sigc::ptr_fun(&bar));
 
   sig_vec.connect(sigc::ptr_fun(&foo));
-  sig_vec.connect(sigc::mem_fun1(&a, &A::foo));
+  sig_vec.connect(sigc::mem_fun(&a, &A::foo));
   sig_vec.connect(sigc::ptr_fun(&bar));
 
   double dres = sig(1);
diff --git a/tests/test_disconnect.cc b/tests/test_disconnect.cc
index 0c11765..44fd8e6 100644
--- a/tests/test_disconnect.cc
+++ b/tests/test_disconnect.cc
@@ -89,7 +89,7 @@ int main(int argc, char* argv[])
 
   {
     A a;
-    sig.connect(sigc::mem_fun1(&a, &A::foo));
+    sig.connect(sigc::mem_fun(&a, &A::foo));
     confoo = sig.connect(sigc::ptr_fun(&foo));
     conbar = sig.connect(sigc::ptr_fun(&bar));
     result_stream << "sig is connected to A::foo, foo, bar (size=" << sig.size() << "): ";
@@ -103,7 +103,7 @@ int main(int argc, char* argv[])
   util->check_result(result_stream, "sig is connected to foo, bar (size=2): foo(2) bar(2) ");
 
   A a;                  // iterators stay valid after further connections.
-  cona = sig.slots().insert(conbar, sigc::mem_fun1(&a, &A::foo));
+  cona = sig.slots().insert(conbar, sigc::mem_fun(&a, &A::foo));
   result_stream << "sig is connected to foo, A::foo, bar (size=" << sig.size() << "): ";
   sig(3);
   util->check_result(result_stream,
diff --git a/tests/test_mem_fun.cc b/tests/test_mem_fun.cc
index 32e568b..b8fe8b9 100644
--- a/tests/test_mem_fun.cc
+++ b/tests/test_mem_fun.cc
@@ -116,16 +116,16 @@ int main(int argc, char* argv[])
 #if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
   { /* test overloaded */
     test t;
-    sigc::mem_fun1<char>(&test::foo_overloaded)(&t, 7);
+    sigc::mem_fun<char>(&test::foo_overloaded)(&t, 7);
     util->check_result(result_stream, "test::foo_overloaded(char 7)");
 
-    sigc::mem_fun1<short>(&test::foo_overloaded)(&t, 7);
+    sigc::mem_fun<short>(&test::foo_overloaded)(&t, 7);
     util->check_result(result_stream, "test::foo_overloaded(short 7)");
 
-    //sigc::mem_fun1(&test::foo_overloaded)(&t, 7);
+    //sigc::mem_fun(&test::foo_overloaded)(&t, 7);
     //util->check_result(result_stream, "test::foo_overloaded(short 7)");
 
-    sigc::mem_fun2(&test::foo_overloaded)(&t, 7, 8);
+    sigc::mem_fun(&test::foo_overloaded)(&t, 7, 8);
     util->check_result(result_stream, "test::foo_overloaded(int 7, int 8)");
   }
 #endif
@@ -150,10 +150,10 @@ int main(int argc, char* argv[])
     util->check_result(result_stream, "test::foo_volatile(float 9)");
 
 #if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
-    sigc::mem_fun2(t, &test::foo_overloaded)(9, 10);
+    sigc::mem_fun(t, &test::foo_overloaded)(9, 10);
     util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)");
 
-    sigc::mem_fun2(&t, &test::foo_overloaded)(9, 10);
+    sigc::mem_fun(&t, &test::foo_overloaded)(9, 10);
     util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)");
 #endif
   }
diff --git a/tests/test_signal.cc b/tests/test_signal.cc
index c8086be..ecb5a55 100644
--- a/tests/test_signal.cc
+++ b/tests/test_signal.cc
@@ -62,7 +62,7 @@ int main(int argc, char* argv[])
   {
     A a;
     sig.connect(sigc::ptr_fun(&foo));
-    sig.connect(sigc::mem_fun1(&a, &A::foo));
+    sig.connect(sigc::mem_fun(&a, &A::foo));
     sig.connect(sigc::ptr_fun(&bar));
     sig(1);
     result_stream << sig.size();
diff --git a/tests/test_size.cc b/tests/test_size.cc
index c902462..7bdca1a 100644
--- a/tests/test_size.cc
+++ b/tests/test_size.cc
@@ -43,8 +43,8 @@ int main(int argc, char* argv[])
     std::cout << "  trackable_callback:      " << sizeof(sigc::internal::trackable_callback) << std::endl;
     std::cout << "  trackable_callback_list: " << sizeof(sigc::internal::trackable_callback_list) << 
std::endl;
     std::cout << "  slot_rep:                " << sizeof(sigc::internal::slot_rep) << std::endl;
-    std::cout << "  typed_slot_rep<mem_functor0<void,A> >: "
-              << sizeof(sigc::internal::typed_slot_rep<sigc::mem_functor0<void,A> >) << std::endl;
+    std::cout << "  typed_slot_rep<mem_functor<void,A> >: "
+              << sizeof(sigc::internal::typed_slot_rep<sigc::mem_functor<void,A> >) << std::endl;
     std::cout << "  signal_impl:             " << sizeof(sigc::internal::signal_impl) << std::endl;
   }
   return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
diff --git a/tests/test_trackable.cc b/tests/test_trackable.cc
index 159aeeb..fe7ecb1 100644
--- a/tests/test_trackable.cc
+++ b/tests/test_trackable.cc
@@ -38,7 +38,7 @@ int main(int argc, char* argv[])
   {
     my_class t;
     t.i = 10;
-    sl = sigc::mem_fun0(&t, &my_class::foo);
+    sl = sigc::mem_fun(&t, &my_class::foo);
     sl();
     util->check_result(result_stream, "10");
   }
diff --git a/tests/test_trackable_move.cc b/tests/test_trackable_move.cc
index 2d16273..6ed2e26 100644
--- a/tests/test_trackable_move.cc
+++ b/tests/test_trackable_move.cc
@@ -61,7 +61,7 @@ int main(int argc, char* argv[])
   {
     my_class t;
     t.i = 10;
-    sl = sigc::mem_fun0(&t, &my_class::foo);
+    sl = sigc::mem_fun(&t, &my_class::foo);
     sl();
     util->check_result(result_stream, "10");
 
@@ -70,7 +70,7 @@ int main(int argc, char* argv[])
     t2.i = 15;
     result_stream.clear();
 
-    sl = sigc::mem_fun0(&t2, &my_class::foo);
+    sl = sigc::mem_fun(&t2, &my_class::foo);
 
     sl();
     util->check_result(result_stream, "15");
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]