untracked/sigc++/functors/mem_fun.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3
   4
   5 // implementation notes:
   6 //  - we do not use bind here, because it would introduce
   7 //    an extra copy and complicate the header include order if bind is
   8 //    to have automatic conversion for member pointers.
   9 #ifndef _SIGC_FUNCTORS_MEM_FUN_H_
  10 #define _SIGC_FUNCTORS_MEM_FUN_H_
  11 #include <sigc++/type_traits.h>
  12 #include <sigc++/functors/functor_trait.h>
  13 #include <sigc++/limit_reference.h>
  14
  15 namespace sigc {
  16
  17 /** @defgroup mem_fun mem_fun()
  18  * mem_fun() Creates a functor from a pointer to a method.
  19  *
  20  * Optionally, a reference or pointer to an object can be bound to the functor.
  21  *
  22  * @note If the object type inherits from sigc::trackable, and the
  23  * functor returned from mem_fun() is assigned to a sigc::slot, the functor
  24  * will be automatically cleared when the object goes out of scope. Invoking
  25  * that slot will then have no effect and will not try to use the destroyed
  26  * instance.
  27  *
  28  * If the member function pointer is to an overloaded type, you must specify
  29  * the types using template arguments starting with the first argument.
  30  * It is not necessary to supply the return type.
  31  *
  32  * @par Example:
  33  * @code
  34  * struct foo : public sigc::trackable
  35  * {
  36  *   void bar(int) {}
  37  * };
  38  * foo my_foo;
  39  * sigc::slot<void, int> sl = sigc::mem_fun(my_foo, &foo::bar);
  40  * // Note: f is not a slot. It will not be invalidated when my_foo is deleted.
  41  * auto f = sigc::mem_fun(my_foo, &foo::bar); // Usually not what you want.
  42  * @endcode
  43  *
  44  * For const methods mem_fun() takes a const reference or pointer to an object.
  45  *
  46  * @par Example:
  47  * @code
  48  * struct foo : public sigc::trackable
  49  * {
  50  *   void bar(int) const {}
  51  * };
  52  * const foo my_foo;
  53  * sigc::slot<void, int> sl = sigc::mem_fun(my_foo, &foo::bar);
  54  * @endcode
  55  *
  56  * Use mem_fun#() if there is an ambiguity as to the number of arguments.
  57  *
  58  * @par Example:
  59  * @code
  60  * struct foo : public sigc::trackable
  61  * {
  62  *   void bar(int) {}
  63  *   void bar(float) {}
  64  *   void bar(int, int) {}
  65  * };
  66  * foo my_foo;
  67  * sigc::slot<void, int> sl = sigc::mem_fun1<int>(my_foo, &foo::bar);
  68  * @endcode
  69  *
  70  * @ingroup sigcfunctors
  71  */
  72
  73 /** mem_functor0 wraps  methods with 0 argument(s).
  74  * Use the convenience function mem_fun() to create an instance of mem_functor0.
  75  *
  76  * The following template arguments are used:
  77  * - @e T_return The return type of operator()().
  78  * - @e T_obj The object type.
  79  *
  80  * @ingroup mem_fun
  81  */
  82 template <class T_return, class T_obj>
  83 class mem_functor0 : public functor_base
  84 {
  85 public:
  86   typedef T_return (T_obj::*function_type)() ;
  87   typedef T_return result_type;
  88
  89   /// Constructs an invalid functor.
  90   mem_functor0() : func_ptr_(nullptr) {}
  91
  92   /** Constructs a mem_functor0 object that wraps the passed method.
  93    * @param _A_func Pointer to method will be invoked from operator()().
  94    */
  95   explicit mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
  96
  97 #ifndef SIGCXX_DISABLE_DEPRECATED
  98   /** Execute the wrapped method operating on the passed instance.
  99    *
 100    * @deprecated Please use the constructor that takes the object by reference
 101    * instead.
 102    *
 103    * @param _A_obj Pointer to instance the method should operate on.
 104    * @return The return value of the method invocation.
 105    */
 106   T_return operator()(T_obj* _A_obj) const
 107     { return (_A_obj->*(this->func_ptr_))(); }
 108 #endif //SIGCXX_DISABLE_DEPRECATED
 109
 110   /** Execute the wrapped method operating on the passed instance.
 111    * @param _A_obj Reference to instance the method should operate on.
 112    * @return The return value of the method invocation.
 113    */
 114   T_return operator()(T_obj& _A_obj) const
 115     { return (_A_obj.*func_ptr_)(); }
 116
 117 protected:
 118   function_type func_ptr_;
 119 };
 120
 121 /** mem_functor1 wraps  methods with 1 argument(s).
 122  * Use the convenience function mem_fun() to create an instance of mem_functor1.
 123  *
 124  * The following template arguments are used:
 125  * - @e T_arg1 Argument type used in the definition of operator()().
 126  * - @e T_return The return type of operator()().
 127  * - @e T_obj The object type.
 128  *
 129  * @ingroup mem_fun
 130  */
 131 template <class T_return, class T_obj, class T_arg1>
 132 class mem_functor1 : public functor_base
 133 {
 134 public:
 135   typedef T_return (T_obj::*function_type)(T_arg1) ;
 136   typedef T_return result_type;
 137
 138   /// Constructs an invalid functor.
 139   mem_functor1() : func_ptr_(nullptr) {}
 140
 141   /** Constructs a mem_functor1 object that wraps the passed method.
 142    * @param _A_func Pointer to method will be invoked from operator()().
 143    */
 144   explicit mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
 145
 146 #ifndef SIGCXX_DISABLE_DEPRECATED
 147   /** Execute the wrapped method operating on the passed instance.
 148    *
 149    * @deprecated Please use the constructor that takes the object by reference
 150    * instead.
 151    *
 152    * @param _A_obj Pointer to instance the method should operate on.
 153    * @param _A_a1 Argument to be passed on to the method.
 154    * @return The return value of the method invocation.
 155    */
 156   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
 157     { return (_A_obj->*(this->func_ptr_))(_A_a1); }
 158 #endif //SIGCXX_DISABLE_DEPRECATED
 159
 160   /** Execute the wrapped method operating on the passed instance.
 161    * @param _A_obj Reference to instance the method should operate on.
 162    * @param _A_a1 Argument to be passed on to the method.
 163    * @return The return value of the method invocation.
 164    */
 165   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
 166     { return (_A_obj.*func_ptr_)(_A_a1); }
 167
 168 protected:
 169   function_type func_ptr_;
 170 };
 171
 172 /** mem_functor2 wraps  methods with 2 argument(s).
 173  * Use the convenience function mem_fun() to create an instance of mem_functor2.
 174  *
 175  * The following template arguments are used:
 176  * - @e T_arg1 Argument type used in the definition of operator()().
 177  * - @e T_arg2 Argument type used in the definition of operator()().
 178  * - @e T_return The return type of operator()().
 179  * - @e T_obj The object type.
 180  *
 181  * @ingroup mem_fun
 182  */
 183 template <class T_return, class T_obj, class T_arg1, class T_arg2>
 184 class mem_functor2 : public functor_base
 185 {
 186 public:
 187   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) ;
 188   typedef T_return result_type;
 189
 190   /// Constructs an invalid functor.
 191   mem_functor2() : func_ptr_(nullptr) {}
 192
 193   /** Constructs a mem_functor2 object that wraps the passed method.
 194    * @param _A_func Pointer to method will be invoked from operator()().
 195    */
 196   explicit mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
 197
 198 #ifndef SIGCXX_DISABLE_DEPRECATED
 199   /** Execute the wrapped method operating on the passed instance.
 200    *
 201    * @deprecated Please use the constructor that takes the object by reference
 202    * instead.
 203    *
 204    * @param _A_obj Pointer to instance the method should operate on.
 205    * @param _A_a1 Argument to be passed on to the method.
 206    * @param _A_a2 Argument to be passed on to the method.
 207    * @return The return value of the method invocation.
 208    */
 209   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
 210     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
 211 #endif //SIGCXX_DISABLE_DEPRECATED
 212
 213   /** Execute the wrapped method operating on the passed instance.
 214    * @param _A_obj Reference to instance the method should operate on.
 215    * @param _A_a1 Argument to be passed on to the method.
 216    * @param _A_a2 Argument to be passed on to the method.
 217    * @return The return value of the method invocation.
 218    */
 219   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
 220     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
 221
 222 protected:
 223   function_type func_ptr_;
 224 };
 225
 226 /** mem_functor3 wraps  methods with 3 argument(s).
 227  * Use the convenience function mem_fun() to create an instance of mem_functor3.
 228  *
 229  * The following template arguments are used:
 230  * - @e T_arg1 Argument type used in the definition of operator()().
 231  * - @e T_arg2 Argument type used in the definition of operator()().
 232  * - @e T_arg3 Argument type used in the definition of operator()().
 233  * - @e T_return The return type of operator()().
 234  * - @e T_obj The object type.
 235  *
 236  * @ingroup mem_fun
 237  */
 238 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
 239 class mem_functor3 : public functor_base
 240 {
 241 public:
 242   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) ;
 243   typedef T_return result_type;
 244
 245   /// Constructs an invalid functor.
 246   mem_functor3() : func_ptr_(nullptr) {}
 247
 248   /** Constructs a mem_functor3 object that wraps the passed method.
 249    * @param _A_func Pointer to method will be invoked from operator()().
 250    */
 251   explicit mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
 252
 253 #ifndef SIGCXX_DISABLE_DEPRECATED
 254   /** Execute the wrapped method operating on the passed instance.
 255    *
 256    * @deprecated Please use the constructor that takes the object by reference
 257    * instead.
 258    *
 259    * @param _A_obj Pointer to instance the method should operate on.
 260    * @param _A_a1 Argument to be passed on to the method.
 261    * @param _A_a2 Argument to be passed on to the method.
 262    * @param _A_a3 Argument to be passed on to the method.
 263    * @return The return value of the method invocation.
 264    */
 265   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
 266     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
 267 #endif //SIGCXX_DISABLE_DEPRECATED
 268
 269   /** Execute the wrapped method operating on the passed instance.
 270    * @param _A_obj Reference to instance the method should operate on.
 271    * @param _A_a1 Argument to be passed on to the method.
 272    * @param _A_a2 Argument to be passed on to the method.
 273    * @param _A_a3 Argument to be passed on to the method.
 274    * @return The return value of the method invocation.
 275    */
 276   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
 277     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
 278
 279 protected:
 280   function_type func_ptr_;
 281 };
 282
 283 /** mem_functor4 wraps  methods with 4 argument(s).
 284  * Use the convenience function mem_fun() to create an instance of mem_functor4.
 285  *
 286  * The following template arguments are used:
 287  * - @e T_arg1 Argument type used in the definition of operator()().
 288  * - @e T_arg2 Argument type used in the definition of operator()().
 289  * - @e T_arg3 Argument type used in the definition of operator()().
 290  * - @e T_arg4 Argument type used in the definition of operator()().
 291  * - @e T_return The return type of operator()().
 292  * - @e T_obj The object type.
 293  *
 294  * @ingroup mem_fun
 295  */
 296 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 297 class mem_functor4 : public functor_base
 298 {
 299 public:
 300   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) ;
 301   typedef T_return result_type;
 302
 303   /// Constructs an invalid functor.
 304   mem_functor4() : func_ptr_(nullptr) {}
 305
 306   /** Constructs a mem_functor4 object that wraps the passed method.
 307    * @param _A_func Pointer to method will be invoked from operator()().
 308    */
 309   explicit mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
 310
 311 #ifndef SIGCXX_DISABLE_DEPRECATED
 312   /** Execute the wrapped method operating on the passed instance.
 313    *
 314    * @deprecated Please use the constructor that takes the object by reference
 315    * instead.
 316    *
 317    * @param _A_obj Pointer to instance the method should operate on.
 318    * @param _A_a1 Argument to be passed on to the method.
 319    * @param _A_a2 Argument to be passed on to the method.
 320    * @param _A_a3 Argument to be passed on to the method.
 321    * @param _A_a4 Argument to be passed on to the method.
 322    * @return The return value of the method invocation.
 323    */
 324   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
 325     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
 326 #endif //SIGCXX_DISABLE_DEPRECATED
 327
 328   /** Execute the wrapped method operating on the passed instance.
 329    * @param _A_obj Reference to instance the method should operate on.
 330    * @param _A_a1 Argument to be passed on to the method.
 331    * @param _A_a2 Argument to be passed on to the method.
 332    * @param _A_a3 Argument to be passed on to the method.
 333    * @param _A_a4 Argument to be passed on to the method.
 334    * @return The return value of the method invocation.
 335    */
 336   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
 337     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
 338
 339 protected:
 340   function_type func_ptr_;
 341 };
 342
 343 /** mem_functor5 wraps  methods with 5 argument(s).
 344  * Use the convenience function mem_fun() to create an instance of mem_functor5.
 345  *
 346  * The following template arguments are used:
 347  * - @e T_arg1 Argument type used in the definition of operator()().
 348  * - @e T_arg2 Argument type used in the definition of operator()().
 349  * - @e T_arg3 Argument type used in the definition of operator()().
 350  * - @e T_arg4 Argument type used in the definition of operator()().
 351  * - @e T_arg5 Argument type used in the definition of operator()().
 352  * - @e T_return The return type of operator()().
 353  * - @e T_obj The object type.
 354  *
 355  * @ingroup mem_fun
 356  */
 357 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 358 class mem_functor5 : public functor_base
 359 {
 360 public:
 361   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) ;
 362   typedef T_return result_type;
 363
 364   /// Constructs an invalid functor.
 365   mem_functor5() : func_ptr_(nullptr) {}
 366
 367   /** Constructs a mem_functor5 object that wraps the passed method.
 368    * @param _A_func Pointer to method will be invoked from operator()().
 369    */
 370   explicit mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
 371
 372 #ifndef SIGCXX_DISABLE_DEPRECATED
 373   /** Execute the wrapped method operating on the passed instance.
 374    *
 375    * @deprecated Please use the constructor that takes the object by reference
 376    * instead.
 377    *
 378    * @param _A_obj Pointer to instance the method should operate on.
 379    * @param _A_a1 Argument to be passed on to the method.
 380    * @param _A_a2 Argument to be passed on to the method.
 381    * @param _A_a3 Argument to be passed on to the method.
 382    * @param _A_a4 Argument to be passed on to the method.
 383    * @param _A_a5 Argument to be passed on to the method.
 384    * @return The return value of the method invocation.
 385    */
 386   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
 387     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
 388 #endif //SIGCXX_DISABLE_DEPRECATED
 389
 390   /** Execute the wrapped method operating on the passed instance.
 391    * @param _A_obj Reference to instance the method should operate on.
 392    * @param _A_a1 Argument to be passed on to the method.
 393    * @param _A_a2 Argument to be passed on to the method.
 394    * @param _A_a3 Argument to be passed on to the method.
 395    * @param _A_a4 Argument to be passed on to the method.
 396    * @param _A_a5 Argument to be passed on to the method.
 397    * @return The return value of the method invocation.
 398    */
 399   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
 400     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
 401
 402 protected:
 403   function_type func_ptr_;
 404 };
 405
 406 /** mem_functor6 wraps  methods with 6 argument(s).
 407  * Use the convenience function mem_fun() to create an instance of mem_functor6.
 408  *
 409  * The following template arguments are used:
 410  * - @e T_arg1 Argument type used in the definition of operator()().
 411  * - @e T_arg2 Argument type used in the definition of operator()().
 412  * - @e T_arg3 Argument type used in the definition of operator()().
 413  * - @e T_arg4 Argument type used in the definition of operator()().
 414  * - @e T_arg5 Argument type used in the definition of operator()().
 415  * - @e T_arg6 Argument type used in the definition of operator()().
 416  * - @e T_return The return type of operator()().
 417  * - @e T_obj The object type.
 418  *
 419  * @ingroup mem_fun
 420  */
 421 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 422 class mem_functor6 : public functor_base
 423 {
 424 public:
 425   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) ;
 426   typedef T_return result_type;
 427
 428   /// Constructs an invalid functor.
 429   mem_functor6() : func_ptr_(nullptr) {}
 430
 431   /** Constructs a mem_functor6 object that wraps the passed method.
 432    * @param _A_func Pointer to method will be invoked from operator()().
 433    */
 434   explicit mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
 435
 436 #ifndef SIGCXX_DISABLE_DEPRECATED
 437   /** Execute the wrapped method operating on the passed instance.
 438    *
 439    * @deprecated Please use the constructor that takes the object by reference
 440    * instead.
 441    *
 442    * @param _A_obj Pointer to instance the method should operate on.
 443    * @param _A_a1 Argument to be passed on to the method.
 444    * @param _A_a2 Argument to be passed on to the method.
 445    * @param _A_a3 Argument to be passed on to the method.
 446    * @param _A_a4 Argument to be passed on to the method.
 447    * @param _A_a5 Argument to be passed on to the method.
 448    * @param _A_a6 Argument to be passed on to the method.
 449    * @return The return value of the method invocation.
 450    */
 451   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
 452     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
 453 #endif //SIGCXX_DISABLE_DEPRECATED
 454
 455   /** Execute the wrapped method operating on the passed instance.
 456    * @param _A_obj Reference to instance the method should operate on.
 457    * @param _A_a1 Argument to be passed on to the method.
 458    * @param _A_a2 Argument to be passed on to the method.
 459    * @param _A_a3 Argument to be passed on to the method.
 460    * @param _A_a4 Argument to be passed on to the method.
 461    * @param _A_a5 Argument to be passed on to the method.
 462    * @param _A_a6 Argument to be passed on to the method.
 463    * @return The return value of the method invocation.
 464    */
 465   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
 466     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
 467
 468 protected:
 469   function_type func_ptr_;
 470 };
 471
 472 /** mem_functor7 wraps  methods with 7 argument(s).
 473  * Use the convenience function mem_fun() to create an instance of mem_functor7.
 474  *
 475  * The following template arguments are used:
 476  * - @e T_arg1 Argument type used in the definition of operator()().
 477  * - @e T_arg2 Argument type used in the definition of operator()().
 478  * - @e T_arg3 Argument type used in the definition of operator()().
 479  * - @e T_arg4 Argument type used in the definition of operator()().
 480  * - @e T_arg5 Argument type used in the definition of operator()().
 481  * - @e T_arg6 Argument type used in the definition of operator()().
 482  * - @e T_arg7 Argument type used in the definition of operator()().
 483  * - @e T_return The return type of operator()().
 484  * - @e T_obj The object type.
 485  *
 486  * @ingroup mem_fun
 487  */
 488 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 489 class mem_functor7 : public functor_base
 490 {
 491 public:
 492   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) ;
 493   typedef T_return result_type;
 494
 495   /// Constructs an invalid functor.
 496   mem_functor7() : func_ptr_(nullptr) {}
 497
 498   /** Constructs a mem_functor7 object that wraps the passed method.
 499    * @param _A_func Pointer to method will be invoked from operator()().
 500    */
 501   explicit mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
 502
 503 #ifndef SIGCXX_DISABLE_DEPRECATED
 504   /** Execute the wrapped method operating on the passed instance.
 505    *
 506    * @deprecated Please use the constructor that takes the object by reference
 507    * instead.
 508    *
 509    * @param _A_obj Pointer to instance the method should operate on.
 510    * @param _A_a1 Argument to be passed on to the method.
 511    * @param _A_a2 Argument to be passed on to the method.
 512    * @param _A_a3 Argument to be passed on to the method.
 513    * @param _A_a4 Argument to be passed on to the method.
 514    * @param _A_a5 Argument to be passed on to the method.
 515    * @param _A_a6 Argument to be passed on to the method.
 516    * @param _A_a7 Argument to be passed on to the method.
 517    * @return The return value of the method invocation.
 518    */
 519   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
 520     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
 521 #endif //SIGCXX_DISABLE_DEPRECATED
 522
 523   /** Execute the wrapped method operating on the passed instance.
 524    * @param _A_obj Reference to instance the method should operate on.
 525    * @param _A_a1 Argument to be passed on to the method.
 526    * @param _A_a2 Argument to be passed on to the method.
 527    * @param _A_a3 Argument to be passed on to the method.
 528    * @param _A_a4 Argument to be passed on to the method.
 529    * @param _A_a5 Argument to be passed on to the method.
 530    * @param _A_a6 Argument to be passed on to the method.
 531    * @param _A_a7 Argument to be passed on to the method.
 532    * @return The return value of the method invocation.
 533    */
 534   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
 535     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
 536
 537 protected:
 538   function_type func_ptr_;
 539 };
 540
 541 /** const_mem_functor0 wraps const methods with 0 argument(s).
 542  * Use the convenience function mem_fun() to create an instance of const_mem_functor0.
 543  *
 544  * The following template arguments are used:
 545  * - @e T_return The return type of operator()().
 546  * - @e T_obj The object type.
 547  *
 548  * @ingroup mem_fun
 549  */
 550 template <class T_return, class T_obj>
 551 class const_mem_functor0 : public functor_base
 552 {
 553 public:
 554   typedef T_return (T_obj::*function_type)() const;
 555   typedef T_return result_type;
 556
 557   /// Constructs an invalid functor.
 558   const_mem_functor0() : func_ptr_(nullptr) {}
 559
 560   /** Constructs a const_mem_functor0 object that wraps the passed method.
 561    * @param _A_func Pointer to method will be invoked from operator()().
 562    */
 563   explicit const_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
 564
 565 #ifndef SIGCXX_DISABLE_DEPRECATED
 566   /** Execute the wrapped method operating on the passed instance.
 567    *
 568    * @deprecated Please use the constructor that takes the object by reference
 569    * instead.
 570    *
 571    * @param _A_obj Pointer to instance the method should operate on.
 572    * @return The return value of the method invocation.
 573    */
 574   T_return operator()(const T_obj* _A_obj) const
 575     { return (_A_obj->*(this->func_ptr_))(); }
 576 #endif //SIGCXX_DISABLE_DEPRECATED
 577
 578   /** Execute the wrapped method operating on the passed instance.
 579    * @param _A_obj Reference to instance the method should operate on.
 580    * @return The return value of the method invocation.
 581    */
 582   T_return operator()(const T_obj& _A_obj) const
 583     { return (_A_obj.*func_ptr_)(); }
 584
 585 protected:
 586   function_type func_ptr_;
 587 };
 588
 589 /** const_mem_functor1 wraps const methods with 1 argument(s).
 590  * Use the convenience function mem_fun() to create an instance of const_mem_functor1.
 591  *
 592  * The following template arguments are used:
 593  * - @e T_arg1 Argument type used in the definition of operator()().
 594  * - @e T_return The return type of operator()().
 595  * - @e T_obj The object type.
 596  *
 597  * @ingroup mem_fun
 598  */
 599 template <class T_return, class T_obj, class T_arg1>
 600 class const_mem_functor1 : public functor_base
 601 {
 602 public:
 603   typedef T_return (T_obj::*function_type)(T_arg1) const;
 604   typedef T_return result_type;
 605
 606   /// Constructs an invalid functor.
 607   const_mem_functor1() : func_ptr_(nullptr) {}
 608
 609   /** Constructs a const_mem_functor1 object that wraps the passed method.
 610    * @param _A_func Pointer to method will be invoked from operator()().
 611    */
 612   explicit const_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
 613
 614 #ifndef SIGCXX_DISABLE_DEPRECATED
 615   /** Execute the wrapped method operating on the passed instance.
 616    *
 617    * @deprecated Please use the constructor that takes the object by reference
 618    * instead.
 619    *
 620    * @param _A_obj Pointer to instance the method should operate on.
 621    * @param _A_a1 Argument to be passed on to the method.
 622    * @return The return value of the method invocation.
 623    */
 624   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
 625     { return (_A_obj->*(this->func_ptr_))(_A_a1); }
 626 #endif //SIGCXX_DISABLE_DEPRECATED
 627
 628   /** Execute the wrapped method operating on the passed instance.
 629    * @param _A_obj Reference to instance the method should operate on.
 630    * @param _A_a1 Argument to be passed on to the method.
 631    * @return The return value of the method invocation.
 632    */
 633   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
 634     { return (_A_obj.*func_ptr_)(_A_a1); }
 635
 636 protected:
 637   function_type func_ptr_;
 638 };
 639
 640 /** const_mem_functor2 wraps const methods with 2 argument(s).
 641  * Use the convenience function mem_fun() to create an instance of const_mem_functor2.
 642  *
 643  * The following template arguments are used:
 644  * - @e T_arg1 Argument type used in the definition of operator()().
 645  * - @e T_arg2 Argument type used in the definition of operator()().
 646  * - @e T_return The return type of operator()().
 647  * - @e T_obj The object type.
 648  *
 649  * @ingroup mem_fun
 650  */
 651 template <class T_return, class T_obj, class T_arg1, class T_arg2>
 652 class const_mem_functor2 : public functor_base
 653 {
 654 public:
 655   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) const;
 656   typedef T_return result_type;
 657
 658   /// Constructs an invalid functor.
 659   const_mem_functor2() : func_ptr_(nullptr) {}
 660
 661   /** Constructs a const_mem_functor2 object that wraps the passed method.
 662    * @param _A_func Pointer to method will be invoked from operator()().
 663    */
 664   explicit const_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
 665
 666 #ifndef SIGCXX_DISABLE_DEPRECATED
 667   /** Execute the wrapped method operating on the passed instance.
 668    *
 669    * @deprecated Please use the constructor that takes the object by reference
 670    * instead.
 671    *
 672    * @param _A_obj Pointer to instance the method should operate on.
 673    * @param _A_a1 Argument to be passed on to the method.
 674    * @param _A_a2 Argument to be passed on to the method.
 675    * @return The return value of the method invocation.
 676    */
 677   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
 678     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
 679 #endif //SIGCXX_DISABLE_DEPRECATED
 680
 681   /** Execute the wrapped method operating on the passed instance.
 682    * @param _A_obj Reference to instance the method should operate on.
 683    * @param _A_a1 Argument to be passed on to the method.
 684    * @param _A_a2 Argument to be passed on to the method.
 685    * @return The return value of the method invocation.
 686    */
 687   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
 688     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
 689
 690 protected:
 691   function_type func_ptr_;
 692 };
 693
 694 /** const_mem_functor3 wraps const methods with 3 argument(s).
 695  * Use the convenience function mem_fun() to create an instance of const_mem_functor3.
 696  *
 697  * The following template arguments are used:
 698  * - @e T_arg1 Argument type used in the definition of operator()().
 699  * - @e T_arg2 Argument type used in the definition of operator()().
 700  * - @e T_arg3 Argument type used in the definition of operator()().
 701  * - @e T_return The return type of operator()().
 702  * - @e T_obj The object type.
 703  *
 704  * @ingroup mem_fun
 705  */
 706 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
 707 class const_mem_functor3 : public functor_base
 708 {
 709 public:
 710   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) const;
 711   typedef T_return result_type;
 712
 713   /// Constructs an invalid functor.
 714   const_mem_functor3() : func_ptr_(nullptr) {}
 715
 716   /** Constructs a const_mem_functor3 object that wraps the passed method.
 717    * @param _A_func Pointer to method will be invoked from operator()().
 718    */
 719   explicit const_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
 720
 721 #ifndef SIGCXX_DISABLE_DEPRECATED
 722   /** Execute the wrapped method operating on the passed instance.
 723    *
 724    * @deprecated Please use the constructor that takes the object by reference
 725    * instead.
 726    *
 727    * @param _A_obj Pointer to instance the method should operate on.
 728    * @param _A_a1 Argument to be passed on to the method.
 729    * @param _A_a2 Argument to be passed on to the method.
 730    * @param _A_a3 Argument to be passed on to the method.
 731    * @return The return value of the method invocation.
 732    */
 733   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
 734     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
 735 #endif //SIGCXX_DISABLE_DEPRECATED
 736
 737   /** Execute the wrapped method operating on the passed instance.
 738    * @param _A_obj Reference to instance the method should operate on.
 739    * @param _A_a1 Argument to be passed on to the method.
 740    * @param _A_a2 Argument to be passed on to the method.
 741    * @param _A_a3 Argument to be passed on to the method.
 742    * @return The return value of the method invocation.
 743    */
 744   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
 745     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
 746
 747 protected:
 748   function_type func_ptr_;
 749 };
 750
 751 /** const_mem_functor4 wraps const methods with 4 argument(s).
 752  * Use the convenience function mem_fun() to create an instance of const_mem_functor4.
 753  *
 754  * The following template arguments are used:
 755  * - @e T_arg1 Argument type used in the definition of operator()().
 756  * - @e T_arg2 Argument type used in the definition of operator()().
 757  * - @e T_arg3 Argument type used in the definition of operator()().
 758  * - @e T_arg4 Argument type used in the definition of operator()().
 759  * - @e T_return The return type of operator()().
 760  * - @e T_obj The object type.
 761  *
 762  * @ingroup mem_fun
 763  */
 764 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 765 class const_mem_functor4 : public functor_base
 766 {
 767 public:
 768   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) const;
 769   typedef T_return result_type;
 770
 771   /// Constructs an invalid functor.
 772   const_mem_functor4() : func_ptr_(nullptr) {}
 773
 774   /** Constructs a const_mem_functor4 object that wraps the passed method.
 775    * @param _A_func Pointer to method will be invoked from operator()().
 776    */
 777   explicit const_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
 778
 779 #ifndef SIGCXX_DISABLE_DEPRECATED
 780   /** Execute the wrapped method operating on the passed instance.
 781    *
 782    * @deprecated Please use the constructor that takes the object by reference
 783    * instead.
 784    *
 785    * @param _A_obj Pointer to instance the method should operate on.
 786    * @param _A_a1 Argument to be passed on to the method.
 787    * @param _A_a2 Argument to be passed on to the method.
 788    * @param _A_a3 Argument to be passed on to the method.
 789    * @param _A_a4 Argument to be passed on to the method.
 790    * @return The return value of the method invocation.
 791    */
 792   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
 793     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
 794 #endif //SIGCXX_DISABLE_DEPRECATED
 795
 796   /** Execute the wrapped method operating on the passed instance.
 797    * @param _A_obj Reference to instance the method should operate on.
 798    * @param _A_a1 Argument to be passed on to the method.
 799    * @param _A_a2 Argument to be passed on to the method.
 800    * @param _A_a3 Argument to be passed on to the method.
 801    * @param _A_a4 Argument to be passed on to the method.
 802    * @return The return value of the method invocation.
 803    */
 804   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
 805     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
 806
 807 protected:
 808   function_type func_ptr_;
 809 };
 810
 811 /** const_mem_functor5 wraps const methods with 5 argument(s).
 812  * Use the convenience function mem_fun() to create an instance of const_mem_functor5.
 813  *
 814  * The following template arguments are used:
 815  * - @e T_arg1 Argument type used in the definition of operator()().
 816  * - @e T_arg2 Argument type used in the definition of operator()().
 817  * - @e T_arg3 Argument type used in the definition of operator()().
 818  * - @e T_arg4 Argument type used in the definition of operator()().
 819  * - @e T_arg5 Argument type used in the definition of operator()().
 820  * - @e T_return The return type of operator()().
 821  * - @e T_obj The object type.
 822  *
 823  * @ingroup mem_fun
 824  */
 825 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 826 class const_mem_functor5 : public functor_base
 827 {
 828 public:
 829   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const;
 830   typedef T_return result_type;
 831
 832   /// Constructs an invalid functor.
 833   const_mem_functor5() : func_ptr_(nullptr) {}
 834
 835   /** Constructs a const_mem_functor5 object that wraps the passed method.
 836    * @param _A_func Pointer to method will be invoked from operator()().
 837    */
 838   explicit const_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
 839
 840 #ifndef SIGCXX_DISABLE_DEPRECATED
 841   /** Execute the wrapped method operating on the passed instance.
 842    *
 843    * @deprecated Please use the constructor that takes the object by reference
 844    * instead.
 845    *
 846    * @param _A_obj Pointer to instance the method should operate on.
 847    * @param _A_a1 Argument to be passed on to the method.
 848    * @param _A_a2 Argument to be passed on to the method.
 849    * @param _A_a3 Argument to be passed on to the method.
 850    * @param _A_a4 Argument to be passed on to the method.
 851    * @param _A_a5 Argument to be passed on to the method.
 852    * @return The return value of the method invocation.
 853    */
 854   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
 855     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
 856 #endif //SIGCXX_DISABLE_DEPRECATED
 857
 858   /** Execute the wrapped method operating on the passed instance.
 859    * @param _A_obj Reference to instance the method should operate on.
 860    * @param _A_a1 Argument to be passed on to the method.
 861    * @param _A_a2 Argument to be passed on to the method.
 862    * @param _A_a3 Argument to be passed on to the method.
 863    * @param _A_a4 Argument to be passed on to the method.
 864    * @param _A_a5 Argument to be passed on to the method.
 865    * @return The return value of the method invocation.
 866    */
 867   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
 868     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
 869
 870 protected:
 871   function_type func_ptr_;
 872 };
 873
 874 /** const_mem_functor6 wraps const methods with 6 argument(s).
 875  * Use the convenience function mem_fun() to create an instance of const_mem_functor6.
 876  *
 877  * The following template arguments are used:
 878  * - @e T_arg1 Argument type used in the definition of operator()().
 879  * - @e T_arg2 Argument type used in the definition of operator()().
 880  * - @e T_arg3 Argument type used in the definition of operator()().
 881  * - @e T_arg4 Argument type used in the definition of operator()().
 882  * - @e T_arg5 Argument type used in the definition of operator()().
 883  * - @e T_arg6 Argument type used in the definition of operator()().
 884  * - @e T_return The return type of operator()().
 885  * - @e T_obj The object type.
 886  *
 887  * @ingroup mem_fun
 888  */
 889 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 890 class const_mem_functor6 : public functor_base
 891 {
 892 public:
 893   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const;
 894   typedef T_return result_type;
 895
 896   /// Constructs an invalid functor.
 897   const_mem_functor6() : func_ptr_(nullptr) {}
 898
 899   /** Constructs a const_mem_functor6 object that wraps the passed method.
 900    * @param _A_func Pointer to method will be invoked from operator()().
 901    */
 902   explicit const_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
 903
 904 #ifndef SIGCXX_DISABLE_DEPRECATED
 905   /** Execute the wrapped method operating on the passed instance.
 906    *
 907    * @deprecated Please use the constructor that takes the object by reference
 908    * instead.
 909    *
 910    * @param _A_obj Pointer to instance the method should operate on.
 911    * @param _A_a1 Argument to be passed on to the method.
 912    * @param _A_a2 Argument to be passed on to the method.
 913    * @param _A_a3 Argument to be passed on to the method.
 914    * @param _A_a4 Argument to be passed on to the method.
 915    * @param _A_a5 Argument to be passed on to the method.
 916    * @param _A_a6 Argument to be passed on to the method.
 917    * @return The return value of the method invocation.
 918    */
 919   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
 920     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
 921 #endif //SIGCXX_DISABLE_DEPRECATED
 922
 923   /** Execute the wrapped method operating on the passed instance.
 924    * @param _A_obj Reference to instance the method should operate on.
 925    * @param _A_a1 Argument to be passed on to the method.
 926    * @param _A_a2 Argument to be passed on to the method.
 927    * @param _A_a3 Argument to be passed on to the method.
 928    * @param _A_a4 Argument to be passed on to the method.
 929    * @param _A_a5 Argument to be passed on to the method.
 930    * @param _A_a6 Argument to be passed on to the method.
 931    * @return The return value of the method invocation.
 932    */
 933   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
 934     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
 935
 936 protected:
 937   function_type func_ptr_;
 938 };
 939
 940 /** const_mem_functor7 wraps const methods with 7 argument(s).
 941  * Use the convenience function mem_fun() to create an instance of const_mem_functor7.
 942  *
 943  * The following template arguments are used:
 944  * - @e T_arg1 Argument type used in the definition of operator()().
 945  * - @e T_arg2 Argument type used in the definition of operator()().
 946  * - @e T_arg3 Argument type used in the definition of operator()().
 947  * - @e T_arg4 Argument type used in the definition of operator()().
 948  * - @e T_arg5 Argument type used in the definition of operator()().
 949  * - @e T_arg6 Argument type used in the definition of operator()().
 950  * - @e T_arg7 Argument type used in the definition of operator()().
 951  * - @e T_return The return type of operator()().
 952  * - @e T_obj The object type.
 953  *
 954  * @ingroup mem_fun
 955  */
 956 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 957 class const_mem_functor7 : public functor_base
 958 {
 959 public:
 960   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const;
 961   typedef T_return result_type;
 962
 963   /// Constructs an invalid functor.
 964   const_mem_functor7() : func_ptr_(nullptr) {}
 965
 966   /** Constructs a const_mem_functor7 object that wraps the passed method.
 967    * @param _A_func Pointer to method will be invoked from operator()().
 968    */
 969   explicit const_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
 970
 971 #ifndef SIGCXX_DISABLE_DEPRECATED
 972   /** Execute the wrapped method operating on the passed instance.
 973    *
 974    * @deprecated Please use the constructor that takes the object by reference
 975    * instead.
 976    *
 977    * @param _A_obj Pointer to instance the method should operate on.
 978    * @param _A_a1 Argument to be passed on to the method.
 979    * @param _A_a2 Argument to be passed on to the method.
 980    * @param _A_a3 Argument to be passed on to the method.
 981    * @param _A_a4 Argument to be passed on to the method.
 982    * @param _A_a5 Argument to be passed on to the method.
 983    * @param _A_a6 Argument to be passed on to the method.
 984    * @param _A_a7 Argument to be passed on to the method.
 985    * @return The return value of the method invocation.
 986    */
 987   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
 988     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
 989 #endif //SIGCXX_DISABLE_DEPRECATED
 990
 991   /** Execute the wrapped method operating on the passed instance.
 992    * @param _A_obj Reference to instance the method should operate on.
 993    * @param _A_a1 Argument to be passed on to the method.
 994    * @param _A_a2 Argument to be passed on to the method.
 995    * @param _A_a3 Argument to be passed on to the method.
 996    * @param _A_a4 Argument to be passed on to the method.
 997    * @param _A_a5 Argument to be passed on to the method.
 998    * @param _A_a6 Argument to be passed on to the method.
 999    * @param _A_a7 Argument to be passed on to the method.
1000    * @return The return value of the method invocation.
1001    */
1002   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
1003     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
1004
1005 protected:
1006   function_type func_ptr_;
1007 };
1008
1009 /** volatile_mem_functor0 wraps volatile methods with 0 argument(s).
1010  * Use the convenience function mem_fun() to create an instance of volatile_mem_functor0.
1011  *
1012  * The following template arguments are used:
1013  * - @e T_return The return type of operator()().
1014  * - @e T_obj The object type.
1015  *
1016  * @ingroup mem_fun
1017  */
1018 template <class T_return, class T_obj>
1019 class volatile_mem_functor0 : public functor_base
1020 {
1021 public:
1022   typedef T_return (T_obj::*function_type)() volatile;
1023   typedef T_return result_type;
1024
1025   /// Constructs an invalid functor.
1026   volatile_mem_functor0() : func_ptr_(nullptr) {}
1027
1028   /** Constructs a volatile_mem_functor0 object that wraps the passed method.
1029    * @param _A_func Pointer to method will be invoked from operator()().
1030    */
1031   explicit volatile_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
1032
1033 #ifndef SIGCXX_DISABLE_DEPRECATED
1034   /** Execute the wrapped method operating on the passed instance.
1035    *
1036    * @deprecated Please use the constructor that takes the object by reference
1037    * instead.
1038    *
1039    * @param _A_obj Pointer to instance the method should operate on.
1040    * @return The return value of the method invocation.
1041    */
1042   T_return operator()(T_obj* _A_obj) const
1043     { return (_A_obj->*(this->func_ptr_))(); }
1044 #endif //SIGCXX_DISABLE_DEPRECATED
1045
1046   /** Execute the wrapped method operating on the passed instance.
1047    * @param _A_obj Reference to instance the method should operate on.
1048    * @return The return value of the method invocation.
1049    */
1050   T_return operator()(T_obj& _A_obj) const
1051     { return (_A_obj.*func_ptr_)(); }
1052
1053 protected:
1054   function_type func_ptr_;
1055 };
1056
1057 /** volatile_mem_functor1 wraps volatile methods with 1 argument(s).
1058  * Use the convenience function mem_fun() to create an instance of volatile_mem_functor1.
1059  *
1060  * The following template arguments are used:
1061  * - @e T_arg1 Argument type used in the definition of operator()().
1062  * - @e T_return The return type of operator()().
1063  * - @e T_obj The object type.
1064  *
1065  * @ingroup mem_fun
1066  */
1067 template <class T_return, class T_obj, class T_arg1>
1068 class volatile_mem_functor1 : public functor_base
1069 {
1070 public:
1071   typedef T_return (T_obj::*function_type)(T_arg1) volatile;
1072   typedef T_return result_type;
1073
1074   /// Constructs an invalid functor.
1075   volatile_mem_functor1() : func_ptr_(nullptr) {}
1076
1077   /** Constructs a volatile_mem_functor1 object that wraps the passed method.
1078    * @param _A_func Pointer to method will be invoked from operator()().
1079    */
1080   explicit volatile_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
1081
1082 #ifndef SIGCXX_DISABLE_DEPRECATED
1083   /** Execute the wrapped method operating on the passed instance.
1084    *
1085    * @deprecated Please use the constructor that takes the object by reference
1086    * instead.
1087    *
1088    * @param _A_obj Pointer to instance the method should operate on.
1089    * @param _A_a1 Argument to be passed on to the method.
1090    * @return The return value of the method invocation.
1091    */
1092   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
1093     { return (_A_obj->*(this->func_ptr_))(_A_a1); }
1094 #endif //SIGCXX_DISABLE_DEPRECATED
1095
1096   /** Execute the wrapped method operating on the passed instance.
1097    * @param _A_obj Reference to instance the method should operate on.
1098    * @param _A_a1 Argument to be passed on to the method.
1099    * @return The return value of the method invocation.
1100    */
1101   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
1102     { return (_A_obj.*func_ptr_)(_A_a1); }
1103
1104 protected:
1105   function_type func_ptr_;
1106 };
1107
1108 /** volatile_mem_functor2 wraps volatile methods with 2 argument(s).
1109  * Use the convenience function mem_fun() to create an instance of volatile_mem_functor2.
1110  *
1111  * The following template arguments are used:
1112  * - @e T_arg1 Argument type used in the definition of operator()().
1113  * - @e T_arg2 Argument type used in the definition of operator()().
1114  * - @e T_return The return type of operator()().
1115  * - @e T_obj The object type.
1116  *
1117  * @ingroup mem_fun
1118  */
1119 template <class T_return, class T_obj, class T_arg1, class T_arg2>
1120 class volatile_mem_functor2 : public functor_base
1121 {
1122 public:
1123   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) volatile;
1124   typedef T_return result_type;
1125
1126   /// Constructs an invalid functor.
1127   volatile_mem_functor2() : func_ptr_(nullptr) {}
1128
1129   /** Constructs a volatile_mem_functor2 object that wraps the passed method.
1130    * @param _A_func Pointer to method will be invoked from operator()().
1131    */
1132   explicit volatile_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
1133
1134 #ifndef SIGCXX_DISABLE_DEPRECATED
1135   /** Execute the wrapped method operating on the passed instance.
1136    *
1137    * @deprecated Please use the constructor that takes the object by reference
1138    * instead.
1139    *
1140    * @param _A_obj Pointer to instance the method should operate on.
1141    * @param _A_a1 Argument to be passed on to the method.
1142    * @param _A_a2 Argument to be passed on to the method.
1143    * @return The return value of the method invocation.
1144    */
1145   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
1146     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
1147 #endif //SIGCXX_DISABLE_DEPRECATED
1148
1149   /** Execute the wrapped method operating on the passed instance.
1150    * @param _A_obj Reference to instance the method should operate on.
1151    * @param _A_a1 Argument to be passed on to the method.
1152    * @param _A_a2 Argument to be passed on to the method.
1153    * @return The return value of the method invocation.
1154    */
1155   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
1156     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
1157
1158 protected:
1159   function_type func_ptr_;
1160 };
1161
1162 /** volatile_mem_functor3 wraps volatile methods with 3 argument(s).
1163  * Use the convenience function mem_fun() to create an instance of volatile_mem_functor3.
1164  *
1165  * The following template arguments are used:
1166  * - @e T_arg1 Argument type used in the definition of operator()().
1167  * - @e T_arg2 Argument type used in the definition of operator()().
1168  * - @e T_arg3 Argument type used in the definition of operator()().
1169  * - @e T_return The return type of operator()().
1170  * - @e T_obj The object type.
1171  *
1172  * @ingroup mem_fun
1173  */
1174 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
1175 class volatile_mem_functor3 : public functor_base
1176 {
1177 public:
1178   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) volatile;
1179   typedef T_return result_type;
1180
1181   /// Constructs an invalid functor.
1182   volatile_mem_functor3() : func_ptr_(nullptr) {}
1183
1184   /** Constructs a volatile_mem_functor3 object that wraps the passed method.
1185    * @param _A_func Pointer to method will be invoked from operator()().
1186    */
1187   explicit volatile_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
1188
1189 #ifndef SIGCXX_DISABLE_DEPRECATED
1190   /** Execute the wrapped method operating on the passed instance.
1191    *
1192    * @deprecated Please use the constructor that takes the object by reference
1193    * instead.
1194    *
1195    * @param _A_obj Pointer to instance the method should operate on.
1196    * @param _A_a1 Argument to be passed on to the method.
1197    * @param _A_a2 Argument to be passed on to the method.
1198    * @param _A_a3 Argument to be passed on to the method.
1199    * @return The return value of the method invocation.
1200    */
1201   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
1202     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
1203 #endif //SIGCXX_DISABLE_DEPRECATED
1204
1205   /** Execute the wrapped method operating on the passed instance.
1206    * @param _A_obj Reference to instance the method should operate on.
1207    * @param _A_a1 Argument to be passed on to the method.
1208    * @param _A_a2 Argument to be passed on to the method.
1209    * @param _A_a3 Argument to be passed on to the method.
1210    * @return The return value of the method invocation.
1211    */
1212   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
1213     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
1214
1215 protected:
1216   function_type func_ptr_;
1217 };
1218
1219 /** volatile_mem_functor4 wraps volatile methods with 4 argument(s).
1220  * Use the convenience function mem_fun() to create an instance of volatile_mem_functor4.
1221  *
1222  * The following template arguments are used:
1223  * - @e T_arg1 Argument type used in the definition of operator()().
1224  * - @e T_arg2 Argument type used in the definition of operator()().
1225  * - @e T_arg3 Argument type used in the definition of operator()().
1226  * - @e T_arg4 Argument type used in the definition of operator()().
1227  * - @e T_return The return type of operator()().
1228  * - @e T_obj The object type.
1229  *
1230  * @ingroup mem_fun
1231  */
1232 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
1233 class volatile_mem_functor4 : public functor_base
1234 {
1235 public:
1236   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) volatile;
1237   typedef T_return result_type;
1238
1239   /// Constructs an invalid functor.
1240   volatile_mem_functor4() : func_ptr_(nullptr) {}
1241
1242   /** Constructs a volatile_mem_functor4 object that wraps the passed method.
1243    * @param _A_func Pointer to method will be invoked from operator()().
1244    */
1245   explicit volatile_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
1246
1247 #ifndef SIGCXX_DISABLE_DEPRECATED
1248   /** Execute the wrapped method operating on the passed instance.
1249    *
1250    * @deprecated Please use the constructor that takes the object by reference
1251    * instead.
1252    *
1253    * @param _A_obj Pointer to instance the method should operate on.
1254    * @param _A_a1 Argument to be passed on to the method.
1255    * @param _A_a2 Argument to be passed on to the method.
1256    * @param _A_a3 Argument to be passed on to the method.
1257    * @param _A_a4 Argument to be passed on to the method.
1258    * @return The return value of the method invocation.
1259    */
1260   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
1261     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
1262 #endif //SIGCXX_DISABLE_DEPRECATED
1263
1264   /** Execute the wrapped method operating on the passed instance.
1265    * @param _A_obj Reference to instance the method should operate on.
1266    * @param _A_a1 Argument to be passed on to the method.
1267    * @param _A_a2 Argument to be passed on to the method.
1268    * @param _A_a3 Argument to be passed on to the method.
1269    * @param _A_a4 Argument to be passed on to the method.
1270    * @return The return value of the method invocation.
1271    */
1272   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
1273     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
1274
1275 protected:
1276   function_type func_ptr_;
1277 };
1278
1279 /** volatile_mem_functor5 wraps volatile methods with 5 argument(s).
1280  * Use the convenience function mem_fun() to create an instance of volatile_mem_functor5.
1281  *
1282  * The following template arguments are used:
1283  * - @e T_arg1 Argument type used in the definition of operator()().
1284  * - @e T_arg2 Argument type used in the definition of operator()().
1285  * - @e T_arg3 Argument type used in the definition of operator()().
1286  * - @e T_arg4 Argument type used in the definition of operator()().
1287  * - @e T_arg5 Argument type used in the definition of operator()().
1288  * - @e T_return The return type of operator()().
1289  * - @e T_obj The object type.
1290  *
1291  * @ingroup mem_fun
1292  */
1293 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
1294 class volatile_mem_functor5 : public functor_base
1295 {
1296 public:
1297   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile;
1298   typedef T_return result_type;
1299
1300   /// Constructs an invalid functor.
1301   volatile_mem_functor5() : func_ptr_(nullptr) {}
1302
1303   /** Constructs a volatile_mem_functor5 object that wraps the passed method.
1304    * @param _A_func Pointer to method will be invoked from operator()().
1305    */
1306   explicit volatile_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
1307
1308 #ifndef SIGCXX_DISABLE_DEPRECATED
1309   /** Execute the wrapped method operating on the passed instance.
1310    *
1311    * @deprecated Please use the constructor that takes the object by reference
1312    * instead.
1313    *
1314    * @param _A_obj Pointer to instance the method should operate on.
1315    * @param _A_a1 Argument to be passed on to the method.
1316    * @param _A_a2 Argument to be passed on to the method.
1317    * @param _A_a3 Argument to be passed on to the method.
1318    * @param _A_a4 Argument to be passed on to the method.
1319    * @param _A_a5 Argument to be passed on to the method.
1320    * @return The return value of the method invocation.
1321    */
1322   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
1323     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
1324 #endif //SIGCXX_DISABLE_DEPRECATED
1325
1326   /** Execute the wrapped method operating on the passed instance.
1327    * @param _A_obj Reference to instance the method should operate on.
1328    * @param _A_a1 Argument to be passed on to the method.
1329    * @param _A_a2 Argument to be passed on to the method.
1330    * @param _A_a3 Argument to be passed on to the method.
1331    * @param _A_a4 Argument to be passed on to the method.
1332    * @param _A_a5 Argument to be passed on to the method.
1333    * @return The return value of the method invocation.
1334    */
1335   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
1336     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
1337
1338 protected:
1339   function_type func_ptr_;
1340 };
1341
1342 /** volatile_mem_functor6 wraps volatile methods with 6 argument(s).
1343  * Use the convenience function mem_fun() to create an instance of volatile_mem_functor6.
1344  *
1345  * The following template arguments are used:
1346  * - @e T_arg1 Argument type used in the definition of operator()().
1347  * - @e T_arg2 Argument type used in the definition of operator()().
1348  * - @e T_arg3 Argument type used in the definition of operator()().
1349  * - @e T_arg4 Argument type used in the definition of operator()().
1350  * - @e T_arg5 Argument type used in the definition of operator()().
1351  * - @e T_arg6 Argument type used in the definition of operator()().
1352  * - @e T_return The return type of operator()().
1353  * - @e T_obj The object type.
1354  *
1355  * @ingroup mem_fun
1356  */
1357 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
1358 class volatile_mem_functor6 : public functor_base
1359 {
1360 public:
1361   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile;
1362   typedef T_return result_type;
1363
1364   /// Constructs an invalid functor.
1365   volatile_mem_functor6() : func_ptr_(nullptr) {}
1366
1367   /** Constructs a volatile_mem_functor6 object that wraps the passed method.
1368    * @param _A_func Pointer to method will be invoked from operator()().
1369    */
1370   explicit volatile_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
1371
1372 #ifndef SIGCXX_DISABLE_DEPRECATED
1373   /** Execute the wrapped method operating on the passed instance.
1374    *
1375    * @deprecated Please use the constructor that takes the object by reference
1376    * instead.
1377    *
1378    * @param _A_obj Pointer to instance the method should operate on.
1379    * @param _A_a1 Argument to be passed on to the method.
1380    * @param _A_a2 Argument to be passed on to the method.
1381    * @param _A_a3 Argument to be passed on to the method.
1382    * @param _A_a4 Argument to be passed on to the method.
1383    * @param _A_a5 Argument to be passed on to the method.
1384    * @param _A_a6 Argument to be passed on to the method.
1385    * @return The return value of the method invocation.
1386    */
1387   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
1388     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
1389 #endif //SIGCXX_DISABLE_DEPRECATED
1390
1391   /** Execute the wrapped method operating on the passed instance.
1392    * @param _A_obj Reference to instance the method should operate on.
1393    * @param _A_a1 Argument to be passed on to the method.
1394    * @param _A_a2 Argument to be passed on to the method.
1395    * @param _A_a3 Argument to be passed on to the method.
1396    * @param _A_a4 Argument to be passed on to the method.
1397    * @param _A_a5 Argument to be passed on to the method.
1398    * @param _A_a6 Argument to be passed on to the method.
1399    * @return The return value of the method invocation.
1400    */
1401   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
1402     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
1403
1404 protected:
1405   function_type func_ptr_;
1406 };
1407
1408 /** volatile_mem_functor7 wraps volatile methods with 7 argument(s).
1409  * Use the convenience function mem_fun() to create an instance of volatile_mem_functor7.
1410  *
1411  * The following template arguments are used:
1412  * - @e T_arg1 Argument type used in the definition of operator()().
1413  * - @e T_arg2 Argument type used in the definition of operator()().
1414  * - @e T_arg3 Argument type used in the definition of operator()().
1415  * - @e T_arg4 Argument type used in the definition of operator()().
1416  * - @e T_arg5 Argument type used in the definition of operator()().
1417  * - @e T_arg6 Argument type used in the definition of operator()().
1418  * - @e T_arg7 Argument type used in the definition of operator()().
1419  * - @e T_return The return type of operator()().
1420  * - @e T_obj The object type.
1421  *
1422  * @ingroup mem_fun
1423  */
1424 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1425 class volatile_mem_functor7 : public functor_base
1426 {
1427 public:
1428   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile;
1429   typedef T_return result_type;
1430
1431   /// Constructs an invalid functor.
1432   volatile_mem_functor7() : func_ptr_(nullptr) {}
1433
1434   /** Constructs a volatile_mem_functor7 object that wraps the passed method.
1435    * @param _A_func Pointer to method will be invoked from operator()().
1436    */
1437   explicit volatile_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
1438
1439 #ifndef SIGCXX_DISABLE_DEPRECATED
1440   /** Execute the wrapped method operating on the passed instance.
1441    *
1442    * @deprecated Please use the constructor that takes the object by reference
1443    * instead.
1444    *
1445    * @param _A_obj Pointer to instance the method should operate on.
1446    * @param _A_a1 Argument to be passed on to the method.
1447    * @param _A_a2 Argument to be passed on to the method.
1448    * @param _A_a3 Argument to be passed on to the method.
1449    * @param _A_a4 Argument to be passed on to the method.
1450    * @param _A_a5 Argument to be passed on to the method.
1451    * @param _A_a6 Argument to be passed on to the method.
1452    * @param _A_a7 Argument to be passed on to the method.
1453    * @return The return value of the method invocation.
1454    */
1455   T_return operator()(T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
1456     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
1457 #endif //SIGCXX_DISABLE_DEPRECATED
1458
1459   /** Execute the wrapped method operating on the passed instance.
1460    * @param _A_obj Reference to instance the method should operate on.
1461    * @param _A_a1 Argument to be passed on to the method.
1462    * @param _A_a2 Argument to be passed on to the method.
1463    * @param _A_a3 Argument to be passed on to the method.
1464    * @param _A_a4 Argument to be passed on to the method.
1465    * @param _A_a5 Argument to be passed on to the method.
1466    * @param _A_a6 Argument to be passed on to the method.
1467    * @param _A_a7 Argument to be passed on to the method.
1468    * @return The return value of the method invocation.
1469    */
1470   T_return operator()(T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
1471     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
1472
1473 protected:
1474   function_type func_ptr_;
1475 };
1476
1477 /** const_volatile_mem_functor0 wraps const volatile methods with 0 argument(s).
1478  * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor0.
1479  *
1480  * The following template arguments are used:
1481  * - @e T_return The return type of operator()().
1482  * - @e T_obj The object type.
1483  *
1484  * @ingroup mem_fun
1485  */
1486 template <class T_return, class T_obj>
1487 class const_volatile_mem_functor0 : public functor_base
1488 {
1489 public:
1490   typedef T_return (T_obj::*function_type)() const volatile;
1491   typedef T_return result_type;
1492
1493   /// Constructs an invalid functor.
1494   const_volatile_mem_functor0() : func_ptr_(nullptr) {}
1495
1496   /** Constructs a const_volatile_mem_functor0 object that wraps the passed method.
1497    * @param _A_func Pointer to method will be invoked from operator()().
1498    */
1499   explicit const_volatile_mem_functor0(function_type _A_func) : func_ptr_(_A_func) {}
1500
1501 #ifndef SIGCXX_DISABLE_DEPRECATED
1502   /** Execute the wrapped method operating on the passed instance.
1503    *
1504    * @deprecated Please use the constructor that takes the object by reference
1505    * instead.
1506    *
1507    * @param _A_obj Pointer to instance the method should operate on.
1508    * @return The return value of the method invocation.
1509    */
1510   T_return operator()(const T_obj* _A_obj) const
1511     { return (_A_obj->*(this->func_ptr_))(); }
1512 #endif //SIGCXX_DISABLE_DEPRECATED
1513
1514   /** Execute the wrapped method operating on the passed instance.
1515    * @param _A_obj Reference to instance the method should operate on.
1516    * @return The return value of the method invocation.
1517    */
1518   T_return operator()(const T_obj& _A_obj) const
1519     { return (_A_obj.*func_ptr_)(); }
1520
1521 protected:
1522   function_type func_ptr_;
1523 };
1524
1525 /** const_volatile_mem_functor1 wraps const volatile methods with 1 argument(s).
1526  * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor1.
1527  *
1528  * The following template arguments are used:
1529  * - @e T_arg1 Argument type used in the definition of operator()().
1530  * - @e T_return The return type of operator()().
1531  * - @e T_obj The object type.
1532  *
1533  * @ingroup mem_fun
1534  */
1535 template <class T_return, class T_obj, class T_arg1>
1536 class const_volatile_mem_functor1 : public functor_base
1537 {
1538 public:
1539   typedef T_return (T_obj::*function_type)(T_arg1) const volatile;
1540   typedef T_return result_type;
1541
1542   /// Constructs an invalid functor.
1543   const_volatile_mem_functor1() : func_ptr_(nullptr) {}
1544
1545   /** Constructs a const_volatile_mem_functor1 object that wraps the passed method.
1546    * @param _A_func Pointer to method will be invoked from operator()().
1547    */
1548   explicit const_volatile_mem_functor1(function_type _A_func) : func_ptr_(_A_func) {}
1549
1550 #ifndef SIGCXX_DISABLE_DEPRECATED
1551   /** Execute the wrapped method operating on the passed instance.
1552    *
1553    * @deprecated Please use the constructor that takes the object by reference
1554    * instead.
1555    *
1556    * @param _A_obj Pointer to instance the method should operate on.
1557    * @param _A_a1 Argument to be passed on to the method.
1558    * @return The return value of the method invocation.
1559    */
1560   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1) const
1561     { return (_A_obj->*(this->func_ptr_))(_A_a1); }
1562 #endif //SIGCXX_DISABLE_DEPRECATED
1563
1564   /** Execute the wrapped method operating on the passed instance.
1565    * @param _A_obj Reference to instance the method should operate on.
1566    * @param _A_a1 Argument to be passed on to the method.
1567    * @return The return value of the method invocation.
1568    */
1569   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1) const
1570     { return (_A_obj.*func_ptr_)(_A_a1); }
1571
1572 protected:
1573   function_type func_ptr_;
1574 };
1575
1576 /** const_volatile_mem_functor2 wraps const volatile methods with 2 argument(s).
1577  * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor2.
1578  *
1579  * The following template arguments are used:
1580  * - @e T_arg1 Argument type used in the definition of operator()().
1581  * - @e T_arg2 Argument type used in the definition of operator()().
1582  * - @e T_return The return type of operator()().
1583  * - @e T_obj The object type.
1584  *
1585  * @ingroup mem_fun
1586  */
1587 template <class T_return, class T_obj, class T_arg1, class T_arg2>
1588 class const_volatile_mem_functor2 : public functor_base
1589 {
1590 public:
1591   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2) const volatile;
1592   typedef T_return result_type;
1593
1594   /// Constructs an invalid functor.
1595   const_volatile_mem_functor2() : func_ptr_(nullptr) {}
1596
1597   /** Constructs a const_volatile_mem_functor2 object that wraps the passed method.
1598    * @param _A_func Pointer to method will be invoked from operator()().
1599    */
1600   explicit const_volatile_mem_functor2(function_type _A_func) : func_ptr_(_A_func) {}
1601
1602 #ifndef SIGCXX_DISABLE_DEPRECATED
1603   /** Execute the wrapped method operating on the passed instance.
1604    *
1605    * @deprecated Please use the constructor that takes the object by reference
1606    * instead.
1607    *
1608    * @param _A_obj Pointer to instance the method should operate on.
1609    * @param _A_a1 Argument to be passed on to the method.
1610    * @param _A_a2 Argument to be passed on to the method.
1611    * @return The return value of the method invocation.
1612    */
1613   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
1614     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2); }
1615 #endif //SIGCXX_DISABLE_DEPRECATED
1616
1617   /** Execute the wrapped method operating on the passed instance.
1618    * @param _A_obj Reference to instance the method should operate on.
1619    * @param _A_a1 Argument to be passed on to the method.
1620    * @param _A_a2 Argument to be passed on to the method.
1621    * @return The return value of the method invocation.
1622    */
1623   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
1624     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2); }
1625
1626 protected:
1627   function_type func_ptr_;
1628 };
1629
1630 /** const_volatile_mem_functor3 wraps const volatile methods with 3 argument(s).
1631  * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor3.
1632  *
1633  * The following template arguments are used:
1634  * - @e T_arg1 Argument type used in the definition of operator()().
1635  * - @e T_arg2 Argument type used in the definition of operator()().
1636  * - @e T_arg3 Argument type used in the definition of operator()().
1637  * - @e T_return The return type of operator()().
1638  * - @e T_obj The object type.
1639  *
1640  * @ingroup mem_fun
1641  */
1642 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
1643 class const_volatile_mem_functor3 : public functor_base
1644 {
1645 public:
1646   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3) const volatile;
1647   typedef T_return result_type;
1648
1649   /// Constructs an invalid functor.
1650   const_volatile_mem_functor3() : func_ptr_(nullptr) {}
1651
1652   /** Constructs a const_volatile_mem_functor3 object that wraps the passed method.
1653    * @param _A_func Pointer to method will be invoked from operator()().
1654    */
1655   explicit const_volatile_mem_functor3(function_type _A_func) : func_ptr_(_A_func) {}
1656
1657 #ifndef SIGCXX_DISABLE_DEPRECATED
1658   /** Execute the wrapped method operating on the passed instance.
1659    *
1660    * @deprecated Please use the constructor that takes the object by reference
1661    * instead.
1662    *
1663    * @param _A_obj Pointer to instance the method should operate on.
1664    * @param _A_a1 Argument to be passed on to the method.
1665    * @param _A_a2 Argument to be passed on to the method.
1666    * @param _A_a3 Argument to be passed on to the method.
1667    * @return The return value of the method invocation.
1668    */
1669   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
1670     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
1671 #endif //SIGCXX_DISABLE_DEPRECATED
1672
1673   /** Execute the wrapped method operating on the passed instance.
1674    * @param _A_obj Reference to instance the method should operate on.
1675    * @param _A_a1 Argument to be passed on to the method.
1676    * @param _A_a2 Argument to be passed on to the method.
1677    * @param _A_a3 Argument to be passed on to the method.
1678    * @return The return value of the method invocation.
1679    */
1680   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
1681     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3); }
1682
1683 protected:
1684   function_type func_ptr_;
1685 };
1686
1687 /** const_volatile_mem_functor4 wraps const volatile methods with 4 argument(s).
1688  * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor4.
1689  *
1690  * The following template arguments are used:
1691  * - @e T_arg1 Argument type used in the definition of operator()().
1692  * - @e T_arg2 Argument type used in the definition of operator()().
1693  * - @e T_arg3 Argument type used in the definition of operator()().
1694  * - @e T_arg4 Argument type used in the definition of operator()().
1695  * - @e T_return The return type of operator()().
1696  * - @e T_obj The object type.
1697  *
1698  * @ingroup mem_fun
1699  */
1700 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
1701 class const_volatile_mem_functor4 : public functor_base
1702 {
1703 public:
1704   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile;
1705   typedef T_return result_type;
1706
1707   /// Constructs an invalid functor.
1708   const_volatile_mem_functor4() : func_ptr_(nullptr) {}
1709
1710   /** Constructs a const_volatile_mem_functor4 object that wraps the passed method.
1711    * @param _A_func Pointer to method will be invoked from operator()().
1712    */
1713   explicit const_volatile_mem_functor4(function_type _A_func) : func_ptr_(_A_func) {}
1714
1715 #ifndef SIGCXX_DISABLE_DEPRECATED
1716   /** Execute the wrapped method operating on the passed instance.
1717    *
1718    * @deprecated Please use the constructor that takes the object by reference
1719    * instead.
1720    *
1721    * @param _A_obj Pointer to instance the method should operate on.
1722    * @param _A_a1 Argument to be passed on to the method.
1723    * @param _A_a2 Argument to be passed on to the method.
1724    * @param _A_a3 Argument to be passed on to the method.
1725    * @param _A_a4 Argument to be passed on to the method.
1726    * @return The return value of the method invocation.
1727    */
1728   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
1729     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
1730 #endif //SIGCXX_DISABLE_DEPRECATED
1731
1732   /** Execute the wrapped method operating on the passed instance.
1733    * @param _A_obj Reference to instance the method should operate on.
1734    * @param _A_a1 Argument to be passed on to the method.
1735    * @param _A_a2 Argument to be passed on to the method.
1736    * @param _A_a3 Argument to be passed on to the method.
1737    * @param _A_a4 Argument to be passed on to the method.
1738    * @return The return value of the method invocation.
1739    */
1740   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
1741     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4); }
1742
1743 protected:
1744   function_type func_ptr_;
1745 };
1746
1747 /** const_volatile_mem_functor5 wraps const volatile methods with 5 argument(s).
1748  * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor5.
1749  *
1750  * The following template arguments are used:
1751  * - @e T_arg1 Argument type used in the definition of operator()().
1752  * - @e T_arg2 Argument type used in the definition of operator()().
1753  * - @e T_arg3 Argument type used in the definition of operator()().
1754  * - @e T_arg4 Argument type used in the definition of operator()().
1755  * - @e T_arg5 Argument type used in the definition of operator()().
1756  * - @e T_return The return type of operator()().
1757  * - @e T_obj The object type.
1758  *
1759  * @ingroup mem_fun
1760  */
1761 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
1762 class const_volatile_mem_functor5 : public functor_base
1763 {
1764 public:
1765   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile;
1766   typedef T_return result_type;
1767
1768   /// Constructs an invalid functor.
1769   const_volatile_mem_functor5() : func_ptr_(nullptr) {}
1770
1771   /** Constructs a const_volatile_mem_functor5 object that wraps the passed method.
1772    * @param _A_func Pointer to method will be invoked from operator()().
1773    */
1774   explicit const_volatile_mem_functor5(function_type _A_func) : func_ptr_(_A_func) {}
1775
1776 #ifndef SIGCXX_DISABLE_DEPRECATED
1777   /** Execute the wrapped method operating on the passed instance.
1778    *
1779    * @deprecated Please use the constructor that takes the object by reference
1780    * instead.
1781    *
1782    * @param _A_obj Pointer to instance the method should operate on.
1783    * @param _A_a1 Argument to be passed on to the method.
1784    * @param _A_a2 Argument to be passed on to the method.
1785    * @param _A_a3 Argument to be passed on to the method.
1786    * @param _A_a4 Argument to be passed on to the method.
1787    * @param _A_a5 Argument to be passed on to the method.
1788    * @return The return value of the method invocation.
1789    */
1790   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
1791     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
1792 #endif //SIGCXX_DISABLE_DEPRECATED
1793
1794   /** Execute the wrapped method operating on the passed instance.
1795    * @param _A_obj Reference to instance the method should operate on.
1796    * @param _A_a1 Argument to be passed on to the method.
1797    * @param _A_a2 Argument to be passed on to the method.
1798    * @param _A_a3 Argument to be passed on to the method.
1799    * @param _A_a4 Argument to be passed on to the method.
1800    * @param _A_a5 Argument to be passed on to the method.
1801    * @return The return value of the method invocation.
1802    */
1803   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
1804     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
1805
1806 protected:
1807   function_type func_ptr_;
1808 };
1809
1810 /** const_volatile_mem_functor6 wraps const volatile methods with 6 argument(s).
1811  * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor6.
1812  *
1813  * The following template arguments are used:
1814  * - @e T_arg1 Argument type used in the definition of operator()().
1815  * - @e T_arg2 Argument type used in the definition of operator()().
1816  * - @e T_arg3 Argument type used in the definition of operator()().
1817  * - @e T_arg4 Argument type used in the definition of operator()().
1818  * - @e T_arg5 Argument type used in the definition of operator()().
1819  * - @e T_arg6 Argument type used in the definition of operator()().
1820  * - @e T_return The return type of operator()().
1821  * - @e T_obj The object type.
1822  *
1823  * @ingroup mem_fun
1824  */
1825 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
1826 class const_volatile_mem_functor6 : public functor_base
1827 {
1828 public:
1829   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile;
1830   typedef T_return result_type;
1831
1832   /// Constructs an invalid functor.
1833   const_volatile_mem_functor6() : func_ptr_(nullptr) {}
1834
1835   /** Constructs a const_volatile_mem_functor6 object that wraps the passed method.
1836    * @param _A_func Pointer to method will be invoked from operator()().
1837    */
1838   explicit const_volatile_mem_functor6(function_type _A_func) : func_ptr_(_A_func) {}
1839
1840 #ifndef SIGCXX_DISABLE_DEPRECATED
1841   /** Execute the wrapped method operating on the passed instance.
1842    *
1843    * @deprecated Please use the constructor that takes the object by reference
1844    * instead.
1845    *
1846    * @param _A_obj Pointer to instance the method should operate on.
1847    * @param _A_a1 Argument to be passed on to the method.
1848    * @param _A_a2 Argument to be passed on to the method.
1849    * @param _A_a3 Argument to be passed on to the method.
1850    * @param _A_a4 Argument to be passed on to the method.
1851    * @param _A_a5 Argument to be passed on to the method.
1852    * @param _A_a6 Argument to be passed on to the method.
1853    * @return The return value of the method invocation.
1854    */
1855   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
1856     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
1857 #endif //SIGCXX_DISABLE_DEPRECATED
1858
1859   /** Execute the wrapped method operating on the passed instance.
1860    * @param _A_obj Reference to instance the method should operate on.
1861    * @param _A_a1 Argument to be passed on to the method.
1862    * @param _A_a2 Argument to be passed on to the method.
1863    * @param _A_a3 Argument to be passed on to the method.
1864    * @param _A_a4 Argument to be passed on to the method.
1865    * @param _A_a5 Argument to be passed on to the method.
1866    * @param _A_a6 Argument to be passed on to the method.
1867    * @return The return value of the method invocation.
1868    */
1869   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
1870     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
1871
1872 protected:
1873   function_type func_ptr_;
1874 };
1875
1876 /** const_volatile_mem_functor7 wraps const volatile methods with 7 argument(s).
1877  * Use the convenience function mem_fun() to create an instance of const_volatile_mem_functor7.
1878  *
1879  * The following template arguments are used:
1880  * - @e T_arg1 Argument type used in the definition of operator()().
1881  * - @e T_arg2 Argument type used in the definition of operator()().
1882  * - @e T_arg3 Argument type used in the definition of operator()().
1883  * - @e T_arg4 Argument type used in the definition of operator()().
1884  * - @e T_arg5 Argument type used in the definition of operator()().
1885  * - @e T_arg6 Argument type used in the definition of operator()().
1886  * - @e T_arg7 Argument type used in the definition of operator()().
1887  * - @e T_return The return type of operator()().
1888  * - @e T_obj The object type.
1889  *
1890  * @ingroup mem_fun
1891  */
1892 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1893 class const_volatile_mem_functor7 : public functor_base
1894 {
1895 public:
1896   typedef T_return (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile;
1897   typedef T_return result_type;
1898
1899   /// Constructs an invalid functor.
1900   const_volatile_mem_functor7() : func_ptr_(nullptr) {}
1901
1902   /** Constructs a const_volatile_mem_functor7 object that wraps the passed method.
1903    * @param _A_func Pointer to method will be invoked from operator()().
1904    */
1905   explicit const_volatile_mem_functor7(function_type _A_func) : func_ptr_(_A_func) {}
1906
1907 #ifndef SIGCXX_DISABLE_DEPRECATED
1908   /** Execute the wrapped method operating on the passed instance.
1909    *
1910    * @deprecated Please use the constructor that takes the object by reference
1911    * instead.
1912    *
1913    * @param _A_obj Pointer to instance the method should operate on.
1914    * @param _A_a1 Argument to be passed on to the method.
1915    * @param _A_a2 Argument to be passed on to the method.
1916    * @param _A_a3 Argument to be passed on to the method.
1917    * @param _A_a4 Argument to be passed on to the method.
1918    * @param _A_a5 Argument to be passed on to the method.
1919    * @param _A_a6 Argument to be passed on to the method.
1920    * @param _A_a7 Argument to be passed on to the method.
1921    * @return The return value of the method invocation.
1922    */
1923   T_return operator()(const T_obj* _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
1924     { return (_A_obj->*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
1925 #endif //SIGCXX_DISABLE_DEPRECATED
1926
1927   /** Execute the wrapped method operating on the passed instance.
1928    * @param _A_obj Reference to instance the method should operate on.
1929    * @param _A_a1 Argument to be passed on to the method.
1930    * @param _A_a2 Argument to be passed on to the method.
1931    * @param _A_a3 Argument to be passed on to the method.
1932    * @param _A_a4 Argument to be passed on to the method.
1933    * @param _A_a5 Argument to be passed on to the method.
1934    * @param _A_a6 Argument to be passed on to the method.
1935    * @param _A_a7 Argument to be passed on to the method.
1936    * @return The return value of the method invocation.
1937    */
1938   T_return operator()(const T_obj& _A_obj, type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
1939     { return (_A_obj.*func_ptr_)(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
1940
1941 protected:
1942   function_type func_ptr_;
1943 };
1944
1945
1946 /** bound_mem_functor0 encapsulates a  method with 0 arguments and an object instance.
1947  * Use the convenience function mem_fun() to create an instance of bound_mem_functor0.
1948  *
1949  * The following template arguments are used:
1950  * - @e T_return The return type of operator()().
1951  * - @e T_obj The object type.
1952  *
1953  * @ingroup mem_fun
1954  */
1955 template <class T_return, class T_obj>
1956 class bound_mem_functor0
1957   : public mem_functor0<T_return, T_obj>
1958 {
1959   typedef mem_functor0<T_return, T_obj> base_type_;
1960 public:
1961   typedef typename base_type_::function_type function_type;
1962
1963 #ifndef SIGCXX_DISABLE_DEPRECATED
1964   /** Constructs a bound_mem_functor0 object that wraps the passed method.
1965    *
1966    * @deprecated Please use the constructor that takes the object by reference
1967    * instead.
1968    *
1969    * @param _A_obj Pointer to instance the method will operate on.
1970    * @param _A_func Pointer to method will be invoked from operator()().
1971    */
1972   bound_mem_functor0( T_obj* _A_obj, function_type _A_func)
1973     : base_type_(_A_func),
1974       obj_(*_A_obj)
1975     {}
1976 #endif // SIGCXX_DISABLE_DEPRECATED
1977
1978   /** Constructs a bound_mem_functor0 object that wraps the passed method.
1979    * @param _A_obj Reference to instance the method will operate on.
1980    * @param _A_func Pointer to method will be invoked from operator()().
1981    */
1982   bound_mem_functor0( T_obj& _A_obj, function_type _A_func)
1983     : base_type_(_A_func),
1984       obj_(_A_obj)
1985     {}
1986
1987   /** Execute the wrapped method operating on the stored instance.
1988    * @return The return value of the method invocation.
1989    */
1990   T_return operator()() const
1991     { return (obj_.invoke().*(this->func_ptr_))(); }
1992
1993 //protected:
1994   // Reference to stored object instance.
1995   // This is the handler object, such as TheObject in void TheObject::signal_handler().
1996   limit_reference<T_obj> obj_;
1997 };
1998
1999 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2000 //template specialization of visitor<>::do_visit_each<>(action, functor):
2001 /** Performs a functor on each of the targets of a functor.
2002  * The function overload for sigc::bound_mem_functor performs a functor
2003  * on the object instance stored in the sigc::bound_mem_functor object.
2004  *
2005  * @ingroup mem_fun
2006  */
2007 template <class T_return, class T_obj>
2008 struct visitor<bound_mem_functor0<T_return, T_obj> >
2009 {
2010   template <class T_action>
2011   static void do_visit_each(const T_action& _A_action,
2012                             const bound_mem_functor0<T_return, T_obj>& _A_target)
2013   {
2014     sigc::visit_each(_A_action, _A_target.obj_);
2015   }
2016 };
2017 #endif // DOXYGEN_SHOULD_SKIP_THIS
2018
2019 /** bound_mem_functor1 encapsulates a  method with 1 arguments and an object instance.
2020  * Use the convenience function mem_fun() to create an instance of bound_mem_functor1.
2021  *
2022  * The following template arguments are used:
2023  * - @e T_arg1 Argument type used in the definition of operator()().
2024  * - @e T_return The return type of operator()().
2025  * - @e T_obj The object type.
2026  *
2027  * @ingroup mem_fun
2028  */
2029 template <class T_return, class T_obj, class T_arg1>
2030 class bound_mem_functor1
2031   : public mem_functor1<T_return, T_obj, T_arg1>
2032 {
2033   typedef mem_functor1<T_return, T_obj, T_arg1> base_type_;
2034 public:
2035   typedef typename base_type_::function_type function_type;
2036
2037 #ifndef SIGCXX_DISABLE_DEPRECATED
2038   /** Constructs a bound_mem_functor1 object that wraps the passed method.
2039    *
2040    * @deprecated Please use the constructor that takes the object by reference
2041    * instead.
2042    *
2043    * @param _A_obj Pointer to instance the method will operate on.
2044    * @param _A_func Pointer to method will be invoked from operator()().
2045    */
2046   bound_mem_functor1( T_obj* _A_obj, function_type _A_func)
2047     : base_type_(_A_func),
2048       obj_(*_A_obj)
2049     {}
2050 #endif // SIGCXX_DISABLE_DEPRECATED
2051
2052   /** Constructs a bound_mem_functor1 object that wraps the passed method.
2053    * @param _A_obj Reference to instance the method will operate on.
2054    * @param _A_func Pointer to method will be invoked from operator()().
2055    */
2056   bound_mem_functor1( T_obj& _A_obj, function_type _A_func)
2057     : base_type_(_A_func),
2058       obj_(_A_obj)
2059     {}
2060
2061   /** Execute the wrapped method operating on the stored instance.
2062    * @param _A_a1 Argument to be passed on to the method.
2063    * @return The return value of the method invocation.
2064    */
2065   T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
2066     { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
2067
2068 //protected:
2069   // Reference to stored object instance.
2070   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2071   limit_reference<T_obj> obj_;
2072 };
2073
2074 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2075 //template specialization of visitor<>::do_visit_each<>(action, functor):
2076 /** Performs a functor on each of the targets of a functor.
2077  * The function overload for sigc::bound_mem_functor performs a functor
2078  * on the object instance stored in the sigc::bound_mem_functor object.
2079  *
2080  * @ingroup mem_fun
2081  */
2082 template <class T_return, class T_obj, class T_arg1>
2083 struct visitor<bound_mem_functor1<T_return, T_obj, T_arg1> >
2084 {
2085   template <class T_action>
2086   static void do_visit_each(const T_action& _A_action,
2087                             const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
2088   {
2089     sigc::visit_each(_A_action, _A_target.obj_);
2090   }
2091 };
2092 #endif // DOXYGEN_SHOULD_SKIP_THIS
2093
2094 /** bound_mem_functor2 encapsulates a  method with 2 arguments and an object instance.
2095  * Use the convenience function mem_fun() to create an instance of bound_mem_functor2.
2096  *
2097  * The following template arguments are used:
2098  * - @e T_arg1 Argument type used in the definition of operator()().
2099  * - @e T_arg2 Argument type used in the definition of operator()().
2100  * - @e T_return The return type of operator()().
2101  * - @e T_obj The object type.
2102  *
2103  * @ingroup mem_fun
2104  */
2105 template <class T_return, class T_obj, class T_arg1, class T_arg2>
2106 class bound_mem_functor2
2107   : public mem_functor2<T_return, T_obj, T_arg1, T_arg2>
2108 {
2109   typedef mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
2110 public:
2111   typedef typename base_type_::function_type function_type;
2112
2113 #ifndef SIGCXX_DISABLE_DEPRECATED
2114   /** Constructs a bound_mem_functor2 object that wraps the passed method.
2115    *
2116    * @deprecated Please use the constructor that takes the object by reference
2117    * instead.
2118    *
2119    * @param _A_obj Pointer to instance the method will operate on.
2120    * @param _A_func Pointer to method will be invoked from operator()().
2121    */
2122   bound_mem_functor2( T_obj* _A_obj, function_type _A_func)
2123     : base_type_(_A_func),
2124       obj_(*_A_obj)
2125     {}
2126 #endif // SIGCXX_DISABLE_DEPRECATED
2127
2128   /** Constructs a bound_mem_functor2 object that wraps the passed method.
2129    * @param _A_obj Reference to instance the method will operate on.
2130    * @param _A_func Pointer to method will be invoked from operator()().
2131    */
2132   bound_mem_functor2( T_obj& _A_obj, function_type _A_func)
2133     : base_type_(_A_func),
2134       obj_(_A_obj)
2135     {}
2136
2137   /** Execute the wrapped method operating on the stored instance.
2138    * @param _A_a1 Argument to be passed on to the method.
2139    * @param _A_a2 Argument to be passed on to the method.
2140    * @return The return value of the method invocation.
2141    */
2142   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
2143     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
2144
2145 //protected:
2146   // Reference to stored object instance.
2147   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2148   limit_reference<T_obj> obj_;
2149 };
2150
2151 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2152 //template specialization of visitor<>::do_visit_each<>(action, functor):
2153 /** Performs a functor on each of the targets of a functor.
2154  * The function overload for sigc::bound_mem_functor performs a functor
2155  * on the object instance stored in the sigc::bound_mem_functor object.
2156  *
2157  * @ingroup mem_fun
2158  */
2159 template <class T_return, class T_obj, class T_arg1, class T_arg2>
2160 struct visitor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
2161 {
2162   template <class T_action>
2163   static void do_visit_each(const T_action& _A_action,
2164                             const bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
2165   {
2166     sigc::visit_each(_A_action, _A_target.obj_);
2167   }
2168 };
2169 #endif // DOXYGEN_SHOULD_SKIP_THIS
2170
2171 /** bound_mem_functor3 encapsulates a  method with 3 arguments and an object instance.
2172  * Use the convenience function mem_fun() to create an instance of bound_mem_functor3.
2173  *
2174  * The following template arguments are used:
2175  * - @e T_arg1 Argument type used in the definition of operator()().
2176  * - @e T_arg2 Argument type used in the definition of operator()().
2177  * - @e T_arg3 Argument type used in the definition of operator()().
2178  * - @e T_return The return type of operator()().
2179  * - @e T_obj The object type.
2180  *
2181  * @ingroup mem_fun
2182  */
2183 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
2184 class bound_mem_functor3
2185   : public mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
2186 {
2187   typedef mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
2188 public:
2189   typedef typename base_type_::function_type function_type;
2190
2191 #ifndef SIGCXX_DISABLE_DEPRECATED
2192   /** Constructs a bound_mem_functor3 object that wraps the passed method.
2193    *
2194    * @deprecated Please use the constructor that takes the object by reference
2195    * instead.
2196    *
2197    * @param _A_obj Pointer to instance the method will operate on.
2198    * @param _A_func Pointer to method will be invoked from operator()().
2199    */
2200   bound_mem_functor3( T_obj* _A_obj, function_type _A_func)
2201     : base_type_(_A_func),
2202       obj_(*_A_obj)
2203     {}
2204 #endif // SIGCXX_DISABLE_DEPRECATED
2205
2206   /** Constructs a bound_mem_functor3 object that wraps the passed method.
2207    * @param _A_obj Reference to instance the method will operate on.
2208    * @param _A_func Pointer to method will be invoked from operator()().
2209    */
2210   bound_mem_functor3( T_obj& _A_obj, function_type _A_func)
2211     : base_type_(_A_func),
2212       obj_(_A_obj)
2213     {}
2214
2215   /** Execute the wrapped method operating on the stored instance.
2216    * @param _A_a1 Argument to be passed on to the method.
2217    * @param _A_a2 Argument to be passed on to the method.
2218    * @param _A_a3 Argument to be passed on to the method.
2219    * @return The return value of the method invocation.
2220    */
2221   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
2222     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
2223
2224 //protected:
2225   // Reference to stored object instance.
2226   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2227   limit_reference<T_obj> obj_;
2228 };
2229
2230 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2231 //template specialization of visitor<>::do_visit_each<>(action, functor):
2232 /** Performs a functor on each of the targets of a functor.
2233  * The function overload for sigc::bound_mem_functor performs a functor
2234  * on the object instance stored in the sigc::bound_mem_functor object.
2235  *
2236  * @ingroup mem_fun
2237  */
2238 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
2239 struct visitor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
2240 {
2241   template <class T_action>
2242   static void do_visit_each(const T_action& _A_action,
2243                             const bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
2244   {
2245     sigc::visit_each(_A_action, _A_target.obj_);
2246   }
2247 };
2248 #endif // DOXYGEN_SHOULD_SKIP_THIS
2249
2250 /** bound_mem_functor4 encapsulates a  method with 4 arguments and an object instance.
2251  * Use the convenience function mem_fun() to create an instance of bound_mem_functor4.
2252  *
2253  * The following template arguments are used:
2254  * - @e T_arg1 Argument type used in the definition of operator()().
2255  * - @e T_arg2 Argument type used in the definition of operator()().
2256  * - @e T_arg3 Argument type used in the definition of operator()().
2257  * - @e T_arg4 Argument type used in the definition of operator()().
2258  * - @e T_return The return type of operator()().
2259  * - @e T_obj The object type.
2260  *
2261  * @ingroup mem_fun
2262  */
2263 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
2264 class bound_mem_functor4
2265   : public mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
2266 {
2267   typedef mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
2268 public:
2269   typedef typename base_type_::function_type function_type;
2270
2271 #ifndef SIGCXX_DISABLE_DEPRECATED
2272   /** Constructs a bound_mem_functor4 object that wraps the passed method.
2273    *
2274    * @deprecated Please use the constructor that takes the object by reference
2275    * instead.
2276    *
2277    * @param _A_obj Pointer to instance the method will operate on.
2278    * @param _A_func Pointer to method will be invoked from operator()().
2279    */
2280   bound_mem_functor4( T_obj* _A_obj, function_type _A_func)
2281     : base_type_(_A_func),
2282       obj_(*_A_obj)
2283     {}
2284 #endif // SIGCXX_DISABLE_DEPRECATED
2285
2286   /** Constructs a bound_mem_functor4 object that wraps the passed method.
2287    * @param _A_obj Reference to instance the method will operate on.
2288    * @param _A_func Pointer to method will be invoked from operator()().
2289    */
2290   bound_mem_functor4( T_obj& _A_obj, function_type _A_func)
2291     : base_type_(_A_func),
2292       obj_(_A_obj)
2293     {}
2294
2295   /** Execute the wrapped method operating on the stored instance.
2296    * @param _A_a1 Argument to be passed on to the method.
2297    * @param _A_a2 Argument to be passed on to the method.
2298    * @param _A_a3 Argument to be passed on to the method.
2299    * @param _A_a4 Argument to be passed on to the method.
2300    * @return The return value of the method invocation.
2301    */
2302   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
2303     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
2304
2305 //protected:
2306   // Reference to stored object instance.
2307   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2308   limit_reference<T_obj> obj_;
2309 };
2310
2311 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2312 //template specialization of visitor<>::do_visit_each<>(action, functor):
2313 /** Performs a functor on each of the targets of a functor.
2314  * The function overload for sigc::bound_mem_functor performs a functor
2315  * on the object instance stored in the sigc::bound_mem_functor object.
2316  *
2317  * @ingroup mem_fun
2318  */
2319 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
2320 struct visitor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
2321 {
2322   template <class T_action>
2323   static void do_visit_each(const T_action& _A_action,
2324                             const bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
2325   {
2326     sigc::visit_each(_A_action, _A_target.obj_);
2327   }
2328 };
2329 #endif // DOXYGEN_SHOULD_SKIP_THIS
2330
2331 /** bound_mem_functor5 encapsulates a  method with 5 arguments and an object instance.
2332  * Use the convenience function mem_fun() to create an instance of bound_mem_functor5.
2333  *
2334  * The following template arguments are used:
2335  * - @e T_arg1 Argument type used in the definition of operator()().
2336  * - @e T_arg2 Argument type used in the definition of operator()().
2337  * - @e T_arg3 Argument type used in the definition of operator()().
2338  * - @e T_arg4 Argument type used in the definition of operator()().
2339  * - @e T_arg5 Argument type used in the definition of operator()().
2340  * - @e T_return The return type of operator()().
2341  * - @e T_obj The object type.
2342  *
2343  * @ingroup mem_fun
2344  */
2345 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
2346 class bound_mem_functor5
2347   : public mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
2348 {
2349   typedef mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
2350 public:
2351   typedef typename base_type_::function_type function_type;
2352
2353 #ifndef SIGCXX_DISABLE_DEPRECATED
2354   /** Constructs a bound_mem_functor5 object that wraps the passed method.
2355    *
2356    * @deprecated Please use the constructor that takes the object by reference
2357    * instead.
2358    *
2359    * @param _A_obj Pointer to instance the method will operate on.
2360    * @param _A_func Pointer to method will be invoked from operator()().
2361    */
2362   bound_mem_functor5( T_obj* _A_obj, function_type _A_func)
2363     : base_type_(_A_func),
2364       obj_(*_A_obj)
2365     {}
2366 #endif // SIGCXX_DISABLE_DEPRECATED
2367
2368   /** Constructs a bound_mem_functor5 object that wraps the passed method.
2369    * @param _A_obj Reference to instance the method will operate on.
2370    * @param _A_func Pointer to method will be invoked from operator()().
2371    */
2372   bound_mem_functor5( T_obj& _A_obj, function_type _A_func)
2373     : base_type_(_A_func),
2374       obj_(_A_obj)
2375     {}
2376
2377   /** Execute the wrapped method operating on the stored instance.
2378    * @param _A_a1 Argument to be passed on to the method.
2379    * @param _A_a2 Argument to be passed on to the method.
2380    * @param _A_a3 Argument to be passed on to the method.
2381    * @param _A_a4 Argument to be passed on to the method.
2382    * @param _A_a5 Argument to be passed on to the method.
2383    * @return The return value of the method invocation.
2384    */
2385   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
2386     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
2387
2388 //protected:
2389   // Reference to stored object instance.
2390   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2391   limit_reference<T_obj> obj_;
2392 };
2393
2394 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2395 //template specialization of visitor<>::do_visit_each<>(action, functor):
2396 /** Performs a functor on each of the targets of a functor.
2397  * The function overload for sigc::bound_mem_functor performs a functor
2398  * on the object instance stored in the sigc::bound_mem_functor object.
2399  *
2400  * @ingroup mem_fun
2401  */
2402 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
2403 struct visitor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
2404 {
2405   template <class T_action>
2406   static void do_visit_each(const T_action& _A_action,
2407                             const bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
2408   {
2409     sigc::visit_each(_A_action, _A_target.obj_);
2410   }
2411 };
2412 #endif // DOXYGEN_SHOULD_SKIP_THIS
2413
2414 /** bound_mem_functor6 encapsulates a  method with 6 arguments and an object instance.
2415  * Use the convenience function mem_fun() to create an instance of bound_mem_functor6.
2416  *
2417  * The following template arguments are used:
2418  * - @e T_arg1 Argument type used in the definition of operator()().
2419  * - @e T_arg2 Argument type used in the definition of operator()().
2420  * - @e T_arg3 Argument type used in the definition of operator()().
2421  * - @e T_arg4 Argument type used in the definition of operator()().
2422  * - @e T_arg5 Argument type used in the definition of operator()().
2423  * - @e T_arg6 Argument type used in the definition of operator()().
2424  * - @e T_return The return type of operator()().
2425  * - @e T_obj The object type.
2426  *
2427  * @ingroup mem_fun
2428  */
2429 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
2430 class bound_mem_functor6
2431   : public mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
2432 {
2433   typedef mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
2434 public:
2435   typedef typename base_type_::function_type function_type;
2436
2437 #ifndef SIGCXX_DISABLE_DEPRECATED
2438   /** Constructs a bound_mem_functor6 object that wraps the passed method.
2439    *
2440    * @deprecated Please use the constructor that takes the object by reference
2441    * instead.
2442    *
2443    * @param _A_obj Pointer to instance the method will operate on.
2444    * @param _A_func Pointer to method will be invoked from operator()().
2445    */
2446   bound_mem_functor6( T_obj* _A_obj, function_type _A_func)
2447     : base_type_(_A_func),
2448       obj_(*_A_obj)
2449     {}
2450 #endif // SIGCXX_DISABLE_DEPRECATED
2451
2452   /** Constructs a bound_mem_functor6 object that wraps the passed method.
2453    * @param _A_obj Reference to instance the method will operate on.
2454    * @param _A_func Pointer to method will be invoked from operator()().
2455    */
2456   bound_mem_functor6( T_obj& _A_obj, function_type _A_func)
2457     : base_type_(_A_func),
2458       obj_(_A_obj)
2459     {}
2460
2461   /** Execute the wrapped method operating on the stored instance.
2462    * @param _A_a1 Argument to be passed on to the method.
2463    * @param _A_a2 Argument to be passed on to the method.
2464    * @param _A_a3 Argument to be passed on to the method.
2465    * @param _A_a4 Argument to be passed on to the method.
2466    * @param _A_a5 Argument to be passed on to the method.
2467    * @param _A_a6 Argument to be passed on to the method.
2468    * @return The return value of the method invocation.
2469    */
2470   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
2471     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
2472
2473 //protected:
2474   // Reference to stored object instance.
2475   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2476   limit_reference<T_obj> obj_;
2477 };
2478
2479 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2480 //template specialization of visitor<>::do_visit_each<>(action, functor):
2481 /** Performs a functor on each of the targets of a functor.
2482  * The function overload for sigc::bound_mem_functor performs a functor
2483  * on the object instance stored in the sigc::bound_mem_functor object.
2484  *
2485  * @ingroup mem_fun
2486  */
2487 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
2488 struct visitor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
2489 {
2490   template <class T_action>
2491   static void do_visit_each(const T_action& _A_action,
2492                             const bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
2493   {
2494     sigc::visit_each(_A_action, _A_target.obj_);
2495   }
2496 };
2497 #endif // DOXYGEN_SHOULD_SKIP_THIS
2498
2499 /** bound_mem_functor7 encapsulates a  method with 7 arguments and an object instance.
2500  * Use the convenience function mem_fun() to create an instance of bound_mem_functor7.
2501  *
2502  * The following template arguments are used:
2503  * - @e T_arg1 Argument type used in the definition of operator()().
2504  * - @e T_arg2 Argument type used in the definition of operator()().
2505  * - @e T_arg3 Argument type used in the definition of operator()().
2506  * - @e T_arg4 Argument type used in the definition of operator()().
2507  * - @e T_arg5 Argument type used in the definition of operator()().
2508  * - @e T_arg6 Argument type used in the definition of operator()().
2509  * - @e T_arg7 Argument type used in the definition of operator()().
2510  * - @e T_return The return type of operator()().
2511  * - @e T_obj The object type.
2512  *
2513  * @ingroup mem_fun
2514  */
2515 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
2516 class bound_mem_functor7
2517   : public mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
2518 {
2519   typedef mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
2520 public:
2521   typedef typename base_type_::function_type function_type;
2522
2523 #ifndef SIGCXX_DISABLE_DEPRECATED
2524   /** Constructs a bound_mem_functor7 object that wraps the passed method.
2525    *
2526    * @deprecated Please use the constructor that takes the object by reference
2527    * instead.
2528    *
2529    * @param _A_obj Pointer to instance the method will operate on.
2530    * @param _A_func Pointer to method will be invoked from operator()().
2531    */
2532   bound_mem_functor7( T_obj* _A_obj, function_type _A_func)
2533     : base_type_(_A_func),
2534       obj_(*_A_obj)
2535     {}
2536 #endif // SIGCXX_DISABLE_DEPRECATED
2537
2538   /** Constructs a bound_mem_functor7 object that wraps the passed method.
2539    * @param _A_obj Reference to instance the method will operate on.
2540    * @param _A_func Pointer to method will be invoked from operator()().
2541    */
2542   bound_mem_functor7( T_obj& _A_obj, function_type _A_func)
2543     : base_type_(_A_func),
2544       obj_(_A_obj)
2545     {}
2546
2547   /** Execute the wrapped method operating on the stored instance.
2548    * @param _A_a1 Argument to be passed on to the method.
2549    * @param _A_a2 Argument to be passed on to the method.
2550    * @param _A_a3 Argument to be passed on to the method.
2551    * @param _A_a4 Argument to be passed on to the method.
2552    * @param _A_a5 Argument to be passed on to the method.
2553    * @param _A_a6 Argument to be passed on to the method.
2554    * @param _A_a7 Argument to be passed on to the method.
2555    * @return The return value of the method invocation.
2556    */
2557   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
2558     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
2559
2560 //protected:
2561   // Reference to stored object instance.
2562   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2563   limit_reference<T_obj> obj_;
2564 };
2565
2566 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2567 //template specialization of visitor<>::do_visit_each<>(action, functor):
2568 /** Performs a functor on each of the targets of a functor.
2569  * The function overload for sigc::bound_mem_functor performs a functor
2570  * on the object instance stored in the sigc::bound_mem_functor object.
2571  *
2572  * @ingroup mem_fun
2573  */
2574 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
2575 struct visitor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
2576 {
2577   template <class T_action>
2578   static void do_visit_each(const T_action& _A_action,
2579                             const bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
2580   {
2581     sigc::visit_each(_A_action, _A_target.obj_);
2582   }
2583 };
2584 #endif // DOXYGEN_SHOULD_SKIP_THIS
2585
2586 /** bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.
2587  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor0.
2588  *
2589  * The following template arguments are used:
2590  * - @e T_return The return type of operator()().
2591  * - @e T_obj The object type.
2592  *
2593  * @ingroup mem_fun
2594  */
2595 template <class T_return, class T_obj>
2596 class bound_const_mem_functor0
2597   : public const_mem_functor0<T_return, T_obj>
2598 {
2599   typedef const_mem_functor0<T_return, T_obj> base_type_;
2600 public:
2601   typedef typename base_type_::function_type function_type;
2602
2603 #ifndef SIGCXX_DISABLE_DEPRECATED
2604   /** Constructs a bound_const_mem_functor0 object that wraps the passed method.
2605    *
2606    * @deprecated Please use the constructor that takes the object by reference
2607    * instead.
2608    *
2609    * @param _A_obj Pointer to instance the method will operate on.
2610    * @param _A_func Pointer to method will be invoked from operator()().
2611    */
2612   bound_const_mem_functor0(const T_obj* _A_obj, function_type _A_func)
2613     : base_type_(_A_func),
2614       obj_(*_A_obj)
2615     {}
2616 #endif // SIGCXX_DISABLE_DEPRECATED
2617
2618   /** Constructs a bound_const_mem_functor0 object that wraps the passed method.
2619    * @param _A_obj Reference to instance the method will operate on.
2620    * @param _A_func Pointer to method will be invoked from operator()().
2621    */
2622   bound_const_mem_functor0(const T_obj& _A_obj, function_type _A_func)
2623     : base_type_(_A_func),
2624       obj_(_A_obj)
2625     {}
2626
2627   /** Execute the wrapped method operating on the stored instance.
2628    * @return The return value of the method invocation.
2629    */
2630   T_return operator()() const
2631     { return (obj_.invoke().*(this->func_ptr_))(); }
2632
2633 //protected:
2634   // Reference to stored object instance.
2635   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2636   const_limit_reference<T_obj> obj_;
2637 };
2638
2639 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2640 //template specialization of visitor<>::do_visit_each<>(action, functor):
2641 /** Performs a functor on each of the targets of a functor.
2642  * The function overload for sigc::bound_const_mem_functor performs a functor
2643  * on the object instance stored in the sigc::bound_const_mem_functor object.
2644  *
2645  * @ingroup mem_fun
2646  */
2647 template <class T_return, class T_obj>
2648 struct visitor<bound_const_mem_functor0<T_return, T_obj> >
2649 {
2650   template <class T_action>
2651   static void do_visit_each(const T_action& _A_action,
2652                             const bound_const_mem_functor0<T_return, T_obj>& _A_target)
2653   {
2654     sigc::visit_each(_A_action, _A_target.obj_);
2655   }
2656 };
2657 #endif // DOXYGEN_SHOULD_SKIP_THIS
2658
2659 /** bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.
2660  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor1.
2661  *
2662  * The following template arguments are used:
2663  * - @e T_arg1 Argument type used in the definition of operator()().
2664  * - @e T_return The return type of operator()().
2665  * - @e T_obj The object type.
2666  *
2667  * @ingroup mem_fun
2668  */
2669 template <class T_return, class T_obj, class T_arg1>
2670 class bound_const_mem_functor1
2671   : public const_mem_functor1<T_return, T_obj, T_arg1>
2672 {
2673   typedef const_mem_functor1<T_return, T_obj, T_arg1> base_type_;
2674 public:
2675   typedef typename base_type_::function_type function_type;
2676
2677 #ifndef SIGCXX_DISABLE_DEPRECATED
2678   /** Constructs a bound_const_mem_functor1 object that wraps the passed method.
2679    *
2680    * @deprecated Please use the constructor that takes the object by reference
2681    * instead.
2682    *
2683    * @param _A_obj Pointer to instance the method will operate on.
2684    * @param _A_func Pointer to method will be invoked from operator()().
2685    */
2686   bound_const_mem_functor1(const T_obj* _A_obj, function_type _A_func)
2687     : base_type_(_A_func),
2688       obj_(*_A_obj)
2689     {}
2690 #endif // SIGCXX_DISABLE_DEPRECATED
2691
2692   /** Constructs a bound_const_mem_functor1 object that wraps the passed method.
2693    * @param _A_obj Reference to instance the method will operate on.
2694    * @param _A_func Pointer to method will be invoked from operator()().
2695    */
2696   bound_const_mem_functor1(const T_obj& _A_obj, function_type _A_func)
2697     : base_type_(_A_func),
2698       obj_(_A_obj)
2699     {}
2700
2701   /** Execute the wrapped method operating on the stored instance.
2702    * @param _A_a1 Argument to be passed on to the method.
2703    * @return The return value of the method invocation.
2704    */
2705   T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
2706     { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
2707
2708 //protected:
2709   // Reference to stored object instance.
2710   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2711   const_limit_reference<T_obj> obj_;
2712 };
2713
2714 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2715 //template specialization of visitor<>::do_visit_each<>(action, functor):
2716 /** Performs a functor on each of the targets of a functor.
2717  * The function overload for sigc::bound_const_mem_functor performs a functor
2718  * on the object instance stored in the sigc::bound_const_mem_functor object.
2719  *
2720  * @ingroup mem_fun
2721  */
2722 template <class T_return, class T_obj, class T_arg1>
2723 struct visitor<bound_const_mem_functor1<T_return, T_obj, T_arg1> >
2724 {
2725   template <class T_action>
2726   static void do_visit_each(const T_action& _A_action,
2727                             const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
2728   {
2729     sigc::visit_each(_A_action, _A_target.obj_);
2730   }
2731 };
2732 #endif // DOXYGEN_SHOULD_SKIP_THIS
2733
2734 /** bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.
2735  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor2.
2736  *
2737  * The following template arguments are used:
2738  * - @e T_arg1 Argument type used in the definition of operator()().
2739  * - @e T_arg2 Argument type used in the definition of operator()().
2740  * - @e T_return The return type of operator()().
2741  * - @e T_obj The object type.
2742  *
2743  * @ingroup mem_fun
2744  */
2745 template <class T_return, class T_obj, class T_arg1, class T_arg2>
2746 class bound_const_mem_functor2
2747   : public const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
2748 {
2749   typedef const_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
2750 public:
2751   typedef typename base_type_::function_type function_type;
2752
2753 #ifndef SIGCXX_DISABLE_DEPRECATED
2754   /** Constructs a bound_const_mem_functor2 object that wraps the passed method.
2755    *
2756    * @deprecated Please use the constructor that takes the object by reference
2757    * instead.
2758    *
2759    * @param _A_obj Pointer to instance the method will operate on.
2760    * @param _A_func Pointer to method will be invoked from operator()().
2761    */
2762   bound_const_mem_functor2(const T_obj* _A_obj, function_type _A_func)
2763     : base_type_(_A_func),
2764       obj_(*_A_obj)
2765     {}
2766 #endif // SIGCXX_DISABLE_DEPRECATED
2767
2768   /** Constructs a bound_const_mem_functor2 object that wraps the passed method.
2769    * @param _A_obj Reference to instance the method will operate on.
2770    * @param _A_func Pointer to method will be invoked from operator()().
2771    */
2772   bound_const_mem_functor2(const T_obj& _A_obj, function_type _A_func)
2773     : base_type_(_A_func),
2774       obj_(_A_obj)
2775     {}
2776
2777   /** Execute the wrapped method operating on the stored instance.
2778    * @param _A_a1 Argument to be passed on to the method.
2779    * @param _A_a2 Argument to be passed on to the method.
2780    * @return The return value of the method invocation.
2781    */
2782   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
2783     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
2784
2785 //protected:
2786   // Reference to stored object instance.
2787   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2788   const_limit_reference<T_obj> obj_;
2789 };
2790
2791 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2792 //template specialization of visitor<>::do_visit_each<>(action, functor):
2793 /** Performs a functor on each of the targets of a functor.
2794  * The function overload for sigc::bound_const_mem_functor performs a functor
2795  * on the object instance stored in the sigc::bound_const_mem_functor object.
2796  *
2797  * @ingroup mem_fun
2798  */
2799 template <class T_return, class T_obj, class T_arg1, class T_arg2>
2800 struct visitor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
2801 {
2802   template <class T_action>
2803   static void do_visit_each(const T_action& _A_action,
2804                             const bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
2805   {
2806     sigc::visit_each(_A_action, _A_target.obj_);
2807   }
2808 };
2809 #endif // DOXYGEN_SHOULD_SKIP_THIS
2810
2811 /** bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.
2812  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor3.
2813  *
2814  * The following template arguments are used:
2815  * - @e T_arg1 Argument type used in the definition of operator()().
2816  * - @e T_arg2 Argument type used in the definition of operator()().
2817  * - @e T_arg3 Argument type used in the definition of operator()().
2818  * - @e T_return The return type of operator()().
2819  * - @e T_obj The object type.
2820  *
2821  * @ingroup mem_fun
2822  */
2823 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
2824 class bound_const_mem_functor3
2825   : public const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
2826 {
2827   typedef const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
2828 public:
2829   typedef typename base_type_::function_type function_type;
2830
2831 #ifndef SIGCXX_DISABLE_DEPRECATED
2832   /** Constructs a bound_const_mem_functor3 object that wraps the passed method.
2833    *
2834    * @deprecated Please use the constructor that takes the object by reference
2835    * instead.
2836    *
2837    * @param _A_obj Pointer to instance the method will operate on.
2838    * @param _A_func Pointer to method will be invoked from operator()().
2839    */
2840   bound_const_mem_functor3(const T_obj* _A_obj, function_type _A_func)
2841     : base_type_(_A_func),
2842       obj_(*_A_obj)
2843     {}
2844 #endif // SIGCXX_DISABLE_DEPRECATED
2845
2846   /** Constructs a bound_const_mem_functor3 object that wraps the passed method.
2847    * @param _A_obj Reference to instance the method will operate on.
2848    * @param _A_func Pointer to method will be invoked from operator()().
2849    */
2850   bound_const_mem_functor3(const T_obj& _A_obj, function_type _A_func)
2851     : base_type_(_A_func),
2852       obj_(_A_obj)
2853     {}
2854
2855   /** Execute the wrapped method operating on the stored instance.
2856    * @param _A_a1 Argument to be passed on to the method.
2857    * @param _A_a2 Argument to be passed on to the method.
2858    * @param _A_a3 Argument to be passed on to the method.
2859    * @return The return value of the method invocation.
2860    */
2861   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
2862     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
2863
2864 //protected:
2865   // Reference to stored object instance.
2866   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2867   const_limit_reference<T_obj> obj_;
2868 };
2869
2870 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2871 //template specialization of visitor<>::do_visit_each<>(action, functor):
2872 /** Performs a functor on each of the targets of a functor.
2873  * The function overload for sigc::bound_const_mem_functor performs a functor
2874  * on the object instance stored in the sigc::bound_const_mem_functor object.
2875  *
2876  * @ingroup mem_fun
2877  */
2878 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
2879 struct visitor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
2880 {
2881   template <class T_action>
2882   static void do_visit_each(const T_action& _A_action,
2883                             const bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
2884   {
2885     sigc::visit_each(_A_action, _A_target.obj_);
2886   }
2887 };
2888 #endif // DOXYGEN_SHOULD_SKIP_THIS
2889
2890 /** bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.
2891  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor4.
2892  *
2893  * The following template arguments are used:
2894  * - @e T_arg1 Argument type used in the definition of operator()().
2895  * - @e T_arg2 Argument type used in the definition of operator()().
2896  * - @e T_arg3 Argument type used in the definition of operator()().
2897  * - @e T_arg4 Argument type used in the definition of operator()().
2898  * - @e T_return The return type of operator()().
2899  * - @e T_obj The object type.
2900  *
2901  * @ingroup mem_fun
2902  */
2903 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
2904 class bound_const_mem_functor4
2905   : public const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
2906 {
2907   typedef const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
2908 public:
2909   typedef typename base_type_::function_type function_type;
2910
2911 #ifndef SIGCXX_DISABLE_DEPRECATED
2912   /** Constructs a bound_const_mem_functor4 object that wraps the passed method.
2913    *
2914    * @deprecated Please use the constructor that takes the object by reference
2915    * instead.
2916    *
2917    * @param _A_obj Pointer to instance the method will operate on.
2918    * @param _A_func Pointer to method will be invoked from operator()().
2919    */
2920   bound_const_mem_functor4(const T_obj* _A_obj, function_type _A_func)
2921     : base_type_(_A_func),
2922       obj_(*_A_obj)
2923     {}
2924 #endif // SIGCXX_DISABLE_DEPRECATED
2925
2926   /** Constructs a bound_const_mem_functor4 object that wraps the passed method.
2927    * @param _A_obj Reference to instance the method will operate on.
2928    * @param _A_func Pointer to method will be invoked from operator()().
2929    */
2930   bound_const_mem_functor4(const T_obj& _A_obj, function_type _A_func)
2931     : base_type_(_A_func),
2932       obj_(_A_obj)
2933     {}
2934
2935   /** Execute the wrapped method operating on the stored instance.
2936    * @param _A_a1 Argument to be passed on to the method.
2937    * @param _A_a2 Argument to be passed on to the method.
2938    * @param _A_a3 Argument to be passed on to the method.
2939    * @param _A_a4 Argument to be passed on to the method.
2940    * @return The return value of the method invocation.
2941    */
2942   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
2943     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
2944
2945 //protected:
2946   // Reference to stored object instance.
2947   // This is the handler object, such as TheObject in void TheObject::signal_handler().
2948   const_limit_reference<T_obj> obj_;
2949 };
2950
2951 #ifndef DOXYGEN_SHOULD_SKIP_THIS
2952 //template specialization of visitor<>::do_visit_each<>(action, functor):
2953 /** Performs a functor on each of the targets of a functor.
2954  * The function overload for sigc::bound_const_mem_functor performs a functor
2955  * on the object instance stored in the sigc::bound_const_mem_functor object.
2956  *
2957  * @ingroup mem_fun
2958  */
2959 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
2960 struct visitor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
2961 {
2962   template <class T_action>
2963   static void do_visit_each(const T_action& _A_action,
2964                             const bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
2965   {
2966     sigc::visit_each(_A_action, _A_target.obj_);
2967   }
2968 };
2969 #endif // DOXYGEN_SHOULD_SKIP_THIS
2970
2971 /** bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.
2972  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor5.
2973  *
2974  * The following template arguments are used:
2975  * - @e T_arg1 Argument type used in the definition of operator()().
2976  * - @e T_arg2 Argument type used in the definition of operator()().
2977  * - @e T_arg3 Argument type used in the definition of operator()().
2978  * - @e T_arg4 Argument type used in the definition of operator()().
2979  * - @e T_arg5 Argument type used in the definition of operator()().
2980  * - @e T_return The return type of operator()().
2981  * - @e T_obj The object type.
2982  *
2983  * @ingroup mem_fun
2984  */
2985 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
2986 class bound_const_mem_functor5
2987   : public const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
2988 {
2989   typedef const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
2990 public:
2991   typedef typename base_type_::function_type function_type;
2992
2993 #ifndef SIGCXX_DISABLE_DEPRECATED
2994   /** Constructs a bound_const_mem_functor5 object that wraps the passed method.
2995    *
2996    * @deprecated Please use the constructor that takes the object by reference
2997    * instead.
2998    *
2999    * @param _A_obj Pointer to instance the method will operate on.
3000    * @param _A_func Pointer to method will be invoked from operator()().
3001    */
3002   bound_const_mem_functor5(const T_obj* _A_obj, function_type _A_func)
3003     : base_type_(_A_func),
3004       obj_(*_A_obj)
3005     {}
3006 #endif // SIGCXX_DISABLE_DEPRECATED
3007
3008   /** Constructs a bound_const_mem_functor5 object that wraps the passed method.
3009    * @param _A_obj Reference to instance the method will operate on.
3010    * @param _A_func Pointer to method will be invoked from operator()().
3011    */
3012   bound_const_mem_functor5(const T_obj& _A_obj, function_type _A_func)
3013     : base_type_(_A_func),
3014       obj_(_A_obj)
3015     {}
3016
3017   /** Execute the wrapped method operating on the stored instance.
3018    * @param _A_a1 Argument to be passed on to the method.
3019    * @param _A_a2 Argument to be passed on to the method.
3020    * @param _A_a3 Argument to be passed on to the method.
3021    * @param _A_a4 Argument to be passed on to the method.
3022    * @param _A_a5 Argument to be passed on to the method.
3023    * @return The return value of the method invocation.
3024    */
3025   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
3026     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
3027
3028 //protected:
3029   // Reference to stored object instance.
3030   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3031   const_limit_reference<T_obj> obj_;
3032 };
3033
3034 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3035 //template specialization of visitor<>::do_visit_each<>(action, functor):
3036 /** Performs a functor on each of the targets of a functor.
3037  * The function overload for sigc::bound_const_mem_functor performs a functor
3038  * on the object instance stored in the sigc::bound_const_mem_functor object.
3039  *
3040  * @ingroup mem_fun
3041  */
3042 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
3043 struct visitor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
3044 {
3045   template <class T_action>
3046   static void do_visit_each(const T_action& _A_action,
3047                             const bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
3048   {
3049     sigc::visit_each(_A_action, _A_target.obj_);
3050   }
3051 };
3052 #endif // DOXYGEN_SHOULD_SKIP_THIS
3053
3054 /** bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.
3055  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor6.
3056  *
3057  * The following template arguments are used:
3058  * - @e T_arg1 Argument type used in the definition of operator()().
3059  * - @e T_arg2 Argument type used in the definition of operator()().
3060  * - @e T_arg3 Argument type used in the definition of operator()().
3061  * - @e T_arg4 Argument type used in the definition of operator()().
3062  * - @e T_arg5 Argument type used in the definition of operator()().
3063  * - @e T_arg6 Argument type used in the definition of operator()().
3064  * - @e T_return The return type of operator()().
3065  * - @e T_obj The object type.
3066  *
3067  * @ingroup mem_fun
3068  */
3069 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
3070 class bound_const_mem_functor6
3071   : public const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
3072 {
3073   typedef const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
3074 public:
3075   typedef typename base_type_::function_type function_type;
3076
3077 #ifndef SIGCXX_DISABLE_DEPRECATED
3078   /** Constructs a bound_const_mem_functor6 object that wraps the passed method.
3079    *
3080    * @deprecated Please use the constructor that takes the object by reference
3081    * instead.
3082    *
3083    * @param _A_obj Pointer to instance the method will operate on.
3084    * @param _A_func Pointer to method will be invoked from operator()().
3085    */
3086   bound_const_mem_functor6(const T_obj* _A_obj, function_type _A_func)
3087     : base_type_(_A_func),
3088       obj_(*_A_obj)
3089     {}
3090 #endif // SIGCXX_DISABLE_DEPRECATED
3091
3092   /** Constructs a bound_const_mem_functor6 object that wraps the passed method.
3093    * @param _A_obj Reference to instance the method will operate on.
3094    * @param _A_func Pointer to method will be invoked from operator()().
3095    */
3096   bound_const_mem_functor6(const T_obj& _A_obj, function_type _A_func)
3097     : base_type_(_A_func),
3098       obj_(_A_obj)
3099     {}
3100
3101   /** Execute the wrapped method operating on the stored instance.
3102    * @param _A_a1 Argument to be passed on to the method.
3103    * @param _A_a2 Argument to be passed on to the method.
3104    * @param _A_a3 Argument to be passed on to the method.
3105    * @param _A_a4 Argument to be passed on to the method.
3106    * @param _A_a5 Argument to be passed on to the method.
3107    * @param _A_a6 Argument to be passed on to the method.
3108    * @return The return value of the method invocation.
3109    */
3110   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
3111     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
3112
3113 //protected:
3114   // Reference to stored object instance.
3115   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3116   const_limit_reference<T_obj> obj_;
3117 };
3118
3119 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3120 //template specialization of visitor<>::do_visit_each<>(action, functor):
3121 /** Performs a functor on each of the targets of a functor.
3122  * The function overload for sigc::bound_const_mem_functor performs a functor
3123  * on the object instance stored in the sigc::bound_const_mem_functor object.
3124  *
3125  * @ingroup mem_fun
3126  */
3127 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
3128 struct visitor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
3129 {
3130   template <class T_action>
3131   static void do_visit_each(const T_action& _A_action,
3132                             const bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
3133   {
3134     sigc::visit_each(_A_action, _A_target.obj_);
3135   }
3136 };
3137 #endif // DOXYGEN_SHOULD_SKIP_THIS
3138
3139 /** bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.
3140  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor7.
3141  *
3142  * The following template arguments are used:
3143  * - @e T_arg1 Argument type used in the definition of operator()().
3144  * - @e T_arg2 Argument type used in the definition of operator()().
3145  * - @e T_arg3 Argument type used in the definition of operator()().
3146  * - @e T_arg4 Argument type used in the definition of operator()().
3147  * - @e T_arg5 Argument type used in the definition of operator()().
3148  * - @e T_arg6 Argument type used in the definition of operator()().
3149  * - @e T_arg7 Argument type used in the definition of operator()().
3150  * - @e T_return The return type of operator()().
3151  * - @e T_obj The object type.
3152  *
3153  * @ingroup mem_fun
3154  */
3155 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
3156 class bound_const_mem_functor7
3157   : public const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
3158 {
3159   typedef const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
3160 public:
3161   typedef typename base_type_::function_type function_type;
3162
3163 #ifndef SIGCXX_DISABLE_DEPRECATED
3164   /** Constructs a bound_const_mem_functor7 object that wraps the passed method.
3165    *
3166    * @deprecated Please use the constructor that takes the object by reference
3167    * instead.
3168    *
3169    * @param _A_obj Pointer to instance the method will operate on.
3170    * @param _A_func Pointer to method will be invoked from operator()().
3171    */
3172   bound_const_mem_functor7(const T_obj* _A_obj, function_type _A_func)
3173     : base_type_(_A_func),
3174       obj_(*_A_obj)
3175     {}
3176 #endif // SIGCXX_DISABLE_DEPRECATED
3177
3178   /** Constructs a bound_const_mem_functor7 object that wraps the passed method.
3179    * @param _A_obj Reference to instance the method will operate on.
3180    * @param _A_func Pointer to method will be invoked from operator()().
3181    */
3182   bound_const_mem_functor7(const T_obj& _A_obj, function_type _A_func)
3183     : base_type_(_A_func),
3184       obj_(_A_obj)
3185     {}
3186
3187   /** Execute the wrapped method operating on the stored instance.
3188    * @param _A_a1 Argument to be passed on to the method.
3189    * @param _A_a2 Argument to be passed on to the method.
3190    * @param _A_a3 Argument to be passed on to the method.
3191    * @param _A_a4 Argument to be passed on to the method.
3192    * @param _A_a5 Argument to be passed on to the method.
3193    * @param _A_a6 Argument to be passed on to the method.
3194    * @param _A_a7 Argument to be passed on to the method.
3195    * @return The return value of the method invocation.
3196    */
3197   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
3198     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
3199
3200 //protected:
3201   // Reference to stored object instance.
3202   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3203   const_limit_reference<T_obj> obj_;
3204 };
3205
3206 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3207 //template specialization of visitor<>::do_visit_each<>(action, functor):
3208 /** Performs a functor on each of the targets of a functor.
3209  * The function overload for sigc::bound_const_mem_functor performs a functor
3210  * on the object instance stored in the sigc::bound_const_mem_functor object.
3211  *
3212  * @ingroup mem_fun
3213  */
3214 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
3215 struct visitor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
3216 {
3217   template <class T_action>
3218   static void do_visit_each(const T_action& _A_action,
3219                             const bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
3220   {
3221     sigc::visit_each(_A_action, _A_target.obj_);
3222   }
3223 };
3224 #endif // DOXYGEN_SHOULD_SKIP_THIS
3225
3226 /** bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.
3227  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor0.
3228  *
3229  * The following template arguments are used:
3230  * - @e T_return The return type of operator()().
3231  * - @e T_obj The object type.
3232  *
3233  * @ingroup mem_fun
3234  */
3235 template <class T_return, class T_obj>
3236 class bound_volatile_mem_functor0
3237   : public volatile_mem_functor0<T_return, T_obj>
3238 {
3239   typedef volatile_mem_functor0<T_return, T_obj> base_type_;
3240 public:
3241   typedef typename base_type_::function_type function_type;
3242
3243 #ifndef SIGCXX_DISABLE_DEPRECATED
3244   /** Constructs a bound_volatile_mem_functor0 object that wraps the passed method.
3245    *
3246    * @deprecated Please use the constructor that takes the object by reference
3247    * instead.
3248    *
3249    * @param _A_obj Pointer to instance the method will operate on.
3250    * @param _A_func Pointer to method will be invoked from operator()().
3251    */
3252   bound_volatile_mem_functor0( T_obj* _A_obj, function_type _A_func)
3253     : base_type_(_A_func),
3254       obj_(*_A_obj)
3255     {}
3256 #endif // SIGCXX_DISABLE_DEPRECATED
3257
3258   /** Constructs a bound_volatile_mem_functor0 object that wraps the passed method.
3259    * @param _A_obj Reference to instance the method will operate on.
3260    * @param _A_func Pointer to method will be invoked from operator()().
3261    */
3262   bound_volatile_mem_functor0( T_obj& _A_obj, function_type _A_func)
3263     : base_type_(_A_func),
3264       obj_(_A_obj)
3265     {}
3266
3267   /** Execute the wrapped method operating on the stored instance.
3268    * @return The return value of the method invocation.
3269    */
3270   T_return operator()() const
3271     { return (obj_.invoke().*(this->func_ptr_))(); }
3272
3273 //protected:
3274   // Reference to stored object instance.
3275   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3276   volatile_limit_reference<T_obj> obj_;
3277 };
3278
3279 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3280 //template specialization of visitor<>::do_visit_each<>(action, functor):
3281 /** Performs a functor on each of the targets of a functor.
3282  * The function overload for sigc::bound_volatile_mem_functor performs a functor
3283  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
3284  *
3285  * @ingroup mem_fun
3286  */
3287 template <class T_return, class T_obj>
3288 struct visitor<bound_volatile_mem_functor0<T_return, T_obj> >
3289 {
3290   template <class T_action>
3291   static void do_visit_each(const T_action& _A_action,
3292                             const bound_volatile_mem_functor0<T_return, T_obj>& _A_target)
3293   {
3294     sigc::visit_each(_A_action, _A_target.obj_);
3295   }
3296 };
3297 #endif // DOXYGEN_SHOULD_SKIP_THIS
3298
3299 /** bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.
3300  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor1.
3301  *
3302  * The following template arguments are used:
3303  * - @e T_arg1 Argument type used in the definition of operator()().
3304  * - @e T_return The return type of operator()().
3305  * - @e T_obj The object type.
3306  *
3307  * @ingroup mem_fun
3308  */
3309 template <class T_return, class T_obj, class T_arg1>
3310 class bound_volatile_mem_functor1
3311   : public volatile_mem_functor1<T_return, T_obj, T_arg1>
3312 {
3313   typedef volatile_mem_functor1<T_return, T_obj, T_arg1> base_type_;
3314 public:
3315   typedef typename base_type_::function_type function_type;
3316
3317 #ifndef SIGCXX_DISABLE_DEPRECATED
3318   /** Constructs a bound_volatile_mem_functor1 object that wraps the passed method.
3319    *
3320    * @deprecated Please use the constructor that takes the object by reference
3321    * instead.
3322    *
3323    * @param _A_obj Pointer to instance the method will operate on.
3324    * @param _A_func Pointer to method will be invoked from operator()().
3325    */
3326   bound_volatile_mem_functor1( T_obj* _A_obj, function_type _A_func)
3327     : base_type_(_A_func),
3328       obj_(*_A_obj)
3329     {}
3330 #endif // SIGCXX_DISABLE_DEPRECATED
3331
3332   /** Constructs a bound_volatile_mem_functor1 object that wraps the passed method.
3333    * @param _A_obj Reference to instance the method will operate on.
3334    * @param _A_func Pointer to method will be invoked from operator()().
3335    */
3336   bound_volatile_mem_functor1( T_obj& _A_obj, function_type _A_func)
3337     : base_type_(_A_func),
3338       obj_(_A_obj)
3339     {}
3340
3341   /** Execute the wrapped method operating on the stored instance.
3342    * @param _A_a1 Argument to be passed on to the method.
3343    * @return The return value of the method invocation.
3344    */
3345   T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
3346     { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
3347
3348 //protected:
3349   // Reference to stored object instance.
3350   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3351   volatile_limit_reference<T_obj> obj_;
3352 };
3353
3354 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3355 //template specialization of visitor<>::do_visit_each<>(action, functor):
3356 /** Performs a functor on each of the targets of a functor.
3357  * The function overload for sigc::bound_volatile_mem_functor performs a functor
3358  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
3359  *
3360  * @ingroup mem_fun
3361  */
3362 template <class T_return, class T_obj, class T_arg1>
3363 struct visitor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1> >
3364 {
3365   template <class T_action>
3366   static void do_visit_each(const T_action& _A_action,
3367                             const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
3368   {
3369     sigc::visit_each(_A_action, _A_target.obj_);
3370   }
3371 };
3372 #endif // DOXYGEN_SHOULD_SKIP_THIS
3373
3374 /** bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.
3375  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor2.
3376  *
3377  * The following template arguments are used:
3378  * - @e T_arg1 Argument type used in the definition of operator()().
3379  * - @e T_arg2 Argument type used in the definition of operator()().
3380  * - @e T_return The return type of operator()().
3381  * - @e T_obj The object type.
3382  *
3383  * @ingroup mem_fun
3384  */
3385 template <class T_return, class T_obj, class T_arg1, class T_arg2>
3386 class bound_volatile_mem_functor2
3387   : public volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
3388 {
3389   typedef volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
3390 public:
3391   typedef typename base_type_::function_type function_type;
3392
3393 #ifndef SIGCXX_DISABLE_DEPRECATED
3394   /** Constructs a bound_volatile_mem_functor2 object that wraps the passed method.
3395    *
3396    * @deprecated Please use the constructor that takes the object by reference
3397    * instead.
3398    *
3399    * @param _A_obj Pointer to instance the method will operate on.
3400    * @param _A_func Pointer to method will be invoked from operator()().
3401    */
3402   bound_volatile_mem_functor2( T_obj* _A_obj, function_type _A_func)
3403     : base_type_(_A_func),
3404       obj_(*_A_obj)
3405     {}
3406 #endif // SIGCXX_DISABLE_DEPRECATED
3407
3408   /** Constructs a bound_volatile_mem_functor2 object that wraps the passed method.
3409    * @param _A_obj Reference to instance the method will operate on.
3410    * @param _A_func Pointer to method will be invoked from operator()().
3411    */
3412   bound_volatile_mem_functor2( T_obj& _A_obj, function_type _A_func)
3413     : base_type_(_A_func),
3414       obj_(_A_obj)
3415     {}
3416
3417   /** Execute the wrapped method operating on the stored instance.
3418    * @param _A_a1 Argument to be passed on to the method.
3419    * @param _A_a2 Argument to be passed on to the method.
3420    * @return The return value of the method invocation.
3421    */
3422   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
3423     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
3424
3425 //protected:
3426   // Reference to stored object instance.
3427   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3428   volatile_limit_reference<T_obj> obj_;
3429 };
3430
3431 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3432 //template specialization of visitor<>::do_visit_each<>(action, functor):
3433 /** Performs a functor on each of the targets of a functor.
3434  * The function overload for sigc::bound_volatile_mem_functor performs a functor
3435  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
3436  *
3437  * @ingroup mem_fun
3438  */
3439 template <class T_return, class T_obj, class T_arg1, class T_arg2>
3440 struct visitor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
3441 {
3442   template <class T_action>
3443   static void do_visit_each(const T_action& _A_action,
3444                             const bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
3445   {
3446     sigc::visit_each(_A_action, _A_target.obj_);
3447   }
3448 };
3449 #endif // DOXYGEN_SHOULD_SKIP_THIS
3450
3451 /** bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.
3452  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor3.
3453  *
3454  * The following template arguments are used:
3455  * - @e T_arg1 Argument type used in the definition of operator()().
3456  * - @e T_arg2 Argument type used in the definition of operator()().
3457  * - @e T_arg3 Argument type used in the definition of operator()().
3458  * - @e T_return The return type of operator()().
3459  * - @e T_obj The object type.
3460  *
3461  * @ingroup mem_fun
3462  */
3463 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
3464 class bound_volatile_mem_functor3
3465   : public volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
3466 {
3467   typedef volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
3468 public:
3469   typedef typename base_type_::function_type function_type;
3470
3471 #ifndef SIGCXX_DISABLE_DEPRECATED
3472   /** Constructs a bound_volatile_mem_functor3 object that wraps the passed method.
3473    *
3474    * @deprecated Please use the constructor that takes the object by reference
3475    * instead.
3476    *
3477    * @param _A_obj Pointer to instance the method will operate on.
3478    * @param _A_func Pointer to method will be invoked from operator()().
3479    */
3480   bound_volatile_mem_functor3( T_obj* _A_obj, function_type _A_func)
3481     : base_type_(_A_func),
3482       obj_(*_A_obj)
3483     {}
3484 #endif // SIGCXX_DISABLE_DEPRECATED
3485
3486   /** Constructs a bound_volatile_mem_functor3 object that wraps the passed method.
3487    * @param _A_obj Reference to instance the method will operate on.
3488    * @param _A_func Pointer to method will be invoked from operator()().
3489    */
3490   bound_volatile_mem_functor3( T_obj& _A_obj, function_type _A_func)
3491     : base_type_(_A_func),
3492       obj_(_A_obj)
3493     {}
3494
3495   /** Execute the wrapped method operating on the stored instance.
3496    * @param _A_a1 Argument to be passed on to the method.
3497    * @param _A_a2 Argument to be passed on to the method.
3498    * @param _A_a3 Argument to be passed on to the method.
3499    * @return The return value of the method invocation.
3500    */
3501   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
3502     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
3503
3504 //protected:
3505   // Reference to stored object instance.
3506   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3507   volatile_limit_reference<T_obj> obj_;
3508 };
3509
3510 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3511 //template specialization of visitor<>::do_visit_each<>(action, functor):
3512 /** Performs a functor on each of the targets of a functor.
3513  * The function overload for sigc::bound_volatile_mem_functor performs a functor
3514  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
3515  *
3516  * @ingroup mem_fun
3517  */
3518 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
3519 struct visitor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
3520 {
3521   template <class T_action>
3522   static void do_visit_each(const T_action& _A_action,
3523                             const bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
3524   {
3525     sigc::visit_each(_A_action, _A_target.obj_);
3526   }
3527 };
3528 #endif // DOXYGEN_SHOULD_SKIP_THIS
3529
3530 /** bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.
3531  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor4.
3532  *
3533  * The following template arguments are used:
3534  * - @e T_arg1 Argument type used in the definition of operator()().
3535  * - @e T_arg2 Argument type used in the definition of operator()().
3536  * - @e T_arg3 Argument type used in the definition of operator()().
3537  * - @e T_arg4 Argument type used in the definition of operator()().
3538  * - @e T_return The return type of operator()().
3539  * - @e T_obj The object type.
3540  *
3541  * @ingroup mem_fun
3542  */
3543 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
3544 class bound_volatile_mem_functor4
3545   : public volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
3546 {
3547   typedef volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
3548 public:
3549   typedef typename base_type_::function_type function_type;
3550
3551 #ifndef SIGCXX_DISABLE_DEPRECATED
3552   /** Constructs a bound_volatile_mem_functor4 object that wraps the passed method.
3553    *
3554    * @deprecated Please use the constructor that takes the object by reference
3555    * instead.
3556    *
3557    * @param _A_obj Pointer to instance the method will operate on.
3558    * @param _A_func Pointer to method will be invoked from operator()().
3559    */
3560   bound_volatile_mem_functor4( T_obj* _A_obj, function_type _A_func)
3561     : base_type_(_A_func),
3562       obj_(*_A_obj)
3563     {}
3564 #endif // SIGCXX_DISABLE_DEPRECATED
3565
3566   /** Constructs a bound_volatile_mem_functor4 object that wraps the passed method.
3567    * @param _A_obj Reference to instance the method will operate on.
3568    * @param _A_func Pointer to method will be invoked from operator()().
3569    */
3570   bound_volatile_mem_functor4( T_obj& _A_obj, function_type _A_func)
3571     : base_type_(_A_func),
3572       obj_(_A_obj)
3573     {}
3574
3575   /** Execute the wrapped method operating on the stored instance.
3576    * @param _A_a1 Argument to be passed on to the method.
3577    * @param _A_a2 Argument to be passed on to the method.
3578    * @param _A_a3 Argument to be passed on to the method.
3579    * @param _A_a4 Argument to be passed on to the method.
3580    * @return The return value of the method invocation.
3581    */
3582   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
3583     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
3584
3585 //protected:
3586   // Reference to stored object instance.
3587   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3588   volatile_limit_reference<T_obj> obj_;
3589 };
3590
3591 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3592 //template specialization of visitor<>::do_visit_each<>(action, functor):
3593 /** Performs a functor on each of the targets of a functor.
3594  * The function overload for sigc::bound_volatile_mem_functor performs a functor
3595  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
3596  *
3597  * @ingroup mem_fun
3598  */
3599 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
3600 struct visitor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
3601 {
3602   template <class T_action>
3603   static void do_visit_each(const T_action& _A_action,
3604                             const bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
3605   {
3606     sigc::visit_each(_A_action, _A_target.obj_);
3607   }
3608 };
3609 #endif // DOXYGEN_SHOULD_SKIP_THIS
3610
3611 /** bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.
3612  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor5.
3613  *
3614  * The following template arguments are used:
3615  * - @e T_arg1 Argument type used in the definition of operator()().
3616  * - @e T_arg2 Argument type used in the definition of operator()().
3617  * - @e T_arg3 Argument type used in the definition of operator()().
3618  * - @e T_arg4 Argument type used in the definition of operator()().
3619  * - @e T_arg5 Argument type used in the definition of operator()().
3620  * - @e T_return The return type of operator()().
3621  * - @e T_obj The object type.
3622  *
3623  * @ingroup mem_fun
3624  */
3625 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
3626 class bound_volatile_mem_functor5
3627   : public volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
3628 {
3629   typedef volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
3630 public:
3631   typedef typename base_type_::function_type function_type;
3632
3633 #ifndef SIGCXX_DISABLE_DEPRECATED
3634   /** Constructs a bound_volatile_mem_functor5 object that wraps the passed method.
3635    *
3636    * @deprecated Please use the constructor that takes the object by reference
3637    * instead.
3638    *
3639    * @param _A_obj Pointer to instance the method will operate on.
3640    * @param _A_func Pointer to method will be invoked from operator()().
3641    */
3642   bound_volatile_mem_functor5( T_obj* _A_obj, function_type _A_func)
3643     : base_type_(_A_func),
3644       obj_(*_A_obj)
3645     {}
3646 #endif // SIGCXX_DISABLE_DEPRECATED
3647
3648   /** Constructs a bound_volatile_mem_functor5 object that wraps the passed method.
3649    * @param _A_obj Reference to instance the method will operate on.
3650    * @param _A_func Pointer to method will be invoked from operator()().
3651    */
3652   bound_volatile_mem_functor5( T_obj& _A_obj, function_type _A_func)
3653     : base_type_(_A_func),
3654       obj_(_A_obj)
3655     {}
3656
3657   /** Execute the wrapped method operating on the stored instance.
3658    * @param _A_a1 Argument to be passed on to the method.
3659    * @param _A_a2 Argument to be passed on to the method.
3660    * @param _A_a3 Argument to be passed on to the method.
3661    * @param _A_a4 Argument to be passed on to the method.
3662    * @param _A_a5 Argument to be passed on to the method.
3663    * @return The return value of the method invocation.
3664    */
3665   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
3666     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
3667
3668 //protected:
3669   // Reference to stored object instance.
3670   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3671   volatile_limit_reference<T_obj> obj_;
3672 };
3673
3674 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3675 //template specialization of visitor<>::do_visit_each<>(action, functor):
3676 /** Performs a functor on each of the targets of a functor.
3677  * The function overload for sigc::bound_volatile_mem_functor performs a functor
3678  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
3679  *
3680  * @ingroup mem_fun
3681  */
3682 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
3683 struct visitor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
3684 {
3685   template <class T_action>
3686   static void do_visit_each(const T_action& _A_action,
3687                             const bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
3688   {
3689     sigc::visit_each(_A_action, _A_target.obj_);
3690   }
3691 };
3692 #endif // DOXYGEN_SHOULD_SKIP_THIS
3693
3694 /** bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.
3695  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor6.
3696  *
3697  * The following template arguments are used:
3698  * - @e T_arg1 Argument type used in the definition of operator()().
3699  * - @e T_arg2 Argument type used in the definition of operator()().
3700  * - @e T_arg3 Argument type used in the definition of operator()().
3701  * - @e T_arg4 Argument type used in the definition of operator()().
3702  * - @e T_arg5 Argument type used in the definition of operator()().
3703  * - @e T_arg6 Argument type used in the definition of operator()().
3704  * - @e T_return The return type of operator()().
3705  * - @e T_obj The object type.
3706  *
3707  * @ingroup mem_fun
3708  */
3709 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
3710 class bound_volatile_mem_functor6
3711   : public volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
3712 {
3713   typedef volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
3714 public:
3715   typedef typename base_type_::function_type function_type;
3716
3717 #ifndef SIGCXX_DISABLE_DEPRECATED
3718   /** Constructs a bound_volatile_mem_functor6 object that wraps the passed method.
3719    *
3720    * @deprecated Please use the constructor that takes the object by reference
3721    * instead.
3722    *
3723    * @param _A_obj Pointer to instance the method will operate on.
3724    * @param _A_func Pointer to method will be invoked from operator()().
3725    */
3726   bound_volatile_mem_functor6( T_obj* _A_obj, function_type _A_func)
3727     : base_type_(_A_func),
3728       obj_(*_A_obj)
3729     {}
3730 #endif // SIGCXX_DISABLE_DEPRECATED
3731
3732   /** Constructs a bound_volatile_mem_functor6 object that wraps the passed method.
3733    * @param _A_obj Reference to instance the method will operate on.
3734    * @param _A_func Pointer to method will be invoked from operator()().
3735    */
3736   bound_volatile_mem_functor6( T_obj& _A_obj, function_type _A_func)
3737     : base_type_(_A_func),
3738       obj_(_A_obj)
3739     {}
3740
3741   /** Execute the wrapped method operating on the stored instance.
3742    * @param _A_a1 Argument to be passed on to the method.
3743    * @param _A_a2 Argument to be passed on to the method.
3744    * @param _A_a3 Argument to be passed on to the method.
3745    * @param _A_a4 Argument to be passed on to the method.
3746    * @param _A_a5 Argument to be passed on to the method.
3747    * @param _A_a6 Argument to be passed on to the method.
3748    * @return The return value of the method invocation.
3749    */
3750   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
3751     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
3752
3753 //protected:
3754   // Reference to stored object instance.
3755   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3756   volatile_limit_reference<T_obj> obj_;
3757 };
3758
3759 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3760 //template specialization of visitor<>::do_visit_each<>(action, functor):
3761 /** Performs a functor on each of the targets of a functor.
3762  * The function overload for sigc::bound_volatile_mem_functor performs a functor
3763  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
3764  *
3765  * @ingroup mem_fun
3766  */
3767 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
3768 struct visitor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
3769 {
3770   template <class T_action>
3771   static void do_visit_each(const T_action& _A_action,
3772                             const bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
3773   {
3774     sigc::visit_each(_A_action, _A_target.obj_);
3775   }
3776 };
3777 #endif // DOXYGEN_SHOULD_SKIP_THIS
3778
3779 /** bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.
3780  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor7.
3781  *
3782  * The following template arguments are used:
3783  * - @e T_arg1 Argument type used in the definition of operator()().
3784  * - @e T_arg2 Argument type used in the definition of operator()().
3785  * - @e T_arg3 Argument type used in the definition of operator()().
3786  * - @e T_arg4 Argument type used in the definition of operator()().
3787  * - @e T_arg5 Argument type used in the definition of operator()().
3788  * - @e T_arg6 Argument type used in the definition of operator()().
3789  * - @e T_arg7 Argument type used in the definition of operator()().
3790  * - @e T_return The return type of operator()().
3791  * - @e T_obj The object type.
3792  *
3793  * @ingroup mem_fun
3794  */
3795 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
3796 class bound_volatile_mem_functor7
3797   : public volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
3798 {
3799   typedef volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
3800 public:
3801   typedef typename base_type_::function_type function_type;
3802
3803 #ifndef SIGCXX_DISABLE_DEPRECATED
3804   /** Constructs a bound_volatile_mem_functor7 object that wraps the passed method.
3805    *
3806    * @deprecated Please use the constructor that takes the object by reference
3807    * instead.
3808    *
3809    * @param _A_obj Pointer to instance the method will operate on.
3810    * @param _A_func Pointer to method will be invoked from operator()().
3811    */
3812   bound_volatile_mem_functor7( T_obj* _A_obj, function_type _A_func)
3813     : base_type_(_A_func),
3814       obj_(*_A_obj)
3815     {}
3816 #endif // SIGCXX_DISABLE_DEPRECATED
3817
3818   /** Constructs a bound_volatile_mem_functor7 object that wraps the passed method.
3819    * @param _A_obj Reference to instance the method will operate on.
3820    * @param _A_func Pointer to method will be invoked from operator()().
3821    */
3822   bound_volatile_mem_functor7( T_obj& _A_obj, function_type _A_func)
3823     : base_type_(_A_func),
3824       obj_(_A_obj)
3825     {}
3826
3827   /** Execute the wrapped method operating on the stored instance.
3828    * @param _A_a1 Argument to be passed on to the method.
3829    * @param _A_a2 Argument to be passed on to the method.
3830    * @param _A_a3 Argument to be passed on to the method.
3831    * @param _A_a4 Argument to be passed on to the method.
3832    * @param _A_a5 Argument to be passed on to the method.
3833    * @param _A_a6 Argument to be passed on to the method.
3834    * @param _A_a7 Argument to be passed on to the method.
3835    * @return The return value of the method invocation.
3836    */
3837   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
3838     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
3839
3840 //protected:
3841   // Reference to stored object instance.
3842   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3843   volatile_limit_reference<T_obj> obj_;
3844 };
3845
3846 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3847 //template specialization of visitor<>::do_visit_each<>(action, functor):
3848 /** Performs a functor on each of the targets of a functor.
3849  * The function overload for sigc::bound_volatile_mem_functor performs a functor
3850  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
3851  *
3852  * @ingroup mem_fun
3853  */
3854 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
3855 struct visitor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
3856 {
3857   template <class T_action>
3858   static void do_visit_each(const T_action& _A_action,
3859                             const bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
3860   {
3861     sigc::visit_each(_A_action, _A_target.obj_);
3862   }
3863 };
3864 #endif // DOXYGEN_SHOULD_SKIP_THIS
3865
3866 /** bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance.
3867  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor0.
3868  *
3869  * The following template arguments are used:
3870  * - @e T_return The return type of operator()().
3871  * - @e T_obj The object type.
3872  *
3873  * @ingroup mem_fun
3874  */
3875 template <class T_return, class T_obj>
3876 class bound_const_volatile_mem_functor0
3877   : public const_volatile_mem_functor0<T_return, T_obj>
3878 {
3879   typedef const_volatile_mem_functor0<T_return, T_obj> base_type_;
3880 public:
3881   typedef typename base_type_::function_type function_type;
3882
3883 #ifndef SIGCXX_DISABLE_DEPRECATED
3884   /** Constructs a bound_const_volatile_mem_functor0 object that wraps the passed method.
3885    *
3886    * @deprecated Please use the constructor that takes the object by reference
3887    * instead.
3888    *
3889    * @param _A_obj Pointer to instance the method will operate on.
3890    * @param _A_func Pointer to method will be invoked from operator()().
3891    */
3892   bound_const_volatile_mem_functor0(const T_obj* _A_obj, function_type _A_func)
3893     : base_type_(_A_func),
3894       obj_(*_A_obj)
3895     {}
3896 #endif // SIGCXX_DISABLE_DEPRECATED
3897
3898   /** Constructs a bound_const_volatile_mem_functor0 object that wraps the passed method.
3899    * @param _A_obj Reference to instance the method will operate on.
3900    * @param _A_func Pointer to method will be invoked from operator()().
3901    */
3902   bound_const_volatile_mem_functor0(const T_obj& _A_obj, function_type _A_func)
3903     : base_type_(_A_func),
3904       obj_(_A_obj)
3905     {}
3906
3907   /** Execute the wrapped method operating on the stored instance.
3908    * @return The return value of the method invocation.
3909    */
3910   T_return operator()() const
3911     { return (obj_.invoke().*(this->func_ptr_))(); }
3912
3913 //protected:
3914   // Reference to stored object instance.
3915   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3916   const_volatile_limit_reference<T_obj> obj_;
3917 };
3918
3919 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3920 //template specialization of visitor<>::do_visit_each<>(action, functor):
3921 /** Performs a functor on each of the targets of a functor.
3922  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
3923  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
3924  *
3925  * @ingroup mem_fun
3926  */
3927 template <class T_return, class T_obj>
3928 struct visitor<bound_const_volatile_mem_functor0<T_return, T_obj> >
3929 {
3930   template <class T_action>
3931   static void do_visit_each(const T_action& _A_action,
3932                             const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_target)
3933   {
3934     sigc::visit_each(_A_action, _A_target.obj_);
3935   }
3936 };
3937 #endif // DOXYGEN_SHOULD_SKIP_THIS
3938
3939 /** bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance.
3940  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor1.
3941  *
3942  * The following template arguments are used:
3943  * - @e T_arg1 Argument type used in the definition of operator()().
3944  * - @e T_return The return type of operator()().
3945  * - @e T_obj The object type.
3946  *
3947  * @ingroup mem_fun
3948  */
3949 template <class T_return, class T_obj, class T_arg1>
3950 class bound_const_volatile_mem_functor1
3951   : public const_volatile_mem_functor1<T_return, T_obj, T_arg1>
3952 {
3953   typedef const_volatile_mem_functor1<T_return, T_obj, T_arg1> base_type_;
3954 public:
3955   typedef typename base_type_::function_type function_type;
3956
3957 #ifndef SIGCXX_DISABLE_DEPRECATED
3958   /** Constructs a bound_const_volatile_mem_functor1 object that wraps the passed method.
3959    *
3960    * @deprecated Please use the constructor that takes the object by reference
3961    * instead.
3962    *
3963    * @param _A_obj Pointer to instance the method will operate on.
3964    * @param _A_func Pointer to method will be invoked from operator()().
3965    */
3966   bound_const_volatile_mem_functor1(const T_obj* _A_obj, function_type _A_func)
3967     : base_type_(_A_func),
3968       obj_(*_A_obj)
3969     {}
3970 #endif // SIGCXX_DISABLE_DEPRECATED
3971
3972   /** Constructs a bound_const_volatile_mem_functor1 object that wraps the passed method.
3973    * @param _A_obj Reference to instance the method will operate on.
3974    * @param _A_func Pointer to method will be invoked from operator()().
3975    */
3976   bound_const_volatile_mem_functor1(const T_obj& _A_obj, function_type _A_func)
3977     : base_type_(_A_func),
3978       obj_(_A_obj)
3979     {}
3980
3981   /** Execute the wrapped method operating on the stored instance.
3982    * @param _A_a1 Argument to be passed on to the method.
3983    * @return The return value of the method invocation.
3984    */
3985   T_return operator()(type_trait_take_t<T_arg1> _A_a1) const
3986     { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
3987
3988 //protected:
3989   // Reference to stored object instance.
3990   // This is the handler object, such as TheObject in void TheObject::signal_handler().
3991   const_volatile_limit_reference<T_obj> obj_;
3992 };
3993
3994 #ifndef DOXYGEN_SHOULD_SKIP_THIS
3995 //template specialization of visitor<>::do_visit_each<>(action, functor):
3996 /** Performs a functor on each of the targets of a functor.
3997  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
3998  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
3999  *
4000  * @ingroup mem_fun
4001  */
4002 template <class T_return, class T_obj, class T_arg1>
4003 struct visitor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1> >
4004 {
4005   template <class T_action>
4006   static void do_visit_each(const T_action& _A_action,
4007                             const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
4008   {
4009     sigc::visit_each(_A_action, _A_target.obj_);
4010   }
4011 };
4012 #endif // DOXYGEN_SHOULD_SKIP_THIS
4013
4014 /** bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance.
4015  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor2.
4016  *
4017  * The following template arguments are used:
4018  * - @e T_arg1 Argument type used in the definition of operator()().
4019  * - @e T_arg2 Argument type used in the definition of operator()().
4020  * - @e T_return The return type of operator()().
4021  * - @e T_obj The object type.
4022  *
4023  * @ingroup mem_fun
4024  */
4025 template <class T_return, class T_obj, class T_arg1, class T_arg2>
4026 class bound_const_volatile_mem_functor2
4027   : public const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
4028 {
4029   typedef const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> base_type_;
4030 public:
4031   typedef typename base_type_::function_type function_type;
4032
4033 #ifndef SIGCXX_DISABLE_DEPRECATED
4034   /** Constructs a bound_const_volatile_mem_functor2 object that wraps the passed method.
4035    *
4036    * @deprecated Please use the constructor that takes the object by reference
4037    * instead.
4038    *
4039    * @param _A_obj Pointer to instance the method will operate on.
4040    * @param _A_func Pointer to method will be invoked from operator()().
4041    */
4042   bound_const_volatile_mem_functor2(const T_obj* _A_obj, function_type _A_func)
4043     : base_type_(_A_func),
4044       obj_(*_A_obj)
4045     {}
4046 #endif // SIGCXX_DISABLE_DEPRECATED
4047
4048   /** Constructs a bound_const_volatile_mem_functor2 object that wraps the passed method.
4049    * @param _A_obj Reference to instance the method will operate on.
4050    * @param _A_func Pointer to method will be invoked from operator()().
4051    */
4052   bound_const_volatile_mem_functor2(const T_obj& _A_obj, function_type _A_func)
4053     : base_type_(_A_func),
4054       obj_(_A_obj)
4055     {}
4056
4057   /** Execute the wrapped method operating on the stored instance.
4058    * @param _A_a1 Argument to be passed on to the method.
4059    * @param _A_a2 Argument to be passed on to the method.
4060    * @return The return value of the method invocation.
4061    */
4062   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2) const
4063     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2); }
4064
4065 //protected:
4066   // Reference to stored object instance.
4067   // This is the handler object, such as TheObject in void TheObject::signal_handler().
4068   const_volatile_limit_reference<T_obj> obj_;
4069 };
4070
4071 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4072 //template specialization of visitor<>::do_visit_each<>(action, functor):
4073 /** Performs a functor on each of the targets of a functor.
4074  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
4075  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
4076  *
4077  * @ingroup mem_fun
4078  */
4079 template <class T_return, class T_obj, class T_arg1, class T_arg2>
4080 struct visitor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2> >
4081 {
4082   template <class T_action>
4083   static void do_visit_each(const T_action& _A_action,
4084                             const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_target)
4085   {
4086     sigc::visit_each(_A_action, _A_target.obj_);
4087   }
4088 };
4089 #endif // DOXYGEN_SHOULD_SKIP_THIS
4090
4091 /** bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance.
4092  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor3.
4093  *
4094  * The following template arguments are used:
4095  * - @e T_arg1 Argument type used in the definition of operator()().
4096  * - @e T_arg2 Argument type used in the definition of operator()().
4097  * - @e T_arg3 Argument type used in the definition of operator()().
4098  * - @e T_return The return type of operator()().
4099  * - @e T_obj The object type.
4100  *
4101  * @ingroup mem_fun
4102  */
4103 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
4104 class bound_const_volatile_mem_functor3
4105   : public const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
4106 {
4107   typedef const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> base_type_;
4108 public:
4109   typedef typename base_type_::function_type function_type;
4110
4111 #ifndef SIGCXX_DISABLE_DEPRECATED
4112   /** Constructs a bound_const_volatile_mem_functor3 object that wraps the passed method.
4113    *
4114    * @deprecated Please use the constructor that takes the object by reference
4115    * instead.
4116    *
4117    * @param _A_obj Pointer to instance the method will operate on.
4118    * @param _A_func Pointer to method will be invoked from operator()().
4119    */
4120   bound_const_volatile_mem_functor3(const T_obj* _A_obj, function_type _A_func)
4121     : base_type_(_A_func),
4122       obj_(*_A_obj)
4123     {}
4124 #endif // SIGCXX_DISABLE_DEPRECATED
4125
4126   /** Constructs a bound_const_volatile_mem_functor3 object that wraps the passed method.
4127    * @param _A_obj Reference to instance the method will operate on.
4128    * @param _A_func Pointer to method will be invoked from operator()().
4129    */
4130   bound_const_volatile_mem_functor3(const T_obj& _A_obj, function_type _A_func)
4131     : base_type_(_A_func),
4132       obj_(_A_obj)
4133     {}
4134
4135   /** Execute the wrapped method operating on the stored instance.
4136    * @param _A_a1 Argument to be passed on to the method.
4137    * @param _A_a2 Argument to be passed on to the method.
4138    * @param _A_a3 Argument to be passed on to the method.
4139    * @return The return value of the method invocation.
4140    */
4141   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3) const
4142     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3); }
4143
4144 //protected:
4145   // Reference to stored object instance.
4146   // This is the handler object, such as TheObject in void TheObject::signal_handler().
4147   const_volatile_limit_reference<T_obj> obj_;
4148 };
4149
4150 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4151 //template specialization of visitor<>::do_visit_each<>(action, functor):
4152 /** Performs a functor on each of the targets of a functor.
4153  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
4154  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
4155  *
4156  * @ingroup mem_fun
4157  */
4158 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3>
4159 struct visitor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3> >
4160 {
4161   template <class T_action>
4162   static void do_visit_each(const T_action& _A_action,
4163                             const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_target)
4164   {
4165     sigc::visit_each(_A_action, _A_target.obj_);
4166   }
4167 };
4168 #endif // DOXYGEN_SHOULD_SKIP_THIS
4169
4170 /** bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance.
4171  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor4.
4172  *
4173  * The following template arguments are used:
4174  * - @e T_arg1 Argument type used in the definition of operator()().
4175  * - @e T_arg2 Argument type used in the definition of operator()().
4176  * - @e T_arg3 Argument type used in the definition of operator()().
4177  * - @e T_arg4 Argument type used in the definition of operator()().
4178  * - @e T_return The return type of operator()().
4179  * - @e T_obj The object type.
4180  *
4181  * @ingroup mem_fun
4182  */
4183 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
4184 class bound_const_volatile_mem_functor4
4185   : public const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
4186 {
4187   typedef const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> base_type_;
4188 public:
4189   typedef typename base_type_::function_type function_type;
4190
4191 #ifndef SIGCXX_DISABLE_DEPRECATED
4192   /** Constructs a bound_const_volatile_mem_functor4 object that wraps the passed method.
4193    *
4194    * @deprecated Please use the constructor that takes the object by reference
4195    * instead.
4196    *
4197    * @param _A_obj Pointer to instance the method will operate on.
4198    * @param _A_func Pointer to method will be invoked from operator()().
4199    */
4200   bound_const_volatile_mem_functor4(const T_obj* _A_obj, function_type _A_func)
4201     : base_type_(_A_func),
4202       obj_(*_A_obj)
4203     {}
4204 #endif // SIGCXX_DISABLE_DEPRECATED
4205
4206   /** Constructs a bound_const_volatile_mem_functor4 object that wraps the passed method.
4207    * @param _A_obj Reference to instance the method will operate on.
4208    * @param _A_func Pointer to method will be invoked from operator()().
4209    */
4210   bound_const_volatile_mem_functor4(const T_obj& _A_obj, function_type _A_func)
4211     : base_type_(_A_func),
4212       obj_(_A_obj)
4213     {}
4214
4215   /** Execute the wrapped method operating on the stored instance.
4216    * @param _A_a1 Argument to be passed on to the method.
4217    * @param _A_a2 Argument to be passed on to the method.
4218    * @param _A_a3 Argument to be passed on to the method.
4219    * @param _A_a4 Argument to be passed on to the method.
4220    * @return The return value of the method invocation.
4221    */
4222   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4) const
4223     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4); }
4224
4225 //protected:
4226   // Reference to stored object instance.
4227   // This is the handler object, such as TheObject in void TheObject::signal_handler().
4228   const_volatile_limit_reference<T_obj> obj_;
4229 };
4230
4231 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4232 //template specialization of visitor<>::do_visit_each<>(action, functor):
4233 /** Performs a functor on each of the targets of a functor.
4234  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
4235  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
4236  *
4237  * @ingroup mem_fun
4238  */
4239 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
4240 struct visitor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> >
4241 {
4242   template <class T_action>
4243   static void do_visit_each(const T_action& _A_action,
4244                             const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_target)
4245   {
4246     sigc::visit_each(_A_action, _A_target.obj_);
4247   }
4248 };
4249 #endif // DOXYGEN_SHOULD_SKIP_THIS
4250
4251 /** bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance.
4252  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor5.
4253  *
4254  * The following template arguments are used:
4255  * - @e T_arg1 Argument type used in the definition of operator()().
4256  * - @e T_arg2 Argument type used in the definition of operator()().
4257  * - @e T_arg3 Argument type used in the definition of operator()().
4258  * - @e T_arg4 Argument type used in the definition of operator()().
4259  * - @e T_arg5 Argument type used in the definition of operator()().
4260  * - @e T_return The return type of operator()().
4261  * - @e T_obj The object type.
4262  *
4263  * @ingroup mem_fun
4264  */
4265 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
4266 class bound_const_volatile_mem_functor5
4267   : public const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
4268 {
4269   typedef const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> base_type_;
4270 public:
4271   typedef typename base_type_::function_type function_type;
4272
4273 #ifndef SIGCXX_DISABLE_DEPRECATED
4274   /** Constructs a bound_const_volatile_mem_functor5 object that wraps the passed method.
4275    *
4276    * @deprecated Please use the constructor that takes the object by reference
4277    * instead.
4278    *
4279    * @param _A_obj Pointer to instance the method will operate on.
4280    * @param _A_func Pointer to method will be invoked from operator()().
4281    */
4282   bound_const_volatile_mem_functor5(const T_obj* _A_obj, function_type _A_func)
4283     : base_type_(_A_func),
4284       obj_(*_A_obj)
4285     {}
4286 #endif // SIGCXX_DISABLE_DEPRECATED
4287
4288   /** Constructs a bound_const_volatile_mem_functor5 object that wraps the passed method.
4289    * @param _A_obj Reference to instance the method will operate on.
4290    * @param _A_func Pointer to method will be invoked from operator()().
4291    */
4292   bound_const_volatile_mem_functor5(const T_obj& _A_obj, function_type _A_func)
4293     : base_type_(_A_func),
4294       obj_(_A_obj)
4295     {}
4296
4297   /** Execute the wrapped method operating on the stored instance.
4298    * @param _A_a1 Argument to be passed on to the method.
4299    * @param _A_a2 Argument to be passed on to the method.
4300    * @param _A_a3 Argument to be passed on to the method.
4301    * @param _A_a4 Argument to be passed on to the method.
4302    * @param _A_a5 Argument to be passed on to the method.
4303    * @return The return value of the method invocation.
4304    */
4305   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5) const
4306     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
4307
4308 //protected:
4309   // Reference to stored object instance.
4310   // This is the handler object, such as TheObject in void TheObject::signal_handler().
4311   const_volatile_limit_reference<T_obj> obj_;
4312 };
4313
4314 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4315 //template specialization of visitor<>::do_visit_each<>(action, functor):
4316 /** Performs a functor on each of the targets of a functor.
4317  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
4318  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
4319  *
4320  * @ingroup mem_fun
4321  */
4322 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
4323 struct visitor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> >
4324 {
4325   template <class T_action>
4326   static void do_visit_each(const T_action& _A_action,
4327                             const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_target)
4328   {
4329     sigc::visit_each(_A_action, _A_target.obj_);
4330   }
4331 };
4332 #endif // DOXYGEN_SHOULD_SKIP_THIS
4333
4334 /** bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance.
4335  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor6.
4336  *
4337  * The following template arguments are used:
4338  * - @e T_arg1 Argument type used in the definition of operator()().
4339  * - @e T_arg2 Argument type used in the definition of operator()().
4340  * - @e T_arg3 Argument type used in the definition of operator()().
4341  * - @e T_arg4 Argument type used in the definition of operator()().
4342  * - @e T_arg5 Argument type used in the definition of operator()().
4343  * - @e T_arg6 Argument type used in the definition of operator()().
4344  * - @e T_return The return type of operator()().
4345  * - @e T_obj The object type.
4346  *
4347  * @ingroup mem_fun
4348  */
4349 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
4350 class bound_const_volatile_mem_functor6
4351   : public const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
4352 {
4353   typedef const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> base_type_;
4354 public:
4355   typedef typename base_type_::function_type function_type;
4356
4357 #ifndef SIGCXX_DISABLE_DEPRECATED
4358   /** Constructs a bound_const_volatile_mem_functor6 object that wraps the passed method.
4359    *
4360    * @deprecated Please use the constructor that takes the object by reference
4361    * instead.
4362    *
4363    * @param _A_obj Pointer to instance the method will operate on.
4364    * @param _A_func Pointer to method will be invoked from operator()().
4365    */
4366   bound_const_volatile_mem_functor6(const T_obj* _A_obj, function_type _A_func)
4367     : base_type_(_A_func),
4368       obj_(*_A_obj)
4369     {}
4370 #endif // SIGCXX_DISABLE_DEPRECATED
4371
4372   /** Constructs a bound_const_volatile_mem_functor6 object that wraps the passed method.
4373    * @param _A_obj Reference to instance the method will operate on.
4374    * @param _A_func Pointer to method will be invoked from operator()().
4375    */
4376   bound_const_volatile_mem_functor6(const T_obj& _A_obj, function_type _A_func)
4377     : base_type_(_A_func),
4378       obj_(_A_obj)
4379     {}
4380
4381   /** Execute the wrapped method operating on the stored instance.
4382    * @param _A_a1 Argument to be passed on to the method.
4383    * @param _A_a2 Argument to be passed on to the method.
4384    * @param _A_a3 Argument to be passed on to the method.
4385    * @param _A_a4 Argument to be passed on to the method.
4386    * @param _A_a5 Argument to be passed on to the method.
4387    * @param _A_a6 Argument to be passed on to the method.
4388    * @return The return value of the method invocation.
4389    */
4390   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6) const
4391     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
4392
4393 //protected:
4394   // Reference to stored object instance.
4395   // This is the handler object, such as TheObject in void TheObject::signal_handler().
4396   const_volatile_limit_reference<T_obj> obj_;
4397 };
4398
4399 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4400 //template specialization of visitor<>::do_visit_each<>(action, functor):
4401 /** Performs a functor on each of the targets of a functor.
4402  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
4403  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
4404  *
4405  * @ingroup mem_fun
4406  */
4407 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
4408 struct visitor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> >
4409 {
4410   template <class T_action>
4411   static void do_visit_each(const T_action& _A_action,
4412                             const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_target)
4413   {
4414     sigc::visit_each(_A_action, _A_target.obj_);
4415   }
4416 };
4417 #endif // DOXYGEN_SHOULD_SKIP_THIS
4418
4419 /** bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance.
4420  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor7.
4421  *
4422  * The following template arguments are used:
4423  * - @e T_arg1 Argument type used in the definition of operator()().
4424  * - @e T_arg2 Argument type used in the definition of operator()().
4425  * - @e T_arg3 Argument type used in the definition of operator()().
4426  * - @e T_arg4 Argument type used in the definition of operator()().
4427  * - @e T_arg5 Argument type used in the definition of operator()().
4428  * - @e T_arg6 Argument type used in the definition of operator()().
4429  * - @e T_arg7 Argument type used in the definition of operator()().
4430  * - @e T_return The return type of operator()().
4431  * - @e T_obj The object type.
4432  *
4433  * @ingroup mem_fun
4434  */
4435 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
4436 class bound_const_volatile_mem_functor7
4437   : public const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
4438 {
4439   typedef const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> base_type_;
4440 public:
4441   typedef typename base_type_::function_type function_type;
4442
4443 #ifndef SIGCXX_DISABLE_DEPRECATED
4444   /** Constructs a bound_const_volatile_mem_functor7 object that wraps the passed method.
4445    *
4446    * @deprecated Please use the constructor that takes the object by reference
4447    * instead.
4448    *
4449    * @param _A_obj Pointer to instance the method will operate on.
4450    * @param _A_func Pointer to method will be invoked from operator()().
4451    */
4452   bound_const_volatile_mem_functor7(const T_obj* _A_obj, function_type _A_func)
4453     : base_type_(_A_func),
4454       obj_(*_A_obj)
4455     {}
4456 #endif // SIGCXX_DISABLE_DEPRECATED
4457
4458   /** Constructs a bound_const_volatile_mem_functor7 object that wraps the passed method.
4459    * @param _A_obj Reference to instance the method will operate on.
4460    * @param _A_func Pointer to method will be invoked from operator()().
4461    */
4462   bound_const_volatile_mem_functor7(const T_obj& _A_obj, function_type _A_func)
4463     : base_type_(_A_func),
4464       obj_(_A_obj)
4465     {}
4466
4467   /** Execute the wrapped method operating on the stored instance.
4468    * @param _A_a1 Argument to be passed on to the method.
4469    * @param _A_a2 Argument to be passed on to the method.
4470    * @param _A_a3 Argument to be passed on to the method.
4471    * @param _A_a4 Argument to be passed on to the method.
4472    * @param _A_a5 Argument to be passed on to the method.
4473    * @param _A_a6 Argument to be passed on to the method.
4474    * @param _A_a7 Argument to be passed on to the method.
4475    * @return The return value of the method invocation.
4476    */
4477   T_return operator()(type_trait_take_t<T_arg1> _A_a1, type_trait_take_t<T_arg2> _A_a2, type_trait_take_t<T_arg3> _A_a3, type_trait_take_t<T_arg4> _A_a4, type_trait_take_t<T_arg5> _A_a5, type_trait_take_t<T_arg6> _A_a6, type_trait_take_t<T_arg7> _A_a7) const
4478     { return (obj_.invoke().*(this->func_ptr_))(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
4479
4480 //protected:
4481   // Reference to stored object instance.
4482   // This is the handler object, such as TheObject in void TheObject::signal_handler().
4483   const_volatile_limit_reference<T_obj> obj_;
4484 };
4485
4486 #ifndef DOXYGEN_SHOULD_SKIP_THIS
4487 //template specialization of visitor<>::do_visit_each<>(action, functor):
4488 /** Performs a functor on each of the targets of a functor.
4489  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
4490  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
4491  *
4492  * @ingroup mem_fun
4493  */
4494 template <class T_return, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
4495 struct visitor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> >
4496 {
4497   template <class T_action>
4498   static void do_visit_each(const T_action& _A_action,
4499                             const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_target)
4500   {
4501     sigc::visit_each(_A_action, _A_target.obj_);
4502   }
4503 };
4504 #endif // DOXYGEN_SHOULD_SKIP_THIS
4505
4506 // numbered
4507 /** Creates a functor of type sigc::mem_functor0 which wraps a  method.
4508  * @param _A_func Pointer to method that should be wrapped.
4509  * @return Functor that executes _A_func on invokation.
4510  *
4511  * @ingroup mem_fun
4512  */
4513 template <class T_return, class T_obj>
4514 inline mem_functor0<T_return, T_obj>
4515 mem_fun0(T_return (T_obj::*_A_func)() )
4516 { return mem_functor0<T_return, T_obj>(_A_func); }
4517
4518 /** Creates a functor of type sigc::mem_functor1 which wraps a  method.
4519  * @param _A_func Pointer to method that should be wrapped.
4520  * @return Functor that executes _A_func on invokation.
4521  *
4522  * @ingroup mem_fun
4523  */
4524 template <class T_arg1, class T_return, class T_obj>
4525 inline mem_functor1<T_return, T_obj, T_arg1>
4526 mem_fun1(T_return (T_obj::*_A_func)(T_arg1) )
4527 { return mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
4528
4529 /** Creates a functor of type sigc::mem_functor2 which wraps a  method.
4530  * @param _A_func Pointer to method that should be wrapped.
4531  * @return Functor that executes _A_func on invokation.
4532  *
4533  * @ingroup mem_fun
4534  */
4535 template <class T_arg1, class T_arg2, class T_return, class T_obj>
4536 inline mem_functor2<T_return, T_obj, T_arg1, T_arg2>
4537 mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) )
4538 { return mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
4539
4540 /** Creates a functor of type sigc::mem_functor3 which wraps a  method.
4541  * @param _A_func Pointer to method that should be wrapped.
4542  * @return Functor that executes _A_func on invokation.
4543  *
4544  * @ingroup mem_fun
4545  */
4546 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
4547 inline mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
4548 mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) )
4549 { return mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
4550
4551 /** Creates a functor of type sigc::mem_functor4 which wraps a  method.
4552  * @param _A_func Pointer to method that should be wrapped.
4553  * @return Functor that executes _A_func on invokation.
4554  *
4555  * @ingroup mem_fun
4556  */
4557 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
4558 inline mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
4559 mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
4560 { return mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
4561
4562 /** Creates a functor of type sigc::mem_functor5 which wraps a  method.
4563  * @param _A_func Pointer to method that should be wrapped.
4564  * @return Functor that executes _A_func on invokation.
4565  *
4566  * @ingroup mem_fun
4567  */
4568 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
4569 inline mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
4570 mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
4571 { return mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
4572
4573 /** Creates a functor of type sigc::mem_functor6 which wraps a  method.
4574  * @param _A_func Pointer to method that should be wrapped.
4575  * @return Functor that executes _A_func on invokation.
4576  *
4577  * @ingroup mem_fun
4578  */
4579 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
4580 inline mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
4581 mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
4582 { return mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
4583
4584 /** Creates a functor of type sigc::mem_functor7 which wraps a  method.
4585  * @param _A_func Pointer to method that should be wrapped.
4586  * @return Functor that executes _A_func on invokation.
4587  *
4588  * @ingroup mem_fun
4589  */
4590 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
4591 inline mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
4592 mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
4593 { return mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
4594
4595 /** Creates a functor of type sigc::const_mem_functor0 which wraps a const method.
4596  * @param _A_func Pointer to method that should be wrapped.
4597  * @return Functor that executes _A_func on invokation.
4598  *
4599  * @ingroup mem_fun
4600  */
4601 template <class T_return, class T_obj>
4602 inline const_mem_functor0<T_return, T_obj>
4603 mem_fun0(T_return (T_obj::*_A_func)() const)
4604 { return const_mem_functor0<T_return, T_obj>(_A_func); }
4605
4606 /** Creates a functor of type sigc::const_mem_functor1 which wraps a const method.
4607  * @param _A_func Pointer to method that should be wrapped.
4608  * @return Functor that executes _A_func on invokation.
4609  *
4610  * @ingroup mem_fun
4611  */
4612 template <class T_arg1, class T_return, class T_obj>
4613 inline const_mem_functor1<T_return, T_obj, T_arg1>
4614 mem_fun1(T_return (T_obj::*_A_func)(T_arg1) const)
4615 { return const_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
4616
4617 /** Creates a functor of type sigc::const_mem_functor2 which wraps a const method.
4618  * @param _A_func Pointer to method that should be wrapped.
4619  * @return Functor that executes _A_func on invokation.
4620  *
4621  * @ingroup mem_fun
4622  */
4623 template <class T_arg1, class T_arg2, class T_return, class T_obj>
4624 inline const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
4625 mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const)
4626 { return const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
4627
4628 /** Creates a functor of type sigc::const_mem_functor3 which wraps a const method.
4629  * @param _A_func Pointer to method that should be wrapped.
4630  * @return Functor that executes _A_func on invokation.
4631  *
4632  * @ingroup mem_fun
4633  */
4634 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
4635 inline const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
4636 mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const)
4637 { return const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
4638
4639 /** Creates a functor of type sigc::const_mem_functor4 which wraps a const method.
4640  * @param _A_func Pointer to method that should be wrapped.
4641  * @return Functor that executes _A_func on invokation.
4642  *
4643  * @ingroup mem_fun
4644  */
4645 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
4646 inline const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
4647 mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
4648 { return const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
4649
4650 /** Creates a functor of type sigc::const_mem_functor5 which wraps a const method.
4651  * @param _A_func Pointer to method that should be wrapped.
4652  * @return Functor that executes _A_func on invokation.
4653  *
4654  * @ingroup mem_fun
4655  */
4656 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
4657 inline const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
4658 mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
4659 { return const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
4660
4661 /** Creates a functor of type sigc::const_mem_functor6 which wraps a const method.
4662  * @param _A_func Pointer to method that should be wrapped.
4663  * @return Functor that executes _A_func on invokation.
4664  *
4665  * @ingroup mem_fun
4666  */
4667 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
4668 inline const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
4669 mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
4670 { return const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
4671
4672 /** Creates a functor of type sigc::const_mem_functor7 which wraps a const method.
4673  * @param _A_func Pointer to method that should be wrapped.
4674  * @return Functor that executes _A_func on invokation.
4675  *
4676  * @ingroup mem_fun
4677  */
4678 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
4679 inline const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
4680 mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
4681 { return const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
4682
4683 /** Creates a functor of type sigc::volatile_mem_functor0 which wraps a volatile method.
4684  * @param _A_func Pointer to method that should be wrapped.
4685  * @return Functor that executes _A_func on invokation.
4686  *
4687  * @ingroup mem_fun
4688  */
4689 template <class T_return, class T_obj>
4690 inline volatile_mem_functor0<T_return, T_obj>
4691 mem_fun0(T_return (T_obj::*_A_func)() volatile)
4692 { return volatile_mem_functor0<T_return, T_obj>(_A_func); }
4693
4694 /** Creates a functor of type sigc::volatile_mem_functor1 which wraps a volatile method.
4695  * @param _A_func Pointer to method that should be wrapped.
4696  * @return Functor that executes _A_func on invokation.
4697  *
4698  * @ingroup mem_fun
4699  */
4700 template <class T_arg1, class T_return, class T_obj>
4701 inline volatile_mem_functor1<T_return, T_obj, T_arg1>
4702 mem_fun1(T_return (T_obj::*_A_func)(T_arg1) volatile)
4703 { return volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
4704
4705 /** Creates a functor of type sigc::volatile_mem_functor2 which wraps a volatile method.
4706  * @param _A_func Pointer to method that should be wrapped.
4707  * @return Functor that executes _A_func on invokation.
4708  *
4709  * @ingroup mem_fun
4710  */
4711 template <class T_arg1, class T_arg2, class T_return, class T_obj>
4712 inline volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
4713 mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) volatile)
4714 { return volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
4715
4716 /** Creates a functor of type sigc::volatile_mem_functor3 which wraps a volatile method.
4717  * @param _A_func Pointer to method that should be wrapped.
4718  * @return Functor that executes _A_func on invokation.
4719  *
4720  * @ingroup mem_fun
4721  */
4722 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
4723 inline volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
4724 mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
4725 { return volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
4726
4727 /** Creates a functor of type sigc::volatile_mem_functor4 which wraps a volatile method.
4728  * @param _A_func Pointer to method that should be wrapped.
4729  * @return Functor that executes _A_func on invokation.
4730  *
4731  * @ingroup mem_fun
4732  */
4733 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
4734 inline volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
4735 mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
4736 { return volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
4737
4738 /** Creates a functor of type sigc::volatile_mem_functor5 which wraps a volatile method.
4739  * @param _A_func Pointer to method that should be wrapped.
4740  * @return Functor that executes _A_func on invokation.
4741  *
4742  * @ingroup mem_fun
4743  */
4744 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
4745 inline volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
4746 mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
4747 { return volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
4748
4749 /** Creates a functor of type sigc::volatile_mem_functor6 which wraps a volatile method.
4750  * @param _A_func Pointer to method that should be wrapped.
4751  * @return Functor that executes _A_func on invokation.
4752  *
4753  * @ingroup mem_fun
4754  */
4755 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
4756 inline volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
4757 mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
4758 { return volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
4759
4760 /** Creates a functor of type sigc::volatile_mem_functor7 which wraps a volatile method.
4761  * @param _A_func Pointer to method that should be wrapped.
4762  * @return Functor that executes _A_func on invokation.
4763  *
4764  * @ingroup mem_fun
4765  */
4766 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
4767 inline volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
4768 mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
4769 { return volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
4770
4771 /** Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile method.
4772  * @param _A_func Pointer to method that should be wrapped.
4773  * @return Functor that executes _A_func on invokation.
4774  *
4775  * @ingroup mem_fun
4776  */
4777 template <class T_return, class T_obj>
4778 inline const_volatile_mem_functor0<T_return, T_obj>
4779 mem_fun0(T_return (T_obj::*_A_func)() const volatile)
4780 { return const_volatile_mem_functor0<T_return, T_obj>(_A_func); }
4781
4782 /** Creates a functor of type sigc::const_volatile_mem_functor1 which wraps a const volatile method.
4783  * @param _A_func Pointer to method that should be wrapped.
4784  * @return Functor that executes _A_func on invokation.
4785  *
4786  * @ingroup mem_fun
4787  */
4788 template <class T_arg1, class T_return, class T_obj>
4789 inline const_volatile_mem_functor1<T_return, T_obj, T_arg1>
4790 mem_fun1(T_return (T_obj::*_A_func)(T_arg1) const volatile)
4791 { return const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
4792
4793 /** Creates a functor of type sigc::const_volatile_mem_functor2 which wraps a const volatile method.
4794  * @param _A_func Pointer to method that should be wrapped.
4795  * @return Functor that executes _A_func on invokation.
4796  *
4797  * @ingroup mem_fun
4798  */
4799 template <class T_arg1, class T_arg2, class T_return, class T_obj>
4800 inline const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
4801 mem_fun2(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const volatile)
4802 { return const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
4803
4804 /** Creates a functor of type sigc::const_volatile_mem_functor3 which wraps a const volatile method.
4805  * @param _A_func Pointer to method that should be wrapped.
4806  * @return Functor that executes _A_func on invokation.
4807  *
4808  * @ingroup mem_fun
4809  */
4810 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
4811 inline const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
4812 mem_fun3(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
4813 { return const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
4814
4815 /** Creates a functor of type sigc::const_volatile_mem_functor4 which wraps a const volatile method.
4816  * @param _A_func Pointer to method that should be wrapped.
4817  * @return Functor that executes _A_func on invokation.
4818  *
4819  * @ingroup mem_fun
4820  */
4821 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
4822 inline const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
4823 mem_fun4(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
4824 { return const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
4825
4826 /** Creates a functor of type sigc::const_volatile_mem_functor5 which wraps a const volatile method.
4827  * @param _A_func Pointer to method that should be wrapped.
4828  * @return Functor that executes _A_func on invokation.
4829  *
4830  * @ingroup mem_fun
4831  */
4832 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
4833 inline const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
4834 mem_fun5(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
4835 { return const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
4836
4837 /** Creates a functor of type sigc::const_volatile_mem_functor6 which wraps a const volatile method.
4838  * @param _A_func Pointer to method that should be wrapped.
4839  * @return Functor that executes _A_func on invokation.
4840  *
4841  * @ingroup mem_fun
4842  */
4843 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
4844 inline const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
4845 mem_fun6(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
4846 { return const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
4847
4848 /** Creates a functor of type sigc::const_volatile_mem_functor7 which wraps a const volatile method.
4849  * @param _A_func Pointer to method that should be wrapped.
4850  * @return Functor that executes _A_func on invokation.
4851  *
4852  * @ingroup mem_fun
4853  */
4854 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
4855 inline const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
4856 mem_fun7(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
4857 { return const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
4858
4859 #ifndef SIGCXX_DISABLE_DEPRECATED
4860 /** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
4861  *
4862  * @deprecated Please use the version that takes the object by reference instead.
4863  *
4864  * @param _A_obj Pointer to object instance the functor should operate on.
4865  * @param _A_func Pointer to method that should be wrapped.
4866  * @return Functor that executes @e _A_func on invokation.
4867  *
4868  * @ingroup mem_fun
4869  */
4870 template <class T_return, class T_obj, class T_obj2>
4871 inline bound_mem_functor0<T_return, T_obj>
4872 mem_fun0(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() )
4873 { return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
4874 #endif //SIGCXX_DISABLE_DEPRECATED
4875
4876 /** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
4877  * @param _A_obj Reference to object instance the functor should operate on.
4878  * @param _A_func Pointer to method that should be wrapped.
4879  * @return Functor that executes @e _A_func on invokation.
4880  *
4881  * @ingroup mem_fun
4882  */
4883 template <class T_return, class T_obj, class T_obj2>
4884 inline bound_mem_functor0<T_return, T_obj>
4885 mem_fun0(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() )
4886 { return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
4887
4888 #ifndef SIGCXX_DISABLE_DEPRECATED
4889 /** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
4890  *
4891  * @deprecated Please use the version that takes the object by reference instead.
4892  *
4893  * @param _A_obj Pointer to object instance the functor should operate on.
4894  * @param _A_func Pointer to method that should be wrapped.
4895  * @return Functor that executes @e _A_func on invokation.
4896  *
4897  * @ingroup mem_fun
4898  */
4899 template <class T_arg1, class T_return, class T_obj, class T_obj2>
4900 inline bound_mem_functor1<T_return, T_obj, T_arg1>
4901 mem_fun1(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
4902 { return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
4903 #endif //SIGCXX_DISABLE_DEPRECATED
4904
4905 /** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
4906  * @param _A_obj Reference to object instance the functor should operate on.
4907  * @param _A_func Pointer to method that should be wrapped.
4908  * @return Functor that executes @e _A_func on invokation.
4909  *
4910  * @ingroup mem_fun
4911  */
4912 template <class T_arg1, class T_return, class T_obj, class T_obj2>
4913 inline bound_mem_functor1<T_return, T_obj, T_arg1>
4914 mem_fun1(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
4915 { return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
4916
4917 #ifndef SIGCXX_DISABLE_DEPRECATED
4918 /** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
4919  *
4920  * @deprecated Please use the version that takes the object by reference instead.
4921  *
4922  * @param _A_obj Pointer to object instance the functor should operate on.
4923  * @param _A_func Pointer to method that should be wrapped.
4924  * @return Functor that executes @e _A_func on invokation.
4925  *
4926  * @ingroup mem_fun
4927  */
4928 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
4929 inline bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
4930 mem_fun2(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) )
4931 { return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
4932 #endif //SIGCXX_DISABLE_DEPRECATED
4933
4934 /** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
4935  * @param _A_obj Reference to object instance the functor should operate on.
4936  * @param _A_func Pointer to method that should be wrapped.
4937  * @return Functor that executes @e _A_func on invokation.
4938  *
4939  * @ingroup mem_fun
4940  */
4941 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
4942 inline bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
4943 mem_fun2(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) )
4944 { return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
4945
4946 #ifndef SIGCXX_DISABLE_DEPRECATED
4947 /** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
4948  *
4949  * @deprecated Please use the version that takes the object by reference instead.
4950  *
4951  * @param _A_obj Pointer to object instance the functor should operate on.
4952  * @param _A_func Pointer to method that should be wrapped.
4953  * @return Functor that executes @e _A_func on invokation.
4954  *
4955  * @ingroup mem_fun
4956  */
4957 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
4958 inline bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
4959 mem_fun3(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) )
4960 { return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
4961 #endif //SIGCXX_DISABLE_DEPRECATED
4962
4963 /** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
4964  * @param _A_obj Reference to object instance the functor should operate on.
4965  * @param _A_func Pointer to method that should be wrapped.
4966  * @return Functor that executes @e _A_func on invokation.
4967  *
4968  * @ingroup mem_fun
4969  */
4970 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
4971 inline bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
4972 mem_fun3(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) )
4973 { return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
4974
4975 #ifndef SIGCXX_DISABLE_DEPRECATED
4976 /** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
4977  *
4978  * @deprecated Please use the version that takes the object by reference instead.
4979  *
4980  * @param _A_obj Pointer to object instance the functor should operate on.
4981  * @param _A_func Pointer to method that should be wrapped.
4982  * @return Functor that executes @e _A_func on invokation.
4983  *
4984  * @ingroup mem_fun
4985  */
4986 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
4987 inline bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
4988 mem_fun4(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
4989 { return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
4990 #endif //SIGCXX_DISABLE_DEPRECATED
4991
4992 /** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
4993  * @param _A_obj Reference to object instance the functor should operate on.
4994  * @param _A_func Pointer to method that should be wrapped.
4995  * @return Functor that executes @e _A_func on invokation.
4996  *
4997  * @ingroup mem_fun
4998  */
4999 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
5000 inline bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5001 mem_fun4(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
5002 { return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
5003
5004 #ifndef SIGCXX_DISABLE_DEPRECATED
5005 /** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
5006  *
5007  * @deprecated Please use the version that takes the object by reference instead.
5008  *
5009  * @param _A_obj Pointer to object instance the functor should operate on.
5010  * @param _A_func Pointer to method that should be wrapped.
5011  * @return Functor that executes @e _A_func on invokation.
5012  *
5013  * @ingroup mem_fun
5014  */
5015 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
5016 inline bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5017 mem_fun5(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
5018 { return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
5019 #endif //SIGCXX_DISABLE_DEPRECATED
5020
5021 /** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
5022  * @param _A_obj Reference to object instance the functor should operate on.
5023  * @param _A_func Pointer to method that should be wrapped.
5024  * @return Functor that executes @e _A_func on invokation.
5025  *
5026  * @ingroup mem_fun
5027  */
5028 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
5029 inline bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5030 mem_fun5(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
5031 { return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
5032
5033 #ifndef SIGCXX_DISABLE_DEPRECATED
5034 /** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
5035  *
5036  * @deprecated Please use the version that takes the object by reference instead.
5037  *
5038  * @param _A_obj Pointer to object instance the functor should operate on.
5039  * @param _A_func Pointer to method that should be wrapped.
5040  * @return Functor that executes @e _A_func on invokation.
5041  *
5042  * @ingroup mem_fun
5043  */
5044 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
5045 inline bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5046 mem_fun6(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
5047 { return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
5048 #endif //SIGCXX_DISABLE_DEPRECATED
5049
5050 /** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
5051  * @param _A_obj Reference to object instance the functor should operate on.
5052  * @param _A_func Pointer to method that should be wrapped.
5053  * @return Functor that executes @e _A_func on invokation.
5054  *
5055  * @ingroup mem_fun
5056  */
5057 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
5058 inline bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5059 mem_fun6(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
5060 { return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
5061
5062 #ifndef SIGCXX_DISABLE_DEPRECATED
5063 /** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
5064  *
5065  * @deprecated Please use the version that takes the object by reference instead.
5066  *
5067  * @param _A_obj Pointer to object instance the functor should operate on.
5068  * @param _A_func Pointer to method that should be wrapped.
5069  * @return Functor that executes @e _A_func on invokation.
5070  *
5071  * @ingroup mem_fun
5072  */
5073 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
5074 inline bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5075 mem_fun7(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
5076 { return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
5077 #endif //SIGCXX_DISABLE_DEPRECATED
5078
5079 /** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
5080  * @param _A_obj Reference to object instance the functor should operate on.
5081  * @param _A_func Pointer to method that should be wrapped.
5082  * @return Functor that executes @e _A_func on invokation.
5083  *
5084  * @ingroup mem_fun
5085  */
5086 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
5087 inline bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5088 mem_fun7(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
5089 { return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
5090
5091 #ifndef SIGCXX_DISABLE_DEPRECATED
5092 /** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
5093  *
5094  * @deprecated Please use the version that takes the object by reference instead.
5095  *
5096  * @param _A_obj Pointer to object instance the functor should operate on.
5097  * @param _A_func Pointer to method that should be wrapped.
5098  * @return Functor that executes @e _A_func on invokation.
5099  *
5100  * @ingroup mem_fun
5101  */
5102 template <class T_return, class T_obj, class T_obj2>
5103 inline bound_const_mem_functor0<T_return, T_obj>
5104 mem_fun0(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const)
5105 { return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
5106 #endif //SIGCXX_DISABLE_DEPRECATED
5107
5108 /** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
5109  * @param _A_obj Reference to object instance the functor should operate on.
5110  * @param _A_func Pointer to method that should be wrapped.
5111  * @return Functor that executes @e _A_func on invokation.
5112  *
5113  * @ingroup mem_fun
5114  */
5115 template <class T_return, class T_obj, class T_obj2>
5116 inline bound_const_mem_functor0<T_return, T_obj>
5117 mem_fun0(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const)
5118 { return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
5119
5120 #ifndef SIGCXX_DISABLE_DEPRECATED
5121 /** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
5122  *
5123  * @deprecated Please use the version that takes the object by reference instead.
5124  *
5125  * @param _A_obj Pointer to object instance the functor should operate on.
5126  * @param _A_func Pointer to method that should be wrapped.
5127  * @return Functor that executes @e _A_func on invokation.
5128  *
5129  * @ingroup mem_fun
5130  */
5131 template <class T_arg1, class T_return, class T_obj, class T_obj2>
5132 inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
5133 mem_fun1(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
5134 { return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
5135 #endif //SIGCXX_DISABLE_DEPRECATED
5136
5137 /** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
5138  * @param _A_obj Reference to object instance the functor should operate on.
5139  * @param _A_func Pointer to method that should be wrapped.
5140  * @return Functor that executes @e _A_func on invokation.
5141  *
5142  * @ingroup mem_fun
5143  */
5144 template <class T_arg1, class T_return, class T_obj, class T_obj2>
5145 inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
5146 mem_fun1(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
5147 { return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
5148
5149 #ifndef SIGCXX_DISABLE_DEPRECATED
5150 /** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
5151  *
5152  * @deprecated Please use the version that takes the object by reference instead.
5153  *
5154  * @param _A_obj Pointer to object instance the functor should operate on.
5155  * @param _A_func Pointer to method that should be wrapped.
5156  * @return Functor that executes @e _A_func on invokation.
5157  *
5158  * @ingroup mem_fun
5159  */
5160 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
5161 inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5162 mem_fun2(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
5163 { return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
5164 #endif //SIGCXX_DISABLE_DEPRECATED
5165
5166 /** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
5167  * @param _A_obj Reference to object instance the functor should operate on.
5168  * @param _A_func Pointer to method that should be wrapped.
5169  * @return Functor that executes @e _A_func on invokation.
5170  *
5171  * @ingroup mem_fun
5172  */
5173 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
5174 inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5175 mem_fun2(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
5176 { return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
5177
5178 #ifndef SIGCXX_DISABLE_DEPRECATED
5179 /** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
5180  *
5181  * @deprecated Please use the version that takes the object by reference instead.
5182  *
5183  * @param _A_obj Pointer to object instance the functor should operate on.
5184  * @param _A_func Pointer to method that should be wrapped.
5185  * @return Functor that executes @e _A_func on invokation.
5186  *
5187  * @ingroup mem_fun
5188  */
5189 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
5190 inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
5191 mem_fun3(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
5192 { return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
5193 #endif //SIGCXX_DISABLE_DEPRECATED
5194
5195 /** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
5196  * @param _A_obj Reference to object instance the functor should operate on.
5197  * @param _A_func Pointer to method that should be wrapped.
5198  * @return Functor that executes @e _A_func on invokation.
5199  *
5200  * @ingroup mem_fun
5201  */
5202 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
5203 inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
5204 mem_fun3(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
5205 { return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
5206
5207 #ifndef SIGCXX_DISABLE_DEPRECATED
5208 /** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
5209  *
5210  * @deprecated Please use the version that takes the object by reference instead.
5211  *
5212  * @param _A_obj Pointer to object instance the functor should operate on.
5213  * @param _A_func Pointer to method that should be wrapped.
5214  * @return Functor that executes @e _A_func on invokation.
5215  *
5216  * @ingroup mem_fun
5217  */
5218 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
5219 inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5220 mem_fun4(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
5221 { return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
5222 #endif //SIGCXX_DISABLE_DEPRECATED
5223
5224 /** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
5225  * @param _A_obj Reference to object instance the functor should operate on.
5226  * @param _A_func Pointer to method that should be wrapped.
5227  * @return Functor that executes @e _A_func on invokation.
5228  *
5229  * @ingroup mem_fun
5230  */
5231 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
5232 inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5233 mem_fun4(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
5234 { return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
5235
5236 #ifndef SIGCXX_DISABLE_DEPRECATED
5237 /** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
5238  *
5239  * @deprecated Please use the version that takes the object by reference instead.
5240  *
5241  * @param _A_obj Pointer to object instance the functor should operate on.
5242  * @param _A_func Pointer to method that should be wrapped.
5243  * @return Functor that executes @e _A_func on invokation.
5244  *
5245  * @ingroup mem_fun
5246  */
5247 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
5248 inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5249 mem_fun5(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
5250 { return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
5251 #endif //SIGCXX_DISABLE_DEPRECATED
5252
5253 /** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
5254  * @param _A_obj Reference to object instance the functor should operate on.
5255  * @param _A_func Pointer to method that should be wrapped.
5256  * @return Functor that executes @e _A_func on invokation.
5257  *
5258  * @ingroup mem_fun
5259  */
5260 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
5261 inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5262 mem_fun5(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
5263 { return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
5264
5265 #ifndef SIGCXX_DISABLE_DEPRECATED
5266 /** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
5267  *
5268  * @deprecated Please use the version that takes the object by reference instead.
5269  *
5270  * @param _A_obj Pointer to object instance the functor should operate on.
5271  * @param _A_func Pointer to method that should be wrapped.
5272  * @return Functor that executes @e _A_func on invokation.
5273  *
5274  * @ingroup mem_fun
5275  */
5276 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
5277 inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5278 mem_fun6(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
5279 { return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
5280 #endif //SIGCXX_DISABLE_DEPRECATED
5281
5282 /** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
5283  * @param _A_obj Reference to object instance the functor should operate on.
5284  * @param _A_func Pointer to method that should be wrapped.
5285  * @return Functor that executes @e _A_func on invokation.
5286  *
5287  * @ingroup mem_fun
5288  */
5289 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
5290 inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5291 mem_fun6(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
5292 { return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
5293
5294 #ifndef SIGCXX_DISABLE_DEPRECATED
5295 /** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
5296  *
5297  * @deprecated Please use the version that takes the object by reference instead.
5298  *
5299  * @param _A_obj Pointer to object instance the functor should operate on.
5300  * @param _A_func Pointer to method that should be wrapped.
5301  * @return Functor that executes @e _A_func on invokation.
5302  *
5303  * @ingroup mem_fun
5304  */
5305 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
5306 inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5307 mem_fun7(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
5308 { return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
5309 #endif //SIGCXX_DISABLE_DEPRECATED
5310
5311 /** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
5312  * @param _A_obj Reference to object instance the functor should operate on.
5313  * @param _A_func Pointer to method that should be wrapped.
5314  * @return Functor that executes @e _A_func on invokation.
5315  *
5316  * @ingroup mem_fun
5317  */
5318 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
5319 inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5320 mem_fun7(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
5321 { return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
5322
5323 #ifndef SIGCXX_DISABLE_DEPRECATED
5324 /** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
5325  *
5326  * @deprecated Please use the version that takes the object by reference instead.
5327  *
5328  * @param _A_obj Pointer to object instance the functor should operate on.
5329  * @param _A_func Pointer to method that should be wrapped.
5330  * @return Functor that executes @e _A_func on invokation.
5331  *
5332  * @ingroup mem_fun
5333  */
5334 template <class T_return, class T_obj, class T_obj2>
5335 inline bound_volatile_mem_functor0<T_return, T_obj>
5336 mem_fun0(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() volatile)
5337 { return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
5338 #endif //SIGCXX_DISABLE_DEPRECATED
5339
5340 /** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
5341  * @param _A_obj Reference to object instance the functor should operate on.
5342  * @param _A_func Pointer to method that should be wrapped.
5343  * @return Functor that executes @e _A_func on invokation.
5344  *
5345  * @ingroup mem_fun
5346  */
5347 template <class T_return, class T_obj, class T_obj2>
5348 inline bound_volatile_mem_functor0<T_return, T_obj>
5349 mem_fun0(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() volatile)
5350 { return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
5351
5352 #ifndef SIGCXX_DISABLE_DEPRECATED
5353 /** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
5354  *
5355  * @deprecated Please use the version that takes the object by reference instead.
5356  *
5357  * @param _A_obj Pointer to object instance the functor should operate on.
5358  * @param _A_func Pointer to method that should be wrapped.
5359  * @return Functor that executes @e _A_func on invokation.
5360  *
5361  * @ingroup mem_fun
5362  */
5363 template <class T_arg1, class T_return, class T_obj, class T_obj2>
5364 inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
5365 mem_fun1(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
5366 { return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
5367 #endif //SIGCXX_DISABLE_DEPRECATED
5368
5369 /** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
5370  * @param _A_obj Reference to object instance the functor should operate on.
5371  * @param _A_func Pointer to method that should be wrapped.
5372  * @return Functor that executes @e _A_func on invokation.
5373  *
5374  * @ingroup mem_fun
5375  */
5376 template <class T_arg1, class T_return, class T_obj, class T_obj2>
5377 inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
5378 mem_fun1(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
5379 { return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
5380
5381 #ifndef SIGCXX_DISABLE_DEPRECATED
5382 /** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
5383  *
5384  * @deprecated Please use the version that takes the object by reference instead.
5385  *
5386  * @param _A_obj Pointer to object instance the functor should operate on.
5387  * @param _A_func Pointer to method that should be wrapped.
5388  * @return Functor that executes @e _A_func on invokation.
5389  *
5390  * @ingroup mem_fun
5391  */
5392 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
5393 inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5394 mem_fun2(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
5395 { return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
5396 #endif //SIGCXX_DISABLE_DEPRECATED
5397
5398 /** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
5399  * @param _A_obj Reference to object instance the functor should operate on.
5400  * @param _A_func Pointer to method that should be wrapped.
5401  * @return Functor that executes @e _A_func on invokation.
5402  *
5403  * @ingroup mem_fun
5404  */
5405 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
5406 inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5407 mem_fun2(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
5408 { return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
5409
5410 #ifndef SIGCXX_DISABLE_DEPRECATED
5411 /** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
5412  *
5413  * @deprecated Please use the version that takes the object by reference instead.
5414  *
5415  * @param _A_obj Pointer to object instance the functor should operate on.
5416  * @param _A_func Pointer to method that should be wrapped.
5417  * @return Functor that executes @e _A_func on invokation.
5418  *
5419  * @ingroup mem_fun
5420  */
5421 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
5422 inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
5423 mem_fun3(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
5424 { return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
5425 #endif //SIGCXX_DISABLE_DEPRECATED
5426
5427 /** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
5428  * @param _A_obj Reference to object instance the functor should operate on.
5429  * @param _A_func Pointer to method that should be wrapped.
5430  * @return Functor that executes @e _A_func on invokation.
5431  *
5432  * @ingroup mem_fun
5433  */
5434 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
5435 inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
5436 mem_fun3(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
5437 { return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
5438
5439 #ifndef SIGCXX_DISABLE_DEPRECATED
5440 /** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
5441  *
5442  * @deprecated Please use the version that takes the object by reference instead.
5443  *
5444  * @param _A_obj Pointer to object instance the functor should operate on.
5445  * @param _A_func Pointer to method that should be wrapped.
5446  * @return Functor that executes @e _A_func on invokation.
5447  *
5448  * @ingroup mem_fun
5449  */
5450 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
5451 inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5452 mem_fun4(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
5453 { return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
5454 #endif //SIGCXX_DISABLE_DEPRECATED
5455
5456 /** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
5457  * @param _A_obj Reference to object instance the functor should operate on.
5458  * @param _A_func Pointer to method that should be wrapped.
5459  * @return Functor that executes @e _A_func on invokation.
5460  *
5461  * @ingroup mem_fun
5462  */
5463 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
5464 inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5465 mem_fun4(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
5466 { return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
5467
5468 #ifndef SIGCXX_DISABLE_DEPRECATED
5469 /** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
5470  *
5471  * @deprecated Please use the version that takes the object by reference instead.
5472  *
5473  * @param _A_obj Pointer to object instance the functor should operate on.
5474  * @param _A_func Pointer to method that should be wrapped.
5475  * @return Functor that executes @e _A_func on invokation.
5476  *
5477  * @ingroup mem_fun
5478  */
5479 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
5480 inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5481 mem_fun5(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
5482 { return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
5483 #endif //SIGCXX_DISABLE_DEPRECATED
5484
5485 /** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
5486  * @param _A_obj Reference to object instance the functor should operate on.
5487  * @param _A_func Pointer to method that should be wrapped.
5488  * @return Functor that executes @e _A_func on invokation.
5489  *
5490  * @ingroup mem_fun
5491  */
5492 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
5493 inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5494 mem_fun5(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
5495 { return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
5496
5497 #ifndef SIGCXX_DISABLE_DEPRECATED
5498 /** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
5499  *
5500  * @deprecated Please use the version that takes the object by reference instead.
5501  *
5502  * @param _A_obj Pointer to object instance the functor should operate on.
5503  * @param _A_func Pointer to method that should be wrapped.
5504  * @return Functor that executes @e _A_func on invokation.
5505  *
5506  * @ingroup mem_fun
5507  */
5508 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
5509 inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5510 mem_fun6(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
5511 { return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
5512 #endif //SIGCXX_DISABLE_DEPRECATED
5513
5514 /** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
5515  * @param _A_obj Reference to object instance the functor should operate on.
5516  * @param _A_func Pointer to method that should be wrapped.
5517  * @return Functor that executes @e _A_func on invokation.
5518  *
5519  * @ingroup mem_fun
5520  */
5521 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
5522 inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5523 mem_fun6(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
5524 { return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
5525
5526 #ifndef SIGCXX_DISABLE_DEPRECATED
5527 /** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
5528  *
5529  * @deprecated Please use the version that takes the object by reference instead.
5530  *
5531  * @param _A_obj Pointer to object instance the functor should operate on.
5532  * @param _A_func Pointer to method that should be wrapped.
5533  * @return Functor that executes @e _A_func on invokation.
5534  *
5535  * @ingroup mem_fun
5536  */
5537 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
5538 inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5539 mem_fun7(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
5540 { return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
5541 #endif //SIGCXX_DISABLE_DEPRECATED
5542
5543 /** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
5544  * @param _A_obj Reference to object instance the functor should operate on.
5545  * @param _A_func Pointer to method that should be wrapped.
5546  * @return Functor that executes @e _A_func on invokation.
5547  *
5548  * @ingroup mem_fun
5549  */
5550 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
5551 inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5552 mem_fun7(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
5553 { return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
5554
5555 #ifndef SIGCXX_DISABLE_DEPRECATED
5556 /** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
5557  *
5558  * @deprecated Please use the version that takes the object by reference instead.
5559  *
5560  * @param _A_obj Pointer to object instance the functor should operate on.
5561  * @param _A_func Pointer to method that should be wrapped.
5562  * @return Functor that executes @e _A_func on invokation.
5563  *
5564  * @ingroup mem_fun
5565  */
5566 template <class T_return, class T_obj, class T_obj2>
5567 inline bound_const_volatile_mem_functor0<T_return, T_obj>
5568 mem_fun0(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const volatile)
5569 { return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
5570 #endif //SIGCXX_DISABLE_DEPRECATED
5571
5572 /** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
5573  * @param _A_obj Reference to object instance the functor should operate on.
5574  * @param _A_func Pointer to method that should be wrapped.
5575  * @return Functor that executes @e _A_func on invokation.
5576  *
5577  * @ingroup mem_fun
5578  */
5579 template <class T_return, class T_obj, class T_obj2>
5580 inline bound_const_volatile_mem_functor0<T_return, T_obj>
5581 mem_fun0(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const volatile)
5582 { return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
5583
5584 #ifndef SIGCXX_DISABLE_DEPRECATED
5585 /** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
5586  *
5587  * @deprecated Please use the version that takes the object by reference instead.
5588  *
5589  * @param _A_obj Pointer to object instance the functor should operate on.
5590  * @param _A_func Pointer to method that should be wrapped.
5591  * @return Functor that executes @e _A_func on invokation.
5592  *
5593  * @ingroup mem_fun
5594  */
5595 template <class T_arg1, class T_return, class T_obj, class T_obj2>
5596 inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
5597 mem_fun1(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
5598 { return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
5599 #endif //SIGCXX_DISABLE_DEPRECATED
5600
5601 /** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
5602  * @param _A_obj Reference to object instance the functor should operate on.
5603  * @param _A_func Pointer to method that should be wrapped.
5604  * @return Functor that executes @e _A_func on invokation.
5605  *
5606  * @ingroup mem_fun
5607  */
5608 template <class T_arg1, class T_return, class T_obj, class T_obj2>
5609 inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
5610 mem_fun1(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
5611 { return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
5612
5613 #ifndef SIGCXX_DISABLE_DEPRECATED
5614 /** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
5615  *
5616  * @deprecated Please use the version that takes the object by reference instead.
5617  *
5618  * @param _A_obj Pointer to object instance the functor should operate on.
5619  * @param _A_func Pointer to method that should be wrapped.
5620  * @return Functor that executes @e _A_func on invokation.
5621  *
5622  * @ingroup mem_fun
5623  */
5624 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
5625 inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5626 mem_fun2(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
5627 { return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
5628 #endif //SIGCXX_DISABLE_DEPRECATED
5629
5630 /** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
5631  * @param _A_obj Reference to object instance the functor should operate on.
5632  * @param _A_func Pointer to method that should be wrapped.
5633  * @return Functor that executes @e _A_func on invokation.
5634  *
5635  * @ingroup mem_fun
5636  */
5637 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
5638 inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5639 mem_fun2(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
5640 { return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
5641
5642 #ifndef SIGCXX_DISABLE_DEPRECATED
5643 /** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
5644  *
5645  * @deprecated Please use the version that takes the object by reference instead.
5646  *
5647  * @param _A_obj Pointer to object instance the functor should operate on.
5648  * @param _A_func Pointer to method that should be wrapped.
5649  * @return Functor that executes @e _A_func on invokation.
5650  *
5651  * @ingroup mem_fun
5652  */
5653 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
5654 inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
5655 mem_fun3(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
5656 { return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
5657 #endif //SIGCXX_DISABLE_DEPRECATED
5658
5659 /** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
5660  * @param _A_obj Reference to object instance the functor should operate on.
5661  * @param _A_func Pointer to method that should be wrapped.
5662  * @return Functor that executes @e _A_func on invokation.
5663  *
5664  * @ingroup mem_fun
5665  */
5666 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
5667 inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
5668 mem_fun3(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
5669 { return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
5670
5671 #ifndef SIGCXX_DISABLE_DEPRECATED
5672 /** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
5673  *
5674  * @deprecated Please use the version that takes the object by reference instead.
5675  *
5676  * @param _A_obj Pointer to object instance the functor should operate on.
5677  * @param _A_func Pointer to method that should be wrapped.
5678  * @return Functor that executes @e _A_func on invokation.
5679  *
5680  * @ingroup mem_fun
5681  */
5682 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
5683 inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5684 mem_fun4(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
5685 { return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
5686 #endif //SIGCXX_DISABLE_DEPRECATED
5687
5688 /** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
5689  * @param _A_obj Reference to object instance the functor should operate on.
5690  * @param _A_func Pointer to method that should be wrapped.
5691  * @return Functor that executes @e _A_func on invokation.
5692  *
5693  * @ingroup mem_fun
5694  */
5695 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
5696 inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5697 mem_fun4(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
5698 { return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
5699
5700 #ifndef SIGCXX_DISABLE_DEPRECATED
5701 /** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
5702  *
5703  * @deprecated Please use the version that takes the object by reference instead.
5704  *
5705  * @param _A_obj Pointer to object instance the functor should operate on.
5706  * @param _A_func Pointer to method that should be wrapped.
5707  * @return Functor that executes @e _A_func on invokation.
5708  *
5709  * @ingroup mem_fun
5710  */
5711 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
5712 inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5713 mem_fun5(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
5714 { return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
5715 #endif //SIGCXX_DISABLE_DEPRECATED
5716
5717 /** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
5718  * @param _A_obj Reference to object instance the functor should operate on.
5719  * @param _A_func Pointer to method that should be wrapped.
5720  * @return Functor that executes @e _A_func on invokation.
5721  *
5722  * @ingroup mem_fun
5723  */
5724 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
5725 inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5726 mem_fun5(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
5727 { return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
5728
5729 #ifndef SIGCXX_DISABLE_DEPRECATED
5730 /** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
5731  *
5732  * @deprecated Please use the version that takes the object by reference instead.
5733  *
5734  * @param _A_obj Pointer to object instance the functor should operate on.
5735  * @param _A_func Pointer to method that should be wrapped.
5736  * @return Functor that executes @e _A_func on invokation.
5737  *
5738  * @ingroup mem_fun
5739  */
5740 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
5741 inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5742 mem_fun6(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
5743 { return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
5744 #endif //SIGCXX_DISABLE_DEPRECATED
5745
5746 /** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
5747  * @param _A_obj Reference to object instance the functor should operate on.
5748  * @param _A_func Pointer to method that should be wrapped.
5749  * @return Functor that executes @e _A_func on invokation.
5750  *
5751  * @ingroup mem_fun
5752  */
5753 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
5754 inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5755 mem_fun6(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
5756 { return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
5757
5758 #ifndef SIGCXX_DISABLE_DEPRECATED
5759 /** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
5760  *
5761  * @deprecated Please use the version that takes the object by reference instead.
5762  *
5763  * @param _A_obj Pointer to object instance the functor should operate on.
5764  * @param _A_func Pointer to method that should be wrapped.
5765  * @return Functor that executes @e _A_func on invokation.
5766  *
5767  * @ingroup mem_fun
5768  */
5769 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
5770 inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5771 mem_fun7(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
5772 { return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
5773 #endif //SIGCXX_DISABLE_DEPRECATED
5774
5775 /** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
5776  * @param _A_obj Reference to object instance the functor should operate on.
5777  * @param _A_func Pointer to method that should be wrapped.
5778  * @return Functor that executes @e _A_func on invokation.
5779  *
5780  * @ingroup mem_fun
5781  */
5782 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
5783 inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5784 mem_fun7(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
5785 { return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
5786
5787
5788 // unnumbered
5789 /** Creates a functor of type sigc::mem_functor0 which wraps a  method.
5790  * @param _A_func Pointer to method that should be wrapped.
5791  * @return Functor that executes _A_func on invokation.
5792  *
5793  * @ingroup mem_fun
5794  */
5795 template <class T_return, class T_obj>
5796 inline mem_functor0<T_return, T_obj>
5797 mem_fun(T_return (T_obj::*_A_func)() )
5798 { return mem_functor0<T_return, T_obj>(_A_func); }
5799
5800 /** Creates a functor of type sigc::mem_functor1 which wraps a  method.
5801  * @param _A_func Pointer to method that should be wrapped.
5802  * @return Functor that executes _A_func on invokation.
5803  *
5804  * @ingroup mem_fun
5805  */
5806 template <class T_arg1, class T_return, class T_obj>
5807 inline mem_functor1<T_return, T_obj, T_arg1>
5808 mem_fun(T_return (T_obj::*_A_func)(T_arg1) )
5809 { return mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
5810
5811 /** Creates a functor of type sigc::mem_functor2 which wraps a  method.
5812  * @param _A_func Pointer to method that should be wrapped.
5813  * @return Functor that executes _A_func on invokation.
5814  *
5815  * @ingroup mem_fun
5816  */
5817 template <class T_arg1, class T_arg2, class T_return, class T_obj>
5818 inline mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5819 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) )
5820 { return mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
5821
5822 /** Creates a functor of type sigc::mem_functor3 which wraps a  method.
5823  * @param _A_func Pointer to method that should be wrapped.
5824  * @return Functor that executes _A_func on invokation.
5825  *
5826  * @ingroup mem_fun
5827  */
5828 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
5829 inline mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
5830 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) )
5831 { return mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
5832
5833 /** Creates a functor of type sigc::mem_functor4 which wraps a  method.
5834  * @param _A_func Pointer to method that should be wrapped.
5835  * @return Functor that executes _A_func on invokation.
5836  *
5837  * @ingroup mem_fun
5838  */
5839 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
5840 inline mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5841 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
5842 { return mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
5843
5844 /** Creates a functor of type sigc::mem_functor5 which wraps a  method.
5845  * @param _A_func Pointer to method that should be wrapped.
5846  * @return Functor that executes _A_func on invokation.
5847  *
5848  * @ingroup mem_fun
5849  */
5850 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
5851 inline mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5852 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
5853 { return mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
5854
5855 /** Creates a functor of type sigc::mem_functor6 which wraps a  method.
5856  * @param _A_func Pointer to method that should be wrapped.
5857  * @return Functor that executes _A_func on invokation.
5858  *
5859  * @ingroup mem_fun
5860  */
5861 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
5862 inline mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5863 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
5864 { return mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
5865
5866 /** Creates a functor of type sigc::mem_functor7 which wraps a  method.
5867  * @param _A_func Pointer to method that should be wrapped.
5868  * @return Functor that executes _A_func on invokation.
5869  *
5870  * @ingroup mem_fun
5871  */
5872 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
5873 inline mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5874 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
5875 { return mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
5876
5877 /** Creates a functor of type sigc::const_mem_functor0 which wraps a const method.
5878  * @param _A_func Pointer to method that should be wrapped.
5879  * @return Functor that executes _A_func on invokation.
5880  *
5881  * @ingroup mem_fun
5882  */
5883 template <class T_return, class T_obj>
5884 inline const_mem_functor0<T_return, T_obj>
5885 mem_fun(T_return (T_obj::*_A_func)() const)
5886 { return const_mem_functor0<T_return, T_obj>(_A_func); }
5887
5888 /** Creates a functor of type sigc::const_mem_functor1 which wraps a const method.
5889  * @param _A_func Pointer to method that should be wrapped.
5890  * @return Functor that executes _A_func on invokation.
5891  *
5892  * @ingroup mem_fun
5893  */
5894 template <class T_arg1, class T_return, class T_obj>
5895 inline const_mem_functor1<T_return, T_obj, T_arg1>
5896 mem_fun(T_return (T_obj::*_A_func)(T_arg1) const)
5897 { return const_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
5898
5899 /** Creates a functor of type sigc::const_mem_functor2 which wraps a const method.
5900  * @param _A_func Pointer to method that should be wrapped.
5901  * @return Functor that executes _A_func on invokation.
5902  *
5903  * @ingroup mem_fun
5904  */
5905 template <class T_arg1, class T_arg2, class T_return, class T_obj>
5906 inline const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5907 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const)
5908 { return const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
5909
5910 /** Creates a functor of type sigc::const_mem_functor3 which wraps a const method.
5911  * @param _A_func Pointer to method that should be wrapped.
5912  * @return Functor that executes _A_func on invokation.
5913  *
5914  * @ingroup mem_fun
5915  */
5916 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
5917 inline const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
5918 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const)
5919 { return const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
5920
5921 /** Creates a functor of type sigc::const_mem_functor4 which wraps a const method.
5922  * @param _A_func Pointer to method that should be wrapped.
5923  * @return Functor that executes _A_func on invokation.
5924  *
5925  * @ingroup mem_fun
5926  */
5927 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
5928 inline const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
5929 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
5930 { return const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
5931
5932 /** Creates a functor of type sigc::const_mem_functor5 which wraps a const method.
5933  * @param _A_func Pointer to method that should be wrapped.
5934  * @return Functor that executes _A_func on invokation.
5935  *
5936  * @ingroup mem_fun
5937  */
5938 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
5939 inline const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
5940 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
5941 { return const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
5942
5943 /** Creates a functor of type sigc::const_mem_functor6 which wraps a const method.
5944  * @param _A_func Pointer to method that should be wrapped.
5945  * @return Functor that executes _A_func on invokation.
5946  *
5947  * @ingroup mem_fun
5948  */
5949 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
5950 inline const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
5951 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
5952 { return const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
5953
5954 /** Creates a functor of type sigc::const_mem_functor7 which wraps a const method.
5955  * @param _A_func Pointer to method that should be wrapped.
5956  * @return Functor that executes _A_func on invokation.
5957  *
5958  * @ingroup mem_fun
5959  */
5960 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
5961 inline const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
5962 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
5963 { return const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
5964
5965 /** Creates a functor of type sigc::volatile_mem_functor0 which wraps a volatile method.
5966  * @param _A_func Pointer to method that should be wrapped.
5967  * @return Functor that executes _A_func on invokation.
5968  *
5969  * @ingroup mem_fun
5970  */
5971 template <class T_return, class T_obj>
5972 inline volatile_mem_functor0<T_return, T_obj>
5973 mem_fun(T_return (T_obj::*_A_func)() volatile)
5974 { return volatile_mem_functor0<T_return, T_obj>(_A_func); }
5975
5976 /** Creates a functor of type sigc::volatile_mem_functor1 which wraps a volatile method.
5977  * @param _A_func Pointer to method that should be wrapped.
5978  * @return Functor that executes _A_func on invokation.
5979  *
5980  * @ingroup mem_fun
5981  */
5982 template <class T_arg1, class T_return, class T_obj>
5983 inline volatile_mem_functor1<T_return, T_obj, T_arg1>
5984 mem_fun(T_return (T_obj::*_A_func)(T_arg1) volatile)
5985 { return volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
5986
5987 /** Creates a functor of type sigc::volatile_mem_functor2 which wraps a volatile method.
5988  * @param _A_func Pointer to method that should be wrapped.
5989  * @return Functor that executes _A_func on invokation.
5990  *
5991  * @ingroup mem_fun
5992  */
5993 template <class T_arg1, class T_arg2, class T_return, class T_obj>
5994 inline volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
5995 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) volatile)
5996 { return volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
5997
5998 /** Creates a functor of type sigc::volatile_mem_functor3 which wraps a volatile method.
5999  * @param _A_func Pointer to method that should be wrapped.
6000  * @return Functor that executes _A_func on invokation.
6001  *
6002  * @ingroup mem_fun
6003  */
6004 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
6005 inline volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6006 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
6007 { return volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
6008
6009 /** Creates a functor of type sigc::volatile_mem_functor4 which wraps a volatile method.
6010  * @param _A_func Pointer to method that should be wrapped.
6011  * @return Functor that executes _A_func on invokation.
6012  *
6013  * @ingroup mem_fun
6014  */
6015 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
6016 inline volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6017 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
6018 { return volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
6019
6020 /** Creates a functor of type sigc::volatile_mem_functor5 which wraps a volatile method.
6021  * @param _A_func Pointer to method that should be wrapped.
6022  * @return Functor that executes _A_func on invokation.
6023  *
6024  * @ingroup mem_fun
6025  */
6026 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
6027 inline volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6028 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
6029 { return volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
6030
6031 /** Creates a functor of type sigc::volatile_mem_functor6 which wraps a volatile method.
6032  * @param _A_func Pointer to method that should be wrapped.
6033  * @return Functor that executes _A_func on invokation.
6034  *
6035  * @ingroup mem_fun
6036  */
6037 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
6038 inline volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
6039 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
6040 { return volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
6041
6042 /** Creates a functor of type sigc::volatile_mem_functor7 which wraps a volatile method.
6043  * @param _A_func Pointer to method that should be wrapped.
6044  * @return Functor that executes _A_func on invokation.
6045  *
6046  * @ingroup mem_fun
6047  */
6048 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
6049 inline volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
6050 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
6051 { return volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
6052
6053 /** Creates a functor of type sigc::const_volatile_mem_functor0 which wraps a const volatile method.
6054  * @param _A_func Pointer to method that should be wrapped.
6055  * @return Functor that executes _A_func on invokation.
6056  *
6057  * @ingroup mem_fun
6058  */
6059 template <class T_return, class T_obj>
6060 inline const_volatile_mem_functor0<T_return, T_obj>
6061 mem_fun(T_return (T_obj::*_A_func)() const volatile)
6062 { return const_volatile_mem_functor0<T_return, T_obj>(_A_func); }
6063
6064 /** Creates a functor of type sigc::const_volatile_mem_functor1 which wraps a const volatile method.
6065  * @param _A_func Pointer to method that should be wrapped.
6066  * @return Functor that executes _A_func on invokation.
6067  *
6068  * @ingroup mem_fun
6069  */
6070 template <class T_arg1, class T_return, class T_obj>
6071 inline const_volatile_mem_functor1<T_return, T_obj, T_arg1>
6072 mem_fun(T_return (T_obj::*_A_func)(T_arg1) const volatile)
6073 { return const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_func); }
6074
6075 /** Creates a functor of type sigc::const_volatile_mem_functor2 which wraps a const volatile method.
6076  * @param _A_func Pointer to method that should be wrapped.
6077  * @return Functor that executes _A_func on invokation.
6078  *
6079  * @ingroup mem_fun
6080  */
6081 template <class T_arg1, class T_arg2, class T_return, class T_obj>
6082 inline const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6083 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2) const volatile)
6084 { return const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_func); }
6085
6086 /** Creates a functor of type sigc::const_volatile_mem_functor3 which wraps a const volatile method.
6087  * @param _A_func Pointer to method that should be wrapped.
6088  * @return Functor that executes _A_func on invokation.
6089  *
6090  * @ingroup mem_fun
6091  */
6092 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj>
6093 inline const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6094 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
6095 { return const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_func); }
6096
6097 /** Creates a functor of type sigc::const_volatile_mem_functor4 which wraps a const volatile method.
6098  * @param _A_func Pointer to method that should be wrapped.
6099  * @return Functor that executes _A_func on invokation.
6100  *
6101  * @ingroup mem_fun
6102  */
6103 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj>
6104 inline const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6105 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
6106 { return const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_func); }
6107
6108 /** Creates a functor of type sigc::const_volatile_mem_functor5 which wraps a const volatile method.
6109  * @param _A_func Pointer to method that should be wrapped.
6110  * @return Functor that executes _A_func on invokation.
6111  *
6112  * @ingroup mem_fun
6113  */
6114 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj>
6115 inline const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6116 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
6117 { return const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_func); }
6118
6119 /** Creates a functor of type sigc::const_volatile_mem_functor6 which wraps a const volatile method.
6120  * @param _A_func Pointer to method that should be wrapped.
6121  * @return Functor that executes _A_func on invokation.
6122  *
6123  * @ingroup mem_fun
6124  */
6125 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj>
6126 inline const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
6127 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
6128 { return const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_func); }
6129
6130 /** Creates a functor of type sigc::const_volatile_mem_functor7 which wraps a const volatile method.
6131  * @param _A_func Pointer to method that should be wrapped.
6132  * @return Functor that executes _A_func on invokation.
6133  *
6134  * @ingroup mem_fun
6135  */
6136 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj>
6137 inline const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
6138 mem_fun(T_return (T_obj::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
6139 { return const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_func); }
6140
6141 #ifndef SIGCXX_DISABLE_DEPRECATED
6142 /** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
6143  *
6144  * @deprecated Please use the version that takes the object by reference instead.
6145  *
6146  * @param _A_obj Pointer to object instance the functor should operate on.
6147  * @param _A_func Pointer to method that should be wrapped.
6148  * @return Functor that executes @e _A_func on invokation.
6149  *
6150  * @ingroup mem_fun
6151  */
6152 template <class T_return, class T_obj, class T_obj2>
6153 inline bound_mem_functor0<T_return, T_obj>
6154 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() )
6155 { return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
6156 #endif //SIGCXX_DISABLE_DEPRECATED
6157
6158 /** Creates a functor of type sigc::bound_mem_functor0 which encapsulates a method and an object instance.
6159  * @param _A_obj Reference to object instance the functor should operate on.
6160  * @param _A_func Pointer to method that should be wrapped.
6161  * @return Functor that executes @e _A_func on invokation.
6162  *
6163  * @ingroup mem_fun
6164  */
6165 template <class T_return, class T_obj, class T_obj2>
6166 inline bound_mem_functor0<T_return, T_obj>
6167 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() )
6168 { return bound_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
6169
6170 #ifndef SIGCXX_DISABLE_DEPRECATED
6171 /** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
6172  *
6173  * @deprecated Please use the version that takes the object by reference instead.
6174  *
6175  * @param _A_obj Pointer to object instance the functor should operate on.
6176  * @param _A_func Pointer to method that should be wrapped.
6177  * @return Functor that executes @e _A_func on invokation.
6178  *
6179  * @ingroup mem_fun
6180  */
6181 template <class T_arg1, class T_return, class T_obj, class T_obj2>
6182 inline bound_mem_functor1<T_return, T_obj, T_arg1>
6183 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
6184 { return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
6185 #endif //SIGCXX_DISABLE_DEPRECATED
6186
6187 /** Creates a functor of type sigc::bound_mem_functor1 which encapsulates a method and an object instance.
6188  * @param _A_obj Reference to object instance the functor should operate on.
6189  * @param _A_func Pointer to method that should be wrapped.
6190  * @return Functor that executes @e _A_func on invokation.
6191  *
6192  * @ingroup mem_fun
6193  */
6194 template <class T_arg1, class T_return, class T_obj, class T_obj2>
6195 inline bound_mem_functor1<T_return, T_obj, T_arg1>
6196 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) )
6197 { return bound_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
6198
6199 #ifndef SIGCXX_DISABLE_DEPRECATED
6200 /** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
6201  *
6202  * @deprecated Please use the version that takes the object by reference instead.
6203  *
6204  * @param _A_obj Pointer to object instance the functor should operate on.
6205  * @param _A_func Pointer to method that should be wrapped.
6206  * @return Functor that executes @e _A_func on invokation.
6207  *
6208  * @ingroup mem_fun
6209  */
6210 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
6211 inline bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6212 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) )
6213 { return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
6214 #endif //SIGCXX_DISABLE_DEPRECATED
6215
6216 /** Creates a functor of type sigc::bound_mem_functor2 which encapsulates a method and an object instance.
6217  * @param _A_obj Reference to object instance the functor should operate on.
6218  * @param _A_func Pointer to method that should be wrapped.
6219  * @return Functor that executes @e _A_func on invokation.
6220  *
6221  * @ingroup mem_fun
6222  */
6223 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
6224 inline bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6225 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) )
6226 { return bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
6227
6228 #ifndef SIGCXX_DISABLE_DEPRECATED
6229 /** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
6230  *
6231  * @deprecated Please use the version that takes the object by reference instead.
6232  *
6233  * @param _A_obj Pointer to object instance the functor should operate on.
6234  * @param _A_func Pointer to method that should be wrapped.
6235  * @return Functor that executes @e _A_func on invokation.
6236  *
6237  * @ingroup mem_fun
6238  */
6239 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
6240 inline bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6241 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) )
6242 { return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
6243 #endif //SIGCXX_DISABLE_DEPRECATED
6244
6245 /** Creates a functor of type sigc::bound_mem_functor3 which encapsulates a method and an object instance.
6246  * @param _A_obj Reference to object instance the functor should operate on.
6247  * @param _A_func Pointer to method that should be wrapped.
6248  * @return Functor that executes @e _A_func on invokation.
6249  *
6250  * @ingroup mem_fun
6251  */
6252 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
6253 inline bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6254 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) )
6255 { return bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
6256
6257 #ifndef SIGCXX_DISABLE_DEPRECATED
6258 /** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
6259  *
6260  * @deprecated Please use the version that takes the object by reference instead.
6261  *
6262  * @param _A_obj Pointer to object instance the functor should operate on.
6263  * @param _A_func Pointer to method that should be wrapped.
6264  * @return Functor that executes @e _A_func on invokation.
6265  *
6266  * @ingroup mem_fun
6267  */
6268 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
6269 inline bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6270 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
6271 { return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
6272 #endif //SIGCXX_DISABLE_DEPRECATED
6273
6274 /** Creates a functor of type sigc::bound_mem_functor4 which encapsulates a method and an object instance.
6275  * @param _A_obj Reference to object instance the functor should operate on.
6276  * @param _A_func Pointer to method that should be wrapped.
6277  * @return Functor that executes @e _A_func on invokation.
6278  *
6279  * @ingroup mem_fun
6280  */
6281 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
6282 inline bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6283 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) )
6284 { return bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
6285
6286 #ifndef SIGCXX_DISABLE_DEPRECATED
6287 /** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
6288  *
6289  * @deprecated Please use the version that takes the object by reference instead.
6290  *
6291  * @param _A_obj Pointer to object instance the functor should operate on.
6292  * @param _A_func Pointer to method that should be wrapped.
6293  * @return Functor that executes @e _A_func on invokation.
6294  *
6295  * @ingroup mem_fun
6296  */
6297 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
6298 inline bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6299 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
6300 { return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
6301 #endif //SIGCXX_DISABLE_DEPRECATED
6302
6303 /** Creates a functor of type sigc::bound_mem_functor5 which encapsulates a method and an object instance.
6304  * @param _A_obj Reference to object instance the functor should operate on.
6305  * @param _A_func Pointer to method that should be wrapped.
6306  * @return Functor that executes @e _A_func on invokation.
6307  *
6308  * @ingroup mem_fun
6309  */
6310 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
6311 inline bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6312 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) )
6313 { return bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
6314
6315 #ifndef SIGCXX_DISABLE_DEPRECATED
6316 /** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
6317  *
6318  * @deprecated Please use the version that takes the object by reference instead.
6319  *
6320  * @param _A_obj Pointer to object instance the functor should operate on.
6321  * @param _A_func Pointer to method that should be wrapped.
6322  * @return Functor that executes @e _A_func on invokation.
6323  *
6324  * @ingroup mem_fun
6325  */
6326 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
6327 inline bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
6328 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
6329 { return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
6330 #endif //SIGCXX_DISABLE_DEPRECATED
6331
6332 /** Creates a functor of type sigc::bound_mem_functor6 which encapsulates a method and an object instance.
6333  * @param _A_obj Reference to object instance the functor should operate on.
6334  * @param _A_func Pointer to method that should be wrapped.
6335  * @return Functor that executes @e _A_func on invokation.
6336  *
6337  * @ingroup mem_fun
6338  */
6339 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
6340 inline bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
6341 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) )
6342 { return bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
6343
6344 #ifndef SIGCXX_DISABLE_DEPRECATED
6345 /** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
6346  *
6347  * @deprecated Please use the version that takes the object by reference instead.
6348  *
6349  * @param _A_obj Pointer to object instance the functor should operate on.
6350  * @param _A_func Pointer to method that should be wrapped.
6351  * @return Functor that executes @e _A_func on invokation.
6352  *
6353  * @ingroup mem_fun
6354  */
6355 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
6356 inline bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
6357 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
6358 { return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
6359 #endif //SIGCXX_DISABLE_DEPRECATED
6360
6361 /** Creates a functor of type sigc::bound_mem_functor7 which encapsulates a method and an object instance.
6362  * @param _A_obj Reference to object instance the functor should operate on.
6363  * @param _A_func Pointer to method that should be wrapped.
6364  * @return Functor that executes @e _A_func on invokation.
6365  *
6366  * @ingroup mem_fun
6367  */
6368 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
6369 inline bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
6370 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) )
6371 { return bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
6372
6373 #ifndef SIGCXX_DISABLE_DEPRECATED
6374 /** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
6375  *
6376  * @deprecated Please use the version that takes the object by reference instead.
6377  *
6378  * @param _A_obj Pointer to object instance the functor should operate on.
6379  * @param _A_func Pointer to method that should be wrapped.
6380  * @return Functor that executes @e _A_func on invokation.
6381  *
6382  * @ingroup mem_fun
6383  */
6384 template <class T_return, class T_obj, class T_obj2>
6385 inline bound_const_mem_functor0<T_return, T_obj>
6386 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const)
6387 { return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
6388 #endif //SIGCXX_DISABLE_DEPRECATED
6389
6390 /** Creates a functor of type sigc::bound_const_mem_functor0 which encapsulates a method and an object instance.
6391  * @param _A_obj Reference to object instance the functor should operate on.
6392  * @param _A_func Pointer to method that should be wrapped.
6393  * @return Functor that executes @e _A_func on invokation.
6394  *
6395  * @ingroup mem_fun
6396  */
6397 template <class T_return, class T_obj, class T_obj2>
6398 inline bound_const_mem_functor0<T_return, T_obj>
6399 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const)
6400 { return bound_const_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
6401
6402 #ifndef SIGCXX_DISABLE_DEPRECATED
6403 /** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
6404  *
6405  * @deprecated Please use the version that takes the object by reference instead.
6406  *
6407  * @param _A_obj Pointer to object instance the functor should operate on.
6408  * @param _A_func Pointer to method that should be wrapped.
6409  * @return Functor that executes @e _A_func on invokation.
6410  *
6411  * @ingroup mem_fun
6412  */
6413 template <class T_arg1, class T_return, class T_obj, class T_obj2>
6414 inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
6415 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
6416 { return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
6417 #endif //SIGCXX_DISABLE_DEPRECATED
6418
6419 /** Creates a functor of type sigc::bound_const_mem_functor1 which encapsulates a method and an object instance.
6420  * @param _A_obj Reference to object instance the functor should operate on.
6421  * @param _A_func Pointer to method that should be wrapped.
6422  * @return Functor that executes @e _A_func on invokation.
6423  *
6424  * @ingroup mem_fun
6425  */
6426 template <class T_arg1, class T_return, class T_obj, class T_obj2>
6427 inline bound_const_mem_functor1<T_return, T_obj, T_arg1>
6428 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const)
6429 { return bound_const_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
6430
6431 #ifndef SIGCXX_DISABLE_DEPRECATED
6432 /** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
6433  *
6434  * @deprecated Please use the version that takes the object by reference instead.
6435  *
6436  * @param _A_obj Pointer to object instance the functor should operate on.
6437  * @param _A_func Pointer to method that should be wrapped.
6438  * @return Functor that executes @e _A_func on invokation.
6439  *
6440  * @ingroup mem_fun
6441  */
6442 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
6443 inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6444 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
6445 { return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
6446 #endif //SIGCXX_DISABLE_DEPRECATED
6447
6448 /** Creates a functor of type sigc::bound_const_mem_functor2 which encapsulates a method and an object instance.
6449  * @param _A_obj Reference to object instance the functor should operate on.
6450  * @param _A_func Pointer to method that should be wrapped.
6451  * @return Functor that executes @e _A_func on invokation.
6452  *
6453  * @ingroup mem_fun
6454  */
6455 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
6456 inline bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6457 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const)
6458 { return bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
6459
6460 #ifndef SIGCXX_DISABLE_DEPRECATED
6461 /** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
6462  *
6463  * @deprecated Please use the version that takes the object by reference instead.
6464  *
6465  * @param _A_obj Pointer to object instance the functor should operate on.
6466  * @param _A_func Pointer to method that should be wrapped.
6467  * @return Functor that executes @e _A_func on invokation.
6468  *
6469  * @ingroup mem_fun
6470  */
6471 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
6472 inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6473 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
6474 { return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
6475 #endif //SIGCXX_DISABLE_DEPRECATED
6476
6477 /** Creates a functor of type sigc::bound_const_mem_functor3 which encapsulates a method and an object instance.
6478  * @param _A_obj Reference to object instance the functor should operate on.
6479  * @param _A_func Pointer to method that should be wrapped.
6480  * @return Functor that executes @e _A_func on invokation.
6481  *
6482  * @ingroup mem_fun
6483  */
6484 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
6485 inline bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6486 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const)
6487 { return bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
6488
6489 #ifndef SIGCXX_DISABLE_DEPRECATED
6490 /** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
6491  *
6492  * @deprecated Please use the version that takes the object by reference instead.
6493  *
6494  * @param _A_obj Pointer to object instance the functor should operate on.
6495  * @param _A_func Pointer to method that should be wrapped.
6496  * @return Functor that executes @e _A_func on invokation.
6497  *
6498  * @ingroup mem_fun
6499  */
6500 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
6501 inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6502 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
6503 { return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
6504 #endif //SIGCXX_DISABLE_DEPRECATED
6505
6506 /** Creates a functor of type sigc::bound_const_mem_functor4 which encapsulates a method and an object instance.
6507  * @param _A_obj Reference to object instance the functor should operate on.
6508  * @param _A_func Pointer to method that should be wrapped.
6509  * @return Functor that executes @e _A_func on invokation.
6510  *
6511  * @ingroup mem_fun
6512  */
6513 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
6514 inline bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6515 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
6516 { return bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
6517
6518 #ifndef SIGCXX_DISABLE_DEPRECATED
6519 /** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
6520  *
6521  * @deprecated Please use the version that takes the object by reference instead.
6522  *
6523  * @param _A_obj Pointer to object instance the functor should operate on.
6524  * @param _A_func Pointer to method that should be wrapped.
6525  * @return Functor that executes @e _A_func on invokation.
6526  *
6527  * @ingroup mem_fun
6528  */
6529 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
6530 inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6531 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
6532 { return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
6533 #endif //SIGCXX_DISABLE_DEPRECATED
6534
6535 /** Creates a functor of type sigc::bound_const_mem_functor5 which encapsulates a method and an object instance.
6536  * @param _A_obj Reference to object instance the functor should operate on.
6537  * @param _A_func Pointer to method that should be wrapped.
6538  * @return Functor that executes @e _A_func on invokation.
6539  *
6540  * @ingroup mem_fun
6541  */
6542 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
6543 inline bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6544 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
6545 { return bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
6546
6547 #ifndef SIGCXX_DISABLE_DEPRECATED
6548 /** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
6549  *
6550  * @deprecated Please use the version that takes the object by reference instead.
6551  *
6552  * @param _A_obj Pointer to object instance the functor should operate on.
6553  * @param _A_func Pointer to method that should be wrapped.
6554  * @return Functor that executes @e _A_func on invokation.
6555  *
6556  * @ingroup mem_fun
6557  */
6558 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
6559 inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
6560 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
6561 { return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
6562 #endif //SIGCXX_DISABLE_DEPRECATED
6563
6564 /** Creates a functor of type sigc::bound_const_mem_functor6 which encapsulates a method and an object instance.
6565  * @param _A_obj Reference to object instance the functor should operate on.
6566  * @param _A_func Pointer to method that should be wrapped.
6567  * @return Functor that executes @e _A_func on invokation.
6568  *
6569  * @ingroup mem_fun
6570  */
6571 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
6572 inline bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
6573 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
6574 { return bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
6575
6576 #ifndef SIGCXX_DISABLE_DEPRECATED
6577 /** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
6578  *
6579  * @deprecated Please use the version that takes the object by reference instead.
6580  *
6581  * @param _A_obj Pointer to object instance the functor should operate on.
6582  * @param _A_func Pointer to method that should be wrapped.
6583  * @return Functor that executes @e _A_func on invokation.
6584  *
6585  * @ingroup mem_fun
6586  */
6587 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
6588 inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
6589 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
6590 { return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
6591 #endif //SIGCXX_DISABLE_DEPRECATED
6592
6593 /** Creates a functor of type sigc::bound_const_mem_functor7 which encapsulates a method and an object instance.
6594  * @param _A_obj Reference to object instance the functor should operate on.
6595  * @param _A_func Pointer to method that should be wrapped.
6596  * @return Functor that executes @e _A_func on invokation.
6597  *
6598  * @ingroup mem_fun
6599  */
6600 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
6601 inline bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
6602 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
6603 { return bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
6604
6605 #ifndef SIGCXX_DISABLE_DEPRECATED
6606 /** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
6607  *
6608  * @deprecated Please use the version that takes the object by reference instead.
6609  *
6610  * @param _A_obj Pointer to object instance the functor should operate on.
6611  * @param _A_func Pointer to method that should be wrapped.
6612  * @return Functor that executes @e _A_func on invokation.
6613  *
6614  * @ingroup mem_fun
6615  */
6616 template <class T_return, class T_obj, class T_obj2>
6617 inline bound_volatile_mem_functor0<T_return, T_obj>
6618 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() volatile)
6619 { return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
6620 #endif //SIGCXX_DISABLE_DEPRECATED
6621
6622 /** Creates a functor of type sigc::bound_volatile_mem_functor0 which encapsulates a method and an object instance.
6623  * @param _A_obj Reference to object instance the functor should operate on.
6624  * @param _A_func Pointer to method that should be wrapped.
6625  * @return Functor that executes @e _A_func on invokation.
6626  *
6627  * @ingroup mem_fun
6628  */
6629 template <class T_return, class T_obj, class T_obj2>
6630 inline bound_volatile_mem_functor0<T_return, T_obj>
6631 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() volatile)
6632 { return bound_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
6633
6634 #ifndef SIGCXX_DISABLE_DEPRECATED
6635 /** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
6636  *
6637  * @deprecated Please use the version that takes the object by reference instead.
6638  *
6639  * @param _A_obj Pointer to object instance the functor should operate on.
6640  * @param _A_func Pointer to method that should be wrapped.
6641  * @return Functor that executes @e _A_func on invokation.
6642  *
6643  * @ingroup mem_fun
6644  */
6645 template <class T_arg1, class T_return, class T_obj, class T_obj2>
6646 inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
6647 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
6648 { return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
6649 #endif //SIGCXX_DISABLE_DEPRECATED
6650
6651 /** Creates a functor of type sigc::bound_volatile_mem_functor1 which encapsulates a method and an object instance.
6652  * @param _A_obj Reference to object instance the functor should operate on.
6653  * @param _A_func Pointer to method that should be wrapped.
6654  * @return Functor that executes @e _A_func on invokation.
6655  *
6656  * @ingroup mem_fun
6657  */
6658 template <class T_arg1, class T_return, class T_obj, class T_obj2>
6659 inline bound_volatile_mem_functor1<T_return, T_obj, T_arg1>
6660 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) volatile)
6661 { return bound_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
6662
6663 #ifndef SIGCXX_DISABLE_DEPRECATED
6664 /** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
6665  *
6666  * @deprecated Please use the version that takes the object by reference instead.
6667  *
6668  * @param _A_obj Pointer to object instance the functor should operate on.
6669  * @param _A_func Pointer to method that should be wrapped.
6670  * @return Functor that executes @e _A_func on invokation.
6671  *
6672  * @ingroup mem_fun
6673  */
6674 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
6675 inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6676 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
6677 { return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
6678 #endif //SIGCXX_DISABLE_DEPRECATED
6679
6680 /** Creates a functor of type sigc::bound_volatile_mem_functor2 which encapsulates a method and an object instance.
6681  * @param _A_obj Reference to object instance the functor should operate on.
6682  * @param _A_func Pointer to method that should be wrapped.
6683  * @return Functor that executes @e _A_func on invokation.
6684  *
6685  * @ingroup mem_fun
6686  */
6687 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
6688 inline bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6689 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) volatile)
6690 { return bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
6691
6692 #ifndef SIGCXX_DISABLE_DEPRECATED
6693 /** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
6694  *
6695  * @deprecated Please use the version that takes the object by reference instead.
6696  *
6697  * @param _A_obj Pointer to object instance the functor should operate on.
6698  * @param _A_func Pointer to method that should be wrapped.
6699  * @return Functor that executes @e _A_func on invokation.
6700  *
6701  * @ingroup mem_fun
6702  */
6703 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
6704 inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6705 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
6706 { return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
6707 #endif //SIGCXX_DISABLE_DEPRECATED
6708
6709 /** Creates a functor of type sigc::bound_volatile_mem_functor3 which encapsulates a method and an object instance.
6710  * @param _A_obj Reference to object instance the functor should operate on.
6711  * @param _A_func Pointer to method that should be wrapped.
6712  * @return Functor that executes @e _A_func on invokation.
6713  *
6714  * @ingroup mem_fun
6715  */
6716 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
6717 inline bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6718 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) volatile)
6719 { return bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
6720
6721 #ifndef SIGCXX_DISABLE_DEPRECATED
6722 /** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
6723  *
6724  * @deprecated Please use the version that takes the object by reference instead.
6725  *
6726  * @param _A_obj Pointer to object instance the functor should operate on.
6727  * @param _A_func Pointer to method that should be wrapped.
6728  * @return Functor that executes @e _A_func on invokation.
6729  *
6730  * @ingroup mem_fun
6731  */
6732 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
6733 inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6734 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
6735 { return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
6736 #endif //SIGCXX_DISABLE_DEPRECATED
6737
6738 /** Creates a functor of type sigc::bound_volatile_mem_functor4 which encapsulates a method and an object instance.
6739  * @param _A_obj Reference to object instance the functor should operate on.
6740  * @param _A_func Pointer to method that should be wrapped.
6741  * @return Functor that executes @e _A_func on invokation.
6742  *
6743  * @ingroup mem_fun
6744  */
6745 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
6746 inline bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6747 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
6748 { return bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
6749
6750 #ifndef SIGCXX_DISABLE_DEPRECATED
6751 /** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
6752  *
6753  * @deprecated Please use the version that takes the object by reference instead.
6754  *
6755  * @param _A_obj Pointer to object instance the functor should operate on.
6756  * @param _A_func Pointer to method that should be wrapped.
6757  * @return Functor that executes @e _A_func on invokation.
6758  *
6759  * @ingroup mem_fun
6760  */
6761 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
6762 inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6763 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
6764 { return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
6765 #endif //SIGCXX_DISABLE_DEPRECATED
6766
6767 /** Creates a functor of type sigc::bound_volatile_mem_functor5 which encapsulates a method and an object instance.
6768  * @param _A_obj Reference to object instance the functor should operate on.
6769  * @param _A_func Pointer to method that should be wrapped.
6770  * @return Functor that executes @e _A_func on invokation.
6771  *
6772  * @ingroup mem_fun
6773  */
6774 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
6775 inline bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6776 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
6777 { return bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
6778
6779 #ifndef SIGCXX_DISABLE_DEPRECATED
6780 /** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
6781  *
6782  * @deprecated Please use the version that takes the object by reference instead.
6783  *
6784  * @param _A_obj Pointer to object instance the functor should operate on.
6785  * @param _A_func Pointer to method that should be wrapped.
6786  * @return Functor that executes @e _A_func on invokation.
6787  *
6788  * @ingroup mem_fun
6789  */
6790 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
6791 inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
6792 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
6793 { return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
6794 #endif //SIGCXX_DISABLE_DEPRECATED
6795
6796 /** Creates a functor of type sigc::bound_volatile_mem_functor6 which encapsulates a method and an object instance.
6797  * @param _A_obj Reference to object instance the functor should operate on.
6798  * @param _A_func Pointer to method that should be wrapped.
6799  * @return Functor that executes @e _A_func on invokation.
6800  *
6801  * @ingroup mem_fun
6802  */
6803 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
6804 inline bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
6805 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
6806 { return bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
6807
6808 #ifndef SIGCXX_DISABLE_DEPRECATED
6809 /** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
6810  *
6811  * @deprecated Please use the version that takes the object by reference instead.
6812  *
6813  * @param _A_obj Pointer to object instance the functor should operate on.
6814  * @param _A_func Pointer to method that should be wrapped.
6815  * @return Functor that executes @e _A_func on invokation.
6816  *
6817  * @ingroup mem_fun
6818  */
6819 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
6820 inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
6821 mem_fun(/**/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
6822 { return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
6823 #endif //SIGCXX_DISABLE_DEPRECATED
6824
6825 /** Creates a functor of type sigc::bound_volatile_mem_functor7 which encapsulates a method and an object instance.
6826  * @param _A_obj Reference to object instance the functor should operate on.
6827  * @param _A_func Pointer to method that should be wrapped.
6828  * @return Functor that executes @e _A_func on invokation.
6829  *
6830  * @ingroup mem_fun
6831  */
6832 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
6833 inline bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
6834 mem_fun(/**/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
6835 { return bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
6836
6837 #ifndef SIGCXX_DISABLE_DEPRECATED
6838 /** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
6839  *
6840  * @deprecated Please use the version that takes the object by reference instead.
6841  *
6842  * @param _A_obj Pointer to object instance the functor should operate on.
6843  * @param _A_func Pointer to method that should be wrapped.
6844  * @return Functor that executes @e _A_func on invokation.
6845  *
6846  * @ingroup mem_fun
6847  */
6848 template <class T_return, class T_obj, class T_obj2>
6849 inline bound_const_volatile_mem_functor0<T_return, T_obj>
6850 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)() const volatile)
6851 { return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
6852 #endif //SIGCXX_DISABLE_DEPRECATED
6853
6854 /** Creates a functor of type sigc::bound_const_volatile_mem_functor0 which encapsulates a method and an object instance.
6855  * @param _A_obj Reference to object instance the functor should operate on.
6856  * @param _A_func Pointer to method that should be wrapped.
6857  * @return Functor that executes @e _A_func on invokation.
6858  *
6859  * @ingroup mem_fun
6860  */
6861 template <class T_return, class T_obj, class T_obj2>
6862 inline bound_const_volatile_mem_functor0<T_return, T_obj>
6863 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)() const volatile)
6864 { return bound_const_volatile_mem_functor0<T_return, T_obj>(_A_obj, _A_func); }
6865
6866 #ifndef SIGCXX_DISABLE_DEPRECATED
6867 /** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
6868  *
6869  * @deprecated Please use the version that takes the object by reference instead.
6870  *
6871  * @param _A_obj Pointer to object instance the functor should operate on.
6872  * @param _A_func Pointer to method that should be wrapped.
6873  * @return Functor that executes @e _A_func on invokation.
6874  *
6875  * @ingroup mem_fun
6876  */
6877 template <class T_arg1, class T_return, class T_obj, class T_obj2>
6878 inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
6879 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
6880 { return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
6881 #endif //SIGCXX_DISABLE_DEPRECATED
6882
6883 /** Creates a functor of type sigc::bound_const_volatile_mem_functor1 which encapsulates a method and an object instance.
6884  * @param _A_obj Reference to object instance the functor should operate on.
6885  * @param _A_func Pointer to method that should be wrapped.
6886  * @return Functor that executes @e _A_func on invokation.
6887  *
6888  * @ingroup mem_fun
6889  */
6890 template <class T_arg1, class T_return, class T_obj, class T_obj2>
6891 inline bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>
6892 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1) const volatile)
6893 { return bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>(_A_obj, _A_func); }
6894
6895 #ifndef SIGCXX_DISABLE_DEPRECATED
6896 /** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
6897  *
6898  * @deprecated Please use the version that takes the object by reference instead.
6899  *
6900  * @param _A_obj Pointer to object instance the functor should operate on.
6901  * @param _A_func Pointer to method that should be wrapped.
6902  * @return Functor that executes @e _A_func on invokation.
6903  *
6904  * @ingroup mem_fun
6905  */
6906 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
6907 inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6908 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
6909 { return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
6910 #endif //SIGCXX_DISABLE_DEPRECATED
6911
6912 /** Creates a functor of type sigc::bound_const_volatile_mem_functor2 which encapsulates a method and an object instance.
6913  * @param _A_obj Reference to object instance the functor should operate on.
6914  * @param _A_func Pointer to method that should be wrapped.
6915  * @return Functor that executes @e _A_func on invokation.
6916  *
6917  * @ingroup mem_fun
6918  */
6919 template <class T_arg1, class T_arg2, class T_return, class T_obj, class T_obj2>
6920 inline bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>
6921 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2) const volatile)
6922 { return bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>(_A_obj, _A_func); }
6923
6924 #ifndef SIGCXX_DISABLE_DEPRECATED
6925 /** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
6926  *
6927  * @deprecated Please use the version that takes the object by reference instead.
6928  *
6929  * @param _A_obj Pointer to object instance the functor should operate on.
6930  * @param _A_func Pointer to method that should be wrapped.
6931  * @return Functor that executes @e _A_func on invokation.
6932  *
6933  * @ingroup mem_fun
6934  */
6935 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
6936 inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6937 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
6938 { return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
6939 #endif //SIGCXX_DISABLE_DEPRECATED
6940
6941 /** Creates a functor of type sigc::bound_const_volatile_mem_functor3 which encapsulates a method and an object instance.
6942  * @param _A_obj Reference to object instance the functor should operate on.
6943  * @param _A_func Pointer to method that should be wrapped.
6944  * @return Functor that executes @e _A_func on invokation.
6945  *
6946  * @ingroup mem_fun
6947  */
6948 template <class T_arg1, class T_arg2, class T_arg3, class T_return, class T_obj, class T_obj2>
6949 inline bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>
6950 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3) const volatile)
6951 { return bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>(_A_obj, _A_func); }
6952
6953 #ifndef SIGCXX_DISABLE_DEPRECATED
6954 /** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
6955  *
6956  * @deprecated Please use the version that takes the object by reference instead.
6957  *
6958  * @param _A_obj Pointer to object instance the functor should operate on.
6959  * @param _A_func Pointer to method that should be wrapped.
6960  * @return Functor that executes @e _A_func on invokation.
6961  *
6962  * @ingroup mem_fun
6963  */
6964 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
6965 inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6966 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
6967 { return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
6968 #endif //SIGCXX_DISABLE_DEPRECATED
6969
6970 /** Creates a functor of type sigc::bound_const_volatile_mem_functor4 which encapsulates a method and an object instance.
6971  * @param _A_obj Reference to object instance the functor should operate on.
6972  * @param _A_func Pointer to method that should be wrapped.
6973  * @return Functor that executes @e _A_func on invokation.
6974  *
6975  * @ingroup mem_fun
6976  */
6977 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_return, class T_obj, class T_obj2>
6978 inline bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>
6979 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
6980 { return bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(_A_obj, _A_func); }
6981
6982 #ifndef SIGCXX_DISABLE_DEPRECATED
6983 /** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
6984  *
6985  * @deprecated Please use the version that takes the object by reference instead.
6986  *
6987  * @param _A_obj Pointer to object instance the functor should operate on.
6988  * @param _A_func Pointer to method that should be wrapped.
6989  * @return Functor that executes @e _A_func on invokation.
6990  *
6991  * @ingroup mem_fun
6992  */
6993 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
6994 inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
6995 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
6996 { return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
6997 #endif //SIGCXX_DISABLE_DEPRECATED
6998
6999 /** Creates a functor of type sigc::bound_const_volatile_mem_functor5 which encapsulates a method and an object instance.
7000  * @param _A_obj Reference to object instance the functor should operate on.
7001  * @param _A_func Pointer to method that should be wrapped.
7002  * @return Functor that executes @e _A_func on invokation.
7003  *
7004  * @ingroup mem_fun
7005  */
7006 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_return, class T_obj, class T_obj2>
7007 inline bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
7008 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
7009 { return bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(_A_obj, _A_func); }
7010
7011 #ifndef SIGCXX_DISABLE_DEPRECATED
7012 /** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
7013  *
7014  * @deprecated Please use the version that takes the object by reference instead.
7015  *
7016  * @param _A_obj Pointer to object instance the functor should operate on.
7017  * @param _A_func Pointer to method that should be wrapped.
7018  * @return Functor that executes @e _A_func on invokation.
7019  *
7020  * @ingroup mem_fun
7021  */
7022 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
7023 inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
7024 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
7025 { return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
7026 #endif //SIGCXX_DISABLE_DEPRECATED
7027
7028 /** Creates a functor of type sigc::bound_const_volatile_mem_functor6 which encapsulates a method and an object instance.
7029  * @param _A_obj Reference to object instance the functor should operate on.
7030  * @param _A_func Pointer to method that should be wrapped.
7031  * @return Functor that executes @e _A_func on invokation.
7032  *
7033  * @ingroup mem_fun
7034  */
7035 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_return, class T_obj, class T_obj2>
7036 inline bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
7037 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
7038 { return bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(_A_obj, _A_func); }
7039
7040 #ifndef SIGCXX_DISABLE_DEPRECATED
7041 /** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
7042  *
7043  * @deprecated Please use the version that takes the object by reference instead.
7044  *
7045  * @param _A_obj Pointer to object instance the functor should operate on.
7046  * @param _A_func Pointer to method that should be wrapped.
7047  * @return Functor that executes @e _A_func on invokation.
7048  *
7049  * @ingroup mem_fun
7050  */
7051 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
7052 inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
7053 mem_fun(/*const*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
7054 { return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
7055 #endif //SIGCXX_DISABLE_DEPRECATED
7056
7057 /** Creates a functor of type sigc::bound_const_volatile_mem_functor7 which encapsulates a method and an object instance.
7058  * @param _A_obj Reference to object instance the functor should operate on.
7059  * @param _A_func Pointer to method that should be wrapped.
7060  * @return Functor that executes @e _A_func on invokation.
7061  *
7062  * @ingroup mem_fun
7063  */
7064 template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_return, class T_obj, class T_obj2>
7065 inline bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
7066 mem_fun(/*const*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
7067 { return bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(_A_obj, _A_func); }
7068
7069
7070 } /* namespace sigc */
7071 #endif /* _SIGC_FUNCTORS_MEM_FUN_H_ */