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