untracked/sigc++/adaptors/bind.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_ADAPTORS_BIND_H_
   4 #define _SIGC_ADAPTORS_BIND_H_
   5 #include <sigc++/adaptors/adaptor_trait.h>
   6 #include <sigc++/adaptors/bound_argument.h>
   7
   8 //TODO: See comment in functor_trait.h.
   9 #if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO)
  10   #define SIGC_NIL_HAS_BEEN_PUSHED 1
  11   #pragma push_macro("nil")
  12   #undef nil
  13 #endif
  14
  15 namespace sigc {
  16
  17 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  18
  19 namespace internal {
  20
  21 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
  22 struct count_void
  23   { static const int value=0; };
  24 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
  25 struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,void>
  26   { static const int value=1; };
  27 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
  28 struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,void,void>
  29   { static const int value=2; };
  30 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
  31 struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,void,void,void>
  32   { static const int value=3; };
  33 template <class T_arg1,class T_arg2,class T_arg3>
  34 struct count_void<T_arg1,T_arg2,T_arg3,void,void,void,void>
  35   { static const int value=4; };
  36 template <class T_arg1,class T_arg2>
  37 struct count_void<T_arg1,T_arg2,void,void,void,void,void>
  38   { static const int value=5; };
  39 template <class T_arg1>
  40 struct count_void<T_arg1,void,void,void,void,void,void>
  41   { static const int value=6; };
  42 template <>
  43 struct count_void<void,void,void,void,void,void,void>
  44   { static const int value=7; };
  45
  46 } /* namespace internal */
  47
  48 #endif /*DOXYGEN_SHOULD_SKIP_THIS*/
  49
  50
  51 /** @defgroup bind bind(), bind_return()
  52  * sigc::bind() alters an arbitrary functor by fixing arguments to certain values.
  53  * Up to 7 arguments can be bound at a time.
  54  * For single argument binding, overloads of sigc::bind() are provided that let you
  55  * specify the zero-based position of the argument to fix with the first template parameter.
  56  * (A value of @p -1 fixes the last argument so sigc::bind<-1>() gives the same result as sigc::bind().)
  57  * The types of the arguments can optionally be specified if not deduced.
  58  *
  59  * @par Examples:
  60  * @code
  61  * void foo(int, int, int);
  62  * // single argument binding ...
  63  * sigc::bind(&foo,1)(2,3);     //fixes the last (third) argument and calls foo(2,3,1)
  64  * sigc::bind<-1>(&foo,1)(2,3); //same as bind(&foo,1)(2,3) (calls foo(2,3,1))
  65  * sigc::bind<0>(&foo,1)(2,3);  //fixes the first argument and calls foo(1,2,3)
  66  * sigc::bind<1>(&foo,1)(2,3);  //fixes the second argument and calls foo(2,1,3)
  67  * sigc::bind<2>(&foo,1)(2,3);  //fixes the third argument and calls foo(2,3,1)
  68  * // multi argument binding ...
  69  * sigc::bind(&foo,1,2)(3);     //fixes the last two arguments and calls foo(3,1,2)
  70  * sigc::bind(&foo,1,2,3)();    //fixes all three arguments and calls foo(1,2,3)
  71  * @endcode
  72  *
  73  * The functor sigc::bind() returns can be passed into
  74  * sigc::signal::connect() directly.
  75  *
  76  * @par Example:
  77  * @code
  78  * sigc::signal<void> some_signal;
  79  * void foo(int);
  80  * some_signal.connect(sigc::bind(&foo,1));
  81  * @endcode
  82  *
  83  * sigc::bind_return() alters an arbitrary functor by
  84  * fixing its return value to a certain value.
  85  *
  86  * @par Example:
  87  * @code
  88  * void foo();
  89  * std::cout << sigc::bind_return(&foo, 5)(); // calls foo() and returns 5
  90  * @endcode
  91  *
  92  * You can bind references to functors by passing the objects through
  93  * the std::ref() or std::cref() functions.
  94  *
  95  * @par Example:
  96  * @code
  97  * int some_int;
  98  * sigc::signal<void> some_signal;
  99  * void foo(int&);
 100  * some_signal.connect(sigc::bind(&foo, std::ref(some_int)));
 101  * @endcode
 102  *
 103  * If you bind an object of a sigc::trackable derived type to a functor
 104  * by reference, a slot assigned to the bind adaptor is cleared automatically
 105  * when the object goes out of scope.
 106  *
 107  * @par Example:
 108  * @code
 109  * struct bar : public sigc::trackable {} some_bar;
 110  * sigc::signal<void> some_signal;
 111  * void foo(bar&);
 112  * some_signal.connect(sigc::bind(&foo, std::ref(some_bar)));
 113  *   // disconnected automatically if some_bar goes out of scope
 114  * @endcode
 115  *
 116  * @ingroup adaptors
 117  */
 118
 119 /** Adaptor that binds an argument to the wrapped functor.
 120  * Use the convenience function sigc::bind() to create an instance of sigc::bind_functor.
 121  *
 122  * The following template arguments are used:
 123  * - @e I_location Zero-based position of the argument to fix (@p -1 for the last argument).
 124  * - @e T_type1 Type of the 1st bound argument.
 125  * - @e T_type2 Type of the 2nd bound argument.
 126  * - @e T_type3 Type of the 3rd bound argument.
 127  * - @e T_type4 Type of the 4th bound argument.
 128  * - @e T_type5 Type of the 5th bound argument.
 129  * - @e T_type6 Type of the 6th bound argument.
 130  * - @e T_type7 Type of the 7th bound argument.
 131  * - @e T_functor Type of the functor to wrap.
 132  *
 133  * @ingroup bind
 134  */
 135 template <int I_location, class T_functor, class T_type1=nil, class T_type2=nil, class T_type3=nil, class T_type4=nil, class T_type5=nil, class T_type6=nil, class T_type7=nil>
 136 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 137 struct bind_functor;
 138 #else
 139 struct bind_functor {};
 140 #endif
 141
 142 /** Adaptor that binds an argument to the wrapped functor.
 143  * This template specialization fixes the 1st argument of the wrapped functor.
 144  *
 145  * @ingroup bind
 146  */
 147 template <class T_functor, class T_bound>
 148 struct bind_functor<0, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
 149 {
 150   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 151
 152 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 153   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
 154   struct deduce_result_type
 155     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
 156 #endif
 157   typedef typename adaptor_type::result_type  result_type;
 158
 159   /** Invokes the wrapped functor passing on the bound argument only.
 160    * @return The return value of the functor invocation.
 161    */
 162   result_type
 163   operator()()
 164   {
 165     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
 166     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
 167   }
 168
 169   /** Invokes the wrapped functor passing on the arguments.
 170    * bound_ is passed as the 1st argument.
 171    * @param _A_arg1 Argument to be passed on to the functor.
 172    * @return The return value of the functor invocation.
 173    */
 174   template <class T_arg1>
 175   typename deduce_result_type<T_arg1>::type
 176   operator()(T_arg1 _A_arg1)
 177     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>>
 178         (bound_.invoke(), _A_arg1);
 179     }
 180
 181   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 182   template <class T_arg1>
 183   typename deduce_result_type<T_arg1>::type
 184   sun_forte_workaround(T_arg1 _A_arg1)
 185     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>>
 186         (bound_.invoke(), _A_arg1);
 187     }
 188   #endif
 189
 190   /** Invokes the wrapped functor passing on the arguments.
 191    * bound_ is passed as the 1st argument.
 192    * @param _A_arg1 Argument to be passed on to the functor.
 193    * @param _A_arg2 Argument to be passed on to the functor.
 194    * @return The return value of the functor invocation.
 195    */
 196   template <class T_arg1, class T_arg2>
 197   typename deduce_result_type<T_arg1, T_arg2>::type
 198   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
 199     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
 200         (bound_.invoke(), _A_arg1, _A_arg2);
 201     }
 202
 203   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 204   template <class T_arg1, class T_arg2>
 205   typename deduce_result_type<T_arg1, T_arg2>::type
 206   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
 207     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>>
 208         (bound_.invoke(), _A_arg1, _A_arg2);
 209     }
 210   #endif
 211
 212   /** Invokes the wrapped functor passing on the arguments.
 213    * bound_ is passed as the 1st argument.
 214    * @param _A_arg1 Argument to be passed on to the functor.
 215    * @param _A_arg2 Argument to be passed on to the functor.
 216    * @param _A_arg3 Argument to be passed on to the functor.
 217    * @return The return value of the functor invocation.
 218    */
 219   template <class T_arg1, class T_arg2, class T_arg3>
 220   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 221   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 222     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
 223         (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3);
 224     }
 225
 226   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 227   template <class T_arg1, class T_arg2, class T_arg3>
 228   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 229   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 230     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
 231         (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3);
 232     }
 233   #endif
 234
 235   /** Invokes the wrapped functor passing on the arguments.
 236    * bound_ is passed as the 1st argument.
 237    * @param _A_arg1 Argument to be passed on to the functor.
 238    * @param _A_arg2 Argument to be passed on to the functor.
 239    * @param _A_arg3 Argument to be passed on to the functor.
 240    * @param _A_arg4 Argument to be passed on to the functor.
 241    * @return The return value of the functor invocation.
 242    */
 243   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 244   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 245   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 246     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
 247         (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4);
 248     }
 249
 250   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 251   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 252   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 253   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 254     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
 255         (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4);
 256     }
 257   #endif
 258
 259   /** Invokes the wrapped functor passing on the arguments.
 260    * bound_ is passed as the 1st argument.
 261    * @param _A_arg1 Argument to be passed on to the functor.
 262    * @param _A_arg2 Argument to be passed on to the functor.
 263    * @param _A_arg3 Argument to be passed on to the functor.
 264    * @param _A_arg4 Argument to be passed on to the functor.
 265    * @param _A_arg5 Argument to be passed on to the functor.
 266    * @return The return value of the functor invocation.
 267    */
 268   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 269   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 270   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 271     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 272         (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
 273     }
 274
 275   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 276   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 277   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 278   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 279     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 280         (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
 281     }
 282   #endif
 283
 284   /** Invokes the wrapped functor passing on the arguments.
 285    * bound_ is passed as the 1st argument.
 286    * @param _A_arg1 Argument to be passed on to the functor.
 287    * @param _A_arg2 Argument to be passed on to the functor.
 288    * @param _A_arg3 Argument to be passed on to the functor.
 289    * @param _A_arg4 Argument to be passed on to the functor.
 290    * @param _A_arg5 Argument to be passed on to the functor.
 291    * @param _A_arg6 Argument to be passed on to the functor.
 292    * @return The return value of the functor invocation.
 293    */
 294   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 295   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 296   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 297     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 298         (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
 299     }
 300
 301   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 302   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 303   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 304   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 305     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 306         (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
 307     }
 308   #endif
 309
 310   /** Constructs a bind_functor object that binds an argument to the passed functor.
 311    * @param _A_func Functor to invoke from operator()().
 312    * @param _A_bound Argument to bind to the functor.
 313    */
 314   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
 315     : adapts<T_functor>(_A_func), bound_(_A_bound)
 316     {}
 317
 318   /// The argument bound to the functor.
 319   bound_argument<T_bound> bound_;
 320 };
 321
 322 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 323 /** Adaptor that binds an argument to the wrapped functor.
 324  * This template specialization fixes the 2nd argument of the wrapped functor.
 325  *
 326  * @ingroup bind
 327  */
 328 template <class T_functor, class T_bound>
 329 struct bind_functor<1, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
 330 {
 331   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 332
 333   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
 334   struct deduce_result_type
 335     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
 336   typedef typename adaptor_type::result_type  result_type;
 337
 338   /** Invokes the wrapped functor passing on the bound argument only.
 339    * @return The return value of the functor invocation.
 340    */
 341   result_type
 342   operator()()
 343   {
 344     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
 345     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
 346   }
 347
 348   /** Invokes the wrapped functor passing on the arguments.
 349    * bound_ is passed as the 2nd argument.
 350    * @param _A_arg1 Argument to be passed on to the functor.
 351    * @return The return value of the functor invocation.
 352    */
 353   template <class T_arg1>
 354   typename deduce_result_type<T_arg1>::type
 355   operator()(T_arg1 _A_arg1)
 356     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 357         (_A_arg1, bound_.invoke());
 358     }
 359
 360   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 361   template <class T_arg1>
 362   typename deduce_result_type<T_arg1>::type
 363   sun_forte_workaround(T_arg1 _A_arg1)
 364     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 365         (_A_arg1, bound_.invoke());
 366     }
 367   #endif
 368
 369   /** Invokes the wrapped functor passing on the arguments.
 370    * bound_ is passed as the 2nd argument.
 371    * @param _A_arg1 Argument to be passed on to the functor.
 372    * @param _A_arg2 Argument to be passed on to the functor.
 373    * @return The return value of the functor invocation.
 374    */
 375   template <class T_arg1, class T_arg2>
 376   typename deduce_result_type<T_arg1, T_arg2>::type
 377   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
 378     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>>
 379         (_A_arg1, bound_.invoke(), _A_arg2);
 380     }
 381
 382   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 383   template <class T_arg1, class T_arg2>
 384   typename deduce_result_type<T_arg1, T_arg2>::type
 385   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
 386     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>>
 387         (_A_arg1, bound_.invoke(), _A_arg2);
 388     }
 389   #endif
 390
 391   /** Invokes the wrapped functor passing on the arguments.
 392    * bound_ is passed as the 2nd argument.
 393    * @param _A_arg1 Argument to be passed on to the functor.
 394    * @param _A_arg2 Argument to be passed on to the functor.
 395    * @param _A_arg3 Argument to be passed on to the functor.
 396    * @return The return value of the functor invocation.
 397    */
 398   template <class T_arg1, class T_arg2, class T_arg3>
 399   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 400   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 401     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
 402         (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3);
 403     }
 404
 405   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 406   template <class T_arg1, class T_arg2, class T_arg3>
 407   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 408   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 409     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>>
 410         (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3);
 411     }
 412   #endif
 413
 414   /** Invokes the wrapped functor passing on the arguments.
 415    * bound_ is passed as the 2nd argument.
 416    * @param _A_arg1 Argument to be passed on to the functor.
 417    * @param _A_arg2 Argument to be passed on to the functor.
 418    * @param _A_arg3 Argument to be passed on to the functor.
 419    * @param _A_arg4 Argument to be passed on to the functor.
 420    * @return The return value of the functor invocation.
 421    */
 422   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 423   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 424   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 425     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
 426         (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4);
 427     }
 428
 429   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 430   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 431   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 432   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 433     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
 434         (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4);
 435     }
 436   #endif
 437
 438   /** Invokes the wrapped functor passing on the arguments.
 439    * bound_ is passed as the 2nd argument.
 440    * @param _A_arg1 Argument to be passed on to the functor.
 441    * @param _A_arg2 Argument to be passed on to the functor.
 442    * @param _A_arg3 Argument to be passed on to the functor.
 443    * @param _A_arg4 Argument to be passed on to the functor.
 444    * @param _A_arg5 Argument to be passed on to the functor.
 445    * @return The return value of the functor invocation.
 446    */
 447   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 448   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 449   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 450     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 451         (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5);
 452     }
 453
 454   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 455   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 456   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 457   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 458     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 459         (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5);
 460     }
 461   #endif
 462
 463   /** Invokes the wrapped functor passing on the arguments.
 464    * bound_ is passed as the 2nd argument.
 465    * @param _A_arg1 Argument to be passed on to the functor.
 466    * @param _A_arg2 Argument to be passed on to the functor.
 467    * @param _A_arg3 Argument to be passed on to the functor.
 468    * @param _A_arg4 Argument to be passed on to the functor.
 469    * @param _A_arg5 Argument to be passed on to the functor.
 470    * @param _A_arg6 Argument to be passed on to the functor.
 471    * @return The return value of the functor invocation.
 472    */
 473   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 474   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 475   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 476     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 477         (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
 478     }
 479
 480   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 481   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 482   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 483   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 484     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 485         (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
 486     }
 487   #endif
 488
 489   /** Constructs a bind_functor object that binds an argument to the passed functor.
 490    * @param _A_func Functor to invoke from operator()().
 491    * @param _A_bound Argument to bind to the functor.
 492    */
 493   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
 494     : adapts<T_functor>(_A_func), bound_(_A_bound)
 495     {}
 496
 497   /// The argument bound to the functor.
 498   bound_argument<T_bound> bound_;
 499 };
 500
 501 /** Adaptor that binds an argument to the wrapped functor.
 502  * This template specialization fixes the 3rd argument of the wrapped functor.
 503  *
 504  * @ingroup bind
 505  */
 506 template <class T_functor, class T_bound>
 507 struct bind_functor<2, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
 508 {
 509   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 510
 511   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
 512   struct deduce_result_type
 513     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
 514   typedef typename adaptor_type::result_type  result_type;
 515
 516   /** Invokes the wrapped functor passing on the bound argument only.
 517    * @return The return value of the functor invocation.
 518    */
 519   result_type
 520   operator()()
 521   {
 522     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
 523     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
 524   }
 525
 526   /** Invokes the wrapped functor passing on the arguments.
 527    * bound_ is passed as the 3rd argument.
 528    * @param _A_arg1 Argument to be passed on to the functor.
 529    * @param _A_arg2 Argument to be passed on to the functor.
 530    * @return The return value of the functor invocation.
 531    */
 532   template <class T_arg1, class T_arg2>
 533   typename deduce_result_type<T_arg1, T_arg2>::type
 534   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
 535     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 536         (_A_arg1, _A_arg2, bound_.invoke());
 537     }
 538
 539   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 540   template <class T_arg1, class T_arg2>
 541   typename deduce_result_type<T_arg1, T_arg2>::type
 542   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
 543     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 544         (_A_arg1, _A_arg2, bound_.invoke());
 545     }
 546   #endif
 547
 548   /** Invokes the wrapped functor passing on the arguments.
 549    * bound_ is passed as the 3rd argument.
 550    * @param _A_arg1 Argument to be passed on to the functor.
 551    * @param _A_arg2 Argument to be passed on to the functor.
 552    * @param _A_arg3 Argument to be passed on to the functor.
 553    * @return The return value of the functor invocation.
 554    */
 555   template <class T_arg1, class T_arg2, class T_arg3>
 556   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 557   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 558     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>>
 559         (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3);
 560     }
 561
 562   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 563   template <class T_arg1, class T_arg2, class T_arg3>
 564   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 565   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 566     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>>
 567         (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3);
 568     }
 569   #endif
 570
 571   /** Invokes the wrapped functor passing on the arguments.
 572    * bound_ is passed as the 3rd argument.
 573    * @param _A_arg1 Argument to be passed on to the functor.
 574    * @param _A_arg2 Argument to be passed on to the functor.
 575    * @param _A_arg3 Argument to be passed on to the functor.
 576    * @param _A_arg4 Argument to be passed on to the functor.
 577    * @return The return value of the functor invocation.
 578    */
 579   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 580   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 581   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 582     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
 583         (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4);
 584     }
 585
 586   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 587   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 588   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 589   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 590     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>>
 591         (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4);
 592     }
 593   #endif
 594
 595   /** Invokes the wrapped functor passing on the arguments.
 596    * bound_ is passed as the 3rd argument.
 597    * @param _A_arg1 Argument to be passed on to the functor.
 598    * @param _A_arg2 Argument to be passed on to the functor.
 599    * @param _A_arg3 Argument to be passed on to the functor.
 600    * @param _A_arg4 Argument to be passed on to the functor.
 601    * @param _A_arg5 Argument to be passed on to the functor.
 602    * @return The return value of the functor invocation.
 603    */
 604   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 605   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 606   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 607     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 608         (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5);
 609     }
 610
 611   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 612   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 613   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 614   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 615     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 616         (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5);
 617     }
 618   #endif
 619
 620   /** Invokes the wrapped functor passing on the arguments.
 621    * bound_ is passed as the 3rd argument.
 622    * @param _A_arg1 Argument to be passed on to the functor.
 623    * @param _A_arg2 Argument to be passed on to the functor.
 624    * @param _A_arg3 Argument to be passed on to the functor.
 625    * @param _A_arg4 Argument to be passed on to the functor.
 626    * @param _A_arg5 Argument to be passed on to the functor.
 627    * @param _A_arg6 Argument to be passed on to the functor.
 628    * @return The return value of the functor invocation.
 629    */
 630   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 631   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 632   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 633     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 634         (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5, _A_arg6);
 635     }
 636
 637   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 638   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 639   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 640   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 641     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 642         (_A_arg1, _A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5, _A_arg6);
 643     }
 644   #endif
 645
 646   /** Constructs a bind_functor object that binds an argument to the passed functor.
 647    * @param _A_func Functor to invoke from operator()().
 648    * @param _A_bound Argument to bind to the functor.
 649    */
 650   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
 651     : adapts<T_functor>(_A_func), bound_(_A_bound)
 652     {}
 653
 654   /// The argument bound to the functor.
 655   bound_argument<T_bound> bound_;
 656 };
 657
 658 /** Adaptor that binds an argument to the wrapped functor.
 659  * This template specialization fixes the 4th argument of the wrapped functor.
 660  *
 661  * @ingroup bind
 662  */
 663 template <class T_functor, class T_bound>
 664 struct bind_functor<3, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
 665 {
 666   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 667
 668   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
 669   struct deduce_result_type
 670     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
 671   typedef typename adaptor_type::result_type  result_type;
 672
 673   /** Invokes the wrapped functor passing on the bound argument only.
 674    * @return The return value of the functor invocation.
 675    */
 676   result_type
 677   operator()()
 678   {
 679     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
 680     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
 681   }
 682
 683   /** Invokes the wrapped functor passing on the arguments.
 684    * bound_ is passed as the 4th argument.
 685    * @param _A_arg1 Argument to be passed on to the functor.
 686    * @param _A_arg2 Argument to be passed on to the functor.
 687    * @param _A_arg3 Argument to be passed on to the functor.
 688    * @return The return value of the functor invocation.
 689    */
 690   template <class T_arg1, class T_arg2, class T_arg3>
 691   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 692   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 693     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 694         (_A_arg1, _A_arg2, _A_arg3, bound_.invoke());
 695     }
 696
 697   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 698   template <class T_arg1, class T_arg2, class T_arg3>
 699   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 700   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
 701     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 702         (_A_arg1, _A_arg2, _A_arg3, bound_.invoke());
 703     }
 704   #endif
 705
 706   /** Invokes the wrapped functor passing on the arguments.
 707    * bound_ is passed as the 4th argument.
 708    * @param _A_arg1 Argument to be passed on to the functor.
 709    * @param _A_arg2 Argument to be passed on to the functor.
 710    * @param _A_arg3 Argument to be passed on to the functor.
 711    * @param _A_arg4 Argument to be passed on to the functor.
 712    * @return The return value of the functor invocation.
 713    */
 714   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 715   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 716   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 717     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>>
 718         (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4);
 719     }
 720
 721   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 722   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 723   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 724   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 725     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>>
 726         (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4);
 727     }
 728   #endif
 729
 730   /** Invokes the wrapped functor passing on the arguments.
 731    * bound_ is passed as the 4th argument.
 732    * @param _A_arg1 Argument to be passed on to the functor.
 733    * @param _A_arg2 Argument to be passed on to the functor.
 734    * @param _A_arg3 Argument to be passed on to the functor.
 735    * @param _A_arg4 Argument to be passed on to the functor.
 736    * @param _A_arg5 Argument to be passed on to the functor.
 737    * @return The return value of the functor invocation.
 738    */
 739   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 740   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 741   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 742     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 743         (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4, _A_arg5);
 744     }
 745
 746   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 747   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 748   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 749   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 750     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>>
 751         (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4, _A_arg5);
 752     }
 753   #endif
 754
 755   /** Invokes the wrapped functor passing on the arguments.
 756    * bound_ is passed as the 4th argument.
 757    * @param _A_arg1 Argument to be passed on to the functor.
 758    * @param _A_arg2 Argument to be passed on to the functor.
 759    * @param _A_arg3 Argument to be passed on to the functor.
 760    * @param _A_arg4 Argument to be passed on to the functor.
 761    * @param _A_arg5 Argument to be passed on to the functor.
 762    * @param _A_arg6 Argument to be passed on to the functor.
 763    * @return The return value of the functor invocation.
 764    */
 765   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 766   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 767   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 768     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 769         (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4, _A_arg5, _A_arg6);
 770     }
 771
 772   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 773   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 774   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 775   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 776     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 777         (_A_arg1, _A_arg2, _A_arg3, bound_.invoke(), _A_arg4, _A_arg5, _A_arg6);
 778     }
 779   #endif
 780
 781   /** Constructs a bind_functor object that binds an argument to the passed functor.
 782    * @param _A_func Functor to invoke from operator()().
 783    * @param _A_bound Argument to bind to the functor.
 784    */
 785   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
 786     : adapts<T_functor>(_A_func), bound_(_A_bound)
 787     {}
 788
 789   /// The argument bound to the functor.
 790   bound_argument<T_bound> bound_;
 791 };
 792
 793 /** Adaptor that binds an argument to the wrapped functor.
 794  * This template specialization fixes the 5th argument of the wrapped functor.
 795  *
 796  * @ingroup bind
 797  */
 798 template <class T_functor, class T_bound>
 799 struct bind_functor<4, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
 800 {
 801   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 802
 803   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
 804   struct deduce_result_type
 805     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>::type type; };
 806   typedef typename adaptor_type::result_type  result_type;
 807
 808   /** Invokes the wrapped functor passing on the bound argument only.
 809    * @return The return value of the functor invocation.
 810    */
 811   result_type
 812   operator()()
 813   {
 814     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
 815     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
 816   }
 817
 818   /** Invokes the wrapped functor passing on the arguments.
 819    * bound_ is passed as the 5th argument.
 820    * @param _A_arg1 Argument to be passed on to the functor.
 821    * @param _A_arg2 Argument to be passed on to the functor.
 822    * @param _A_arg3 Argument to be passed on to the functor.
 823    * @param _A_arg4 Argument to be passed on to the functor.
 824    * @return The return value of the functor invocation.
 825    */
 826   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 827   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 828   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 829     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 830         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke());
 831     }
 832
 833   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 834   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 835   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 836   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
 837     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 838         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke());
 839     }
 840   #endif
 841
 842   /** Invokes the wrapped functor passing on the arguments.
 843    * bound_ is passed as the 5th argument.
 844    * @param _A_arg1 Argument to be passed on to the functor.
 845    * @param _A_arg2 Argument to be passed on to the functor.
 846    * @param _A_arg3 Argument to be passed on to the functor.
 847    * @param _A_arg4 Argument to be passed on to the functor.
 848    * @param _A_arg5 Argument to be passed on to the functor.
 849    * @return The return value of the functor invocation.
 850    */
 851   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 852   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 853   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 854     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>>
 855         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke(), _A_arg5);
 856     }
 857
 858   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 859   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 860   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 861   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 862     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>>
 863         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke(), _A_arg5);
 864     }
 865   #endif
 866
 867   /** Invokes the wrapped functor passing on the arguments.
 868    * bound_ is passed as the 5th argument.
 869    * @param _A_arg1 Argument to be passed on to the functor.
 870    * @param _A_arg2 Argument to be passed on to the functor.
 871    * @param _A_arg3 Argument to be passed on to the functor.
 872    * @param _A_arg4 Argument to be passed on to the functor.
 873    * @param _A_arg5 Argument to be passed on to the functor.
 874    * @param _A_arg6 Argument to be passed on to the functor.
 875    * @return The return value of the functor invocation.
 876    */
 877   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 878   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 879   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 880     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 881         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke(), _A_arg5, _A_arg6);
 882     }
 883
 884   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 885   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 886   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 887   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 888     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>>
 889         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound_.invoke(), _A_arg5, _A_arg6);
 890     }
 891   #endif
 892
 893   /** Constructs a bind_functor object that binds an argument to the passed functor.
 894    * @param _A_func Functor to invoke from operator()().
 895    * @param _A_bound Argument to bind to the functor.
 896    */
 897   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
 898     : adapts<T_functor>(_A_func), bound_(_A_bound)
 899     {}
 900
 901   /// The argument bound to the functor.
 902   bound_argument<T_bound> bound_;
 903 };
 904
 905 /** Adaptor that binds an argument to the wrapped functor.
 906  * This template specialization fixes the 6th argument of the wrapped functor.
 907  *
 908  * @ingroup bind
 909  */
 910 template <class T_functor, class T_bound>
 911 struct bind_functor<5, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
 912 {
 913   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 914
 915   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
 916   struct deduce_result_type
 917     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg6>>::type type; };
 918   typedef typename adaptor_type::result_type  result_type;
 919
 920   /** Invokes the wrapped functor passing on the bound argument only.
 921    * @return The return value of the functor invocation.
 922    */
 923   result_type
 924   operator()()
 925   {
 926     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
 927     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
 928   }
 929
 930   /** Invokes the wrapped functor passing on the arguments.
 931    * bound_ is passed as the 6th argument.
 932    * @param _A_arg1 Argument to be passed on to the functor.
 933    * @param _A_arg2 Argument to be passed on to the functor.
 934    * @param _A_arg3 Argument to be passed on to the functor.
 935    * @param _A_arg4 Argument to be passed on to the functor.
 936    * @param _A_arg5 Argument to be passed on to the functor.
 937    * @return The return value of the functor invocation.
 938    */
 939   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 940   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 941   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 942     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 943         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound_.invoke());
 944     }
 945
 946   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 947   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 948   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 949   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
 950     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
 951         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound_.invoke());
 952     }
 953   #endif
 954
 955   /** Invokes the wrapped functor passing on the arguments.
 956    * bound_ is passed as the 6th argument.
 957    * @param _A_arg1 Argument to be passed on to the functor.
 958    * @param _A_arg2 Argument to be passed on to the functor.
 959    * @param _A_arg3 Argument to be passed on to the functor.
 960    * @param _A_arg4 Argument to be passed on to the functor.
 961    * @param _A_arg5 Argument to be passed on to the functor.
 962    * @param _A_arg6 Argument to be passed on to the functor.
 963    * @return The return value of the functor invocation.
 964    */
 965   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 966   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 967   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 968     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg6>>
 969         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound_.invoke(), _A_arg6);
 970     }
 971
 972   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 973   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 974   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 975   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
 976     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>, type_trait_pass_t<T_arg6>>
 977         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound_.invoke(), _A_arg6);
 978     }
 979   #endif
 980
 981   /** Constructs a bind_functor object that binds an argument to the passed functor.
 982    * @param _A_func Functor to invoke from operator()().
 983    * @param _A_bound Argument to bind to the functor.
 984    */
 985   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
 986     : adapts<T_functor>(_A_func), bound_(_A_bound)
 987     {}
 988
 989   /// The argument bound to the functor.
 990   bound_argument<T_bound> bound_;
 991 };
 992
 993 /** Adaptor that binds an argument to the wrapped functor.
 994  * This template specialization fixes the 7th argument of the wrapped functor.
 995  *
 996  * @ingroup bind
 997  */
 998 template <class T_functor, class T_bound>
 999 struct bind_functor<6, T_functor, T_bound, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
1000 {
1001   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
1002
1003   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
1004   struct deduce_result_type
1005     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>::type type; };
1006   typedef typename adaptor_type::result_type  result_type;
1007
1008   /** Invokes the wrapped functor passing on the bound argument only.
1009    * @return The return value of the functor invocation.
1010    */
1011   result_type
1012   operator()()
1013   {
1014     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
1015     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_bound>::type>> (bound_.invoke());
1016   }
1017
1018   /** Invokes the wrapped functor passing on the arguments.
1019    * bound_ is passed as the 7th argument.
1020    * @param _A_arg1 Argument to be passed on to the functor.
1021    * @param _A_arg2 Argument to be passed on to the functor.
1022    * @param _A_arg3 Argument to be passed on to the functor.
1023    * @param _A_arg4 Argument to be passed on to the functor.
1024    * @param _A_arg5 Argument to be passed on to the functor.
1025    * @param _A_arg6 Argument to be passed on to the functor.
1026    * @return The return value of the functor invocation.
1027    */
1028   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
1029   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
1030   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
1031     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
1032         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, bound_.invoke());
1033     }
1034
1035   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1036   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
1037   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
1038   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
1039     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_bound>::type>>
1040         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, bound_.invoke());
1041     }
1042   #endif
1043
1044   /** Constructs a bind_functor object that binds an argument to the passed functor.
1045    * @param _A_func Functor to invoke from operator()().
1046    * @param _A_bound Argument to bind to the functor.
1047    */
1048   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_bound> _A_bound)
1049     : adapts<T_functor>(_A_func), bound_(_A_bound)
1050     {}
1051
1052   /// The argument bound to the functor.
1053   bound_argument<T_bound> bound_;
1054 };
1055 #endif // DOXYGEN_SHOULD_SKIP_THIS
1056
1057
1058 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1059 //template specialization of visitor<>::do_visit_each<>(action, functor):
1060 /** Performs a functor on each of the targets of a functor.
1061  * The function overload for sigc::bind_functor performs a functor on the
1062  * functor and on the object instances stored in the sigc::bind_functor object.
1063  *
1064  * @ingroup bind
1065  */
1066 template <int T_loc, class T_functor, class T_bound>
1067 struct visitor<bind_functor<T_loc, T_functor, T_bound> >
1068 {
1069   template <class T_action>
1070   static void do_visit_each(const T_action& _A_action,
1071                             const bind_functor<T_loc, T_functor, T_bound>& _A_target)
1072   {
1073     sigc::visit_each(_A_action, _A_target.functor_);
1074     sigc::visit_each(_A_action, _A_target.bound_);
1075   }
1076 };
1077 #endif // DOXYGEN_SHOULD_SKIP_THIS
1078
1079 /** Adaptor that binds 1 argument(s) to the wrapped functor.
1080  * This template specialization fixes the last 1 argument(s) of the wrapped functor.
1081  *
1082  * @ingroup bind
1083  */
1084 template <class T_functor, class T_type1>
1085 struct bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
1086 {
1087   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
1088
1089 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1090   template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1091   struct deduce_result_type_internal
1092     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
1093   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1094   struct deduce_result_type_internal<2, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1095     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
1096   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1097   struct deduce_result_type_internal<3, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1098     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
1099   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1100   struct deduce_result_type_internal<4, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1101     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
1102   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1103   struct deduce_result_type_internal<5, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1104     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
1105   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1106   struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1107     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>::type type; };
1108
1109   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
1110   struct deduce_result_type {
1111     typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
1112                                                  T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
1113   };
1114 #endif // DOXYGEN_SHOULD_SKIP_THIS
1115   typedef typename adaptor_type::result_type  result_type;
1116
1117   /** Invokes the wrapped functor passing on the bound argument only.
1118    * @return The return value of the functor invocation.
1119    */
1120   result_type
1121   operator()()
1122   {
1123     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
1124     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_type1>::type>> (bound1_.invoke());
1125   }
1126
1127   /** Invokes the wrapped functor passing on the arguments.
1128    * The last 1 argument(s) are fixed.
1129    * @param _A_arg1 Argument to be passed on to the functor.
1130    * @return The return value of the functor invocation.
1131    */
1132   template <class T_arg1>
1133   typename deduce_result_type<T_arg1>::type
1134   operator()(T_arg1 _A_arg1)
1135     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1136         (_A_arg1, bound1_.invoke());
1137     }
1138
1139   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1140   template <class T_arg1>
1141   typename deduce_result_type<T_arg1>::type
1142   sun_forte_workaround(T_arg1 _A_arg1)
1143     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1144         (_A_arg1, bound1_.invoke());
1145     }
1146   #endif
1147
1148   /** Invokes the wrapped functor passing on the arguments.
1149    * The last 1 argument(s) are fixed.
1150    * @param _A_arg1 Argument to be passed on to the functor.
1151    * @param _A_arg2 Argument to be passed on to the functor.
1152    * @return The return value of the functor invocation.
1153    */
1154   template <class T_arg1, class T_arg2>
1155   typename deduce_result_type<T_arg1, T_arg2>::type
1156   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
1157     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1158         (_A_arg1, _A_arg2, bound1_.invoke());
1159     }
1160
1161   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1162   template <class T_arg1, class T_arg2>
1163   typename deduce_result_type<T_arg1, T_arg2>::type
1164   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
1165     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1166         (_A_arg1, _A_arg2, bound1_.invoke());
1167     }
1168   #endif
1169
1170   /** Invokes the wrapped functor passing on the arguments.
1171    * The last 1 argument(s) are fixed.
1172    * @param _A_arg1 Argument to be passed on to the functor.
1173    * @param _A_arg2 Argument to be passed on to the functor.
1174    * @param _A_arg3 Argument to be passed on to the functor.
1175    * @return The return value of the functor invocation.
1176    */
1177   template <class T_arg1, class T_arg2, class T_arg3>
1178   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
1179   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
1180     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1181         (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke());
1182     }
1183
1184   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1185   template <class T_arg1, class T_arg2, class T_arg3>
1186   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
1187   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
1188     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1189         (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke());
1190     }
1191   #endif
1192
1193   /** Invokes the wrapped functor passing on the arguments.
1194    * The last 1 argument(s) are fixed.
1195    * @param _A_arg1 Argument to be passed on to the functor.
1196    * @param _A_arg2 Argument to be passed on to the functor.
1197    * @param _A_arg3 Argument to be passed on to the functor.
1198    * @param _A_arg4 Argument to be passed on to the functor.
1199    * @return The return value of the functor invocation.
1200    */
1201   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
1202   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
1203   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
1204     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1205         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke());
1206     }
1207
1208   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1209   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
1210   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
1211   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
1212     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1213         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke());
1214     }
1215   #endif
1216
1217   /** Invokes the wrapped functor passing on the arguments.
1218    * The last 1 argument(s) are fixed.
1219    * @param _A_arg1 Argument to be passed on to the functor.
1220    * @param _A_arg2 Argument to be passed on to the functor.
1221    * @param _A_arg3 Argument to be passed on to the functor.
1222    * @param _A_arg4 Argument to be passed on to the functor.
1223    * @param _A_arg5 Argument to be passed on to the functor.
1224    * @return The return value of the functor invocation.
1225    */
1226   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
1227   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
1228   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
1229     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1230         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound1_.invoke());
1231     }
1232
1233   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1234   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
1235   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
1236   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
1237     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1238         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound1_.invoke());
1239     }
1240   #endif
1241
1242   /** Invokes the wrapped functor passing on the arguments.
1243    * The last 1 argument(s) are fixed.
1244    * @param _A_arg1 Argument to be passed on to the functor.
1245    * @param _A_arg2 Argument to be passed on to the functor.
1246    * @param _A_arg3 Argument to be passed on to the functor.
1247    * @param _A_arg4 Argument to be passed on to the functor.
1248    * @param _A_arg5 Argument to be passed on to the functor.
1249    * @param _A_arg6 Argument to be passed on to the functor.
1250    * @return The return value of the functor invocation.
1251    */
1252   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
1253   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
1254   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
1255     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1256         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, bound1_.invoke());
1257     }
1258
1259   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1260   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
1261   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
1262   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5, T_arg6 _A_arg6)
1263     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>>
1264         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6, bound1_.invoke());
1265     }
1266   #endif
1267
1268   /** Constructs a bind_functor object that binds an argument to the passed functor.
1269    * @param _A_func Functor to invoke from operator()().
1270    * @param _A_bound1 Argument to bind to the functor.
1271    */
1272   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1)
1273     : adapts<T_functor>(_A_func), bound1_(_A_bound1)
1274     {}
1275
1276   /// The argument bound to the functor.
1277   bound_argument<T_type1> bound1_;
1278 };
1279
1280 #ifndef DOXYGEN_SHOULD_SKIP_THIS
1281 //template specialization of visitor<>::do_visit_each<>(action, functor):
1282 /** Performs a functor on each of the targets of a functor.
1283  * The function overload for sigc::bind_functor performs a functor on the
1284  * functor and on the object instances stored in the sigc::bind_functor object.
1285  *
1286  * @ingroup bind
1287  */
1288 template <class T_functor, class T_type1>
1289 struct visitor<bind_functor<-1, T_functor, T_type1> >
1290 {
1291   template <typename T_action>
1292   static void do_visit_each(const T_action& _A_action,
1293                             const bind_functor<-1, T_functor,  T_type1>& _A_target)
1294   {
1295     sigc::visit_each(_A_action, _A_target.functor_);
1296     sigc::visit_each(_A_action, _A_target.bound1_);
1297   }
1298 };
1299
1300 /** Adaptor that binds 2 argument(s) to the wrapped functor.
1301  * This template specialization fixes the last 2 argument(s) of the wrapped functor.
1302  *
1303  * @ingroup bind
1304  */
1305 template <class T_functor, class T_type1, class T_type2>
1306 struct bind_functor<-1, T_functor, T_type1, T_type2, nil, nil, nil, nil, nil> : public adapts<T_functor>
1307 {
1308   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
1309
1310   template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1311   struct deduce_result_type_internal
1312     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
1313   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1314   struct deduce_result_type_internal<3, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1315     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
1316   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1317   struct deduce_result_type_internal<4, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1318     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
1319   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1320   struct deduce_result_type_internal<5, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1321     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
1322   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1323   struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1324     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>::type type; };
1325
1326   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
1327   struct deduce_result_type {
1328     typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
1329                                                  T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
1330   };
1331   typedef typename adaptor_type::result_type  result_type;
1332
1333   /** Invokes the wrapped functor passing on the bound argument only.
1334    * @return The return value of the functor invocation.
1335    */
1336   result_type
1337   operator()()
1338   {
1339     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
1340     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>> (bound1_.invoke(), bound2_.invoke());
1341   }
1342
1343   /** Invokes the wrapped functor passing on the arguments.
1344    * The last 2 argument(s) are fixed.
1345    * @param _A_arg1 Argument to be passed on to the functor.
1346    * @return The return value of the functor invocation.
1347    */
1348   template <class T_arg1>
1349   typename deduce_result_type<T_arg1>::type
1350   operator()(T_arg1 _A_arg1)
1351     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1352         (_A_arg1, bound1_.invoke(), bound2_.invoke());
1353     }
1354
1355   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1356   template <class T_arg1>
1357   typename deduce_result_type<T_arg1>::type
1358   sun_forte_workaround(T_arg1 _A_arg1)
1359     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1360         (_A_arg1, bound1_.invoke(), bound2_.invoke());
1361     }
1362   #endif
1363
1364   /** Invokes the wrapped functor passing on the arguments.
1365    * The last 2 argument(s) are fixed.
1366    * @param _A_arg1 Argument to be passed on to the functor.
1367    * @param _A_arg2 Argument to be passed on to the functor.
1368    * @return The return value of the functor invocation.
1369    */
1370   template <class T_arg1, class T_arg2>
1371   typename deduce_result_type<T_arg1, T_arg2>::type
1372   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
1373     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1374         (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke());
1375     }
1376
1377   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1378   template <class T_arg1, class T_arg2>
1379   typename deduce_result_type<T_arg1, T_arg2>::type
1380   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
1381     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1382         (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke());
1383     }
1384   #endif
1385
1386   /** Invokes the wrapped functor passing on the arguments.
1387    * The last 2 argument(s) are fixed.
1388    * @param _A_arg1 Argument to be passed on to the functor.
1389    * @param _A_arg2 Argument to be passed on to the functor.
1390    * @param _A_arg3 Argument to be passed on to the functor.
1391    * @return The return value of the functor invocation.
1392    */
1393   template <class T_arg1, class T_arg2, class T_arg3>
1394   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
1395   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
1396     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1397         (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke());
1398     }
1399
1400   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1401   template <class T_arg1, class T_arg2, class T_arg3>
1402   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
1403   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
1404     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1405         (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke());
1406     }
1407   #endif
1408
1409   /** Invokes the wrapped functor passing on the arguments.
1410    * The last 2 argument(s) are fixed.
1411    * @param _A_arg1 Argument to be passed on to the functor.
1412    * @param _A_arg2 Argument to be passed on to the functor.
1413    * @param _A_arg3 Argument to be passed on to the functor.
1414    * @param _A_arg4 Argument to be passed on to the functor.
1415    * @return The return value of the functor invocation.
1416    */
1417   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
1418   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
1419   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
1420     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1421         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke(), bound2_.invoke());
1422     }
1423
1424   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1425   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
1426   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
1427   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
1428     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1429         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke(), bound2_.invoke());
1430     }
1431   #endif
1432
1433   /** Invokes the wrapped functor passing on the arguments.
1434    * The last 2 argument(s) are fixed.
1435    * @param _A_arg1 Argument to be passed on to the functor.
1436    * @param _A_arg2 Argument to be passed on to the functor.
1437    * @param _A_arg3 Argument to be passed on to the functor.
1438    * @param _A_arg4 Argument to be passed on to the functor.
1439    * @param _A_arg5 Argument to be passed on to the functor.
1440    * @return The return value of the functor invocation.
1441    */
1442   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
1443   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
1444   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
1445     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1446         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound1_.invoke(), bound2_.invoke());
1447     }
1448
1449   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1450   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
1451   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
1452   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4, T_arg5 _A_arg5)
1453     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>>
1454         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, bound1_.invoke(), bound2_.invoke());
1455     }
1456   #endif
1457
1458   /** Constructs a bind_functor object that binds an argument to the passed functor.
1459    * @param _A_func Functor to invoke from operator()().
1460    * @param _A_bound1 Argument to bind to the functor.
1461    * @param _A_bound2 Argument to bind to the functor.
1462    */
1463   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2)
1464     : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2)
1465     {}
1466
1467   /// The argument bound to the functor.
1468   bound_argument<T_type1> bound1_;
1469   bound_argument<T_type2> bound2_;
1470 };
1471
1472 //template specialization of visitor<>::do_visit_each<>(action, functor):
1473 /** Performs a functor on each of the targets of a functor.
1474  * The function overload for sigc::bind_functor performs a functor on the
1475  * functor and on the object instances stored in the sigc::bind_functor object.
1476  *
1477  * @ingroup bind
1478  */
1479 template <class T_functor, class T_type1, class T_type2>
1480 struct visitor<bind_functor<-1, T_functor, T_type1, T_type2> >
1481 {
1482   template <typename T_action>
1483   static void do_visit_each(const T_action& _A_action,
1484                             const bind_functor<-1, T_functor,  T_type1, T_type2>& _A_target)
1485   {
1486     sigc::visit_each(_A_action, _A_target.functor_);
1487     sigc::visit_each(_A_action, _A_target.bound1_);
1488     sigc::visit_each(_A_action, _A_target.bound2_);
1489   }
1490 };
1491
1492 /** Adaptor that binds 3 argument(s) to the wrapped functor.
1493  * This template specialization fixes the last 3 argument(s) of the wrapped functor.
1494  *
1495  * @ingroup bind
1496  */
1497 template <class T_functor, class T_type1, class T_type2, class T_type3>
1498 struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil, nil, nil, nil> : public adapts<T_functor>
1499 {
1500   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
1501
1502   template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1503   struct deduce_result_type_internal
1504     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>::type type; };
1505   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1506   struct deduce_result_type_internal<4, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1507     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>::type type; };
1508   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1509   struct deduce_result_type_internal<5, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1510     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>::type type; };
1511   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1512   struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1513     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>::type type; };
1514
1515   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
1516   struct deduce_result_type {
1517     typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
1518                                                  T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
1519   };
1520   typedef typename adaptor_type::result_type  result_type;
1521
1522   /** Invokes the wrapped functor passing on the bound argument only.
1523    * @return The return value of the functor invocation.
1524    */
1525   result_type
1526   operator()()
1527   {
1528     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
1529     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1530   }
1531
1532   /** Invokes the wrapped functor passing on the arguments.
1533    * The last 3 argument(s) are fixed.
1534    * @param _A_arg1 Argument to be passed on to the functor.
1535    * @return The return value of the functor invocation.
1536    */
1537   template <class T_arg1>
1538   typename deduce_result_type<T_arg1>::type
1539   operator()(T_arg1 _A_arg1)
1540     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
1541         (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1542     }
1543
1544   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1545   template <class T_arg1>
1546   typename deduce_result_type<T_arg1>::type
1547   sun_forte_workaround(T_arg1 _A_arg1)
1548     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
1549         (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1550     }
1551   #endif
1552
1553   /** Invokes the wrapped functor passing on the arguments.
1554    * The last 3 argument(s) are fixed.
1555    * @param _A_arg1 Argument to be passed on to the functor.
1556    * @param _A_arg2 Argument to be passed on to the functor.
1557    * @return The return value of the functor invocation.
1558    */
1559   template <class T_arg1, class T_arg2>
1560   typename deduce_result_type<T_arg1, T_arg2>::type
1561   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
1562     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
1563         (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1564     }
1565
1566   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1567   template <class T_arg1, class T_arg2>
1568   typename deduce_result_type<T_arg1, T_arg2>::type
1569   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
1570     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
1571         (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1572     }
1573   #endif
1574
1575   /** Invokes the wrapped functor passing on the arguments.
1576    * The last 3 argument(s) are fixed.
1577    * @param _A_arg1 Argument to be passed on to the functor.
1578    * @param _A_arg2 Argument to be passed on to the functor.
1579    * @param _A_arg3 Argument to be passed on to the functor.
1580    * @return The return value of the functor invocation.
1581    */
1582   template <class T_arg1, class T_arg2, class T_arg3>
1583   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
1584   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
1585     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
1586         (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1587     }
1588
1589   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1590   template <class T_arg1, class T_arg2, class T_arg3>
1591   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
1592   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
1593     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
1594         (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1595     }
1596   #endif
1597
1598   /** Invokes the wrapped functor passing on the arguments.
1599    * The last 3 argument(s) are fixed.
1600    * @param _A_arg1 Argument to be passed on to the functor.
1601    * @param _A_arg2 Argument to be passed on to the functor.
1602    * @param _A_arg3 Argument to be passed on to the functor.
1603    * @param _A_arg4 Argument to be passed on to the functor.
1604    * @return The return value of the functor invocation.
1605    */
1606   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
1607   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
1608   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
1609     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
1610         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1611     }
1612
1613   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1614   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
1615   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
1616   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3, T_arg4 _A_arg4)
1617     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>>
1618         (_A_arg1, _A_arg2, _A_arg3, _A_arg4, bound1_.invoke(), bound2_.invoke(), bound3_.invoke());
1619     }
1620   #endif
1621
1622   /** Constructs a bind_functor object that binds an argument to the passed functor.
1623    * @param _A_func Functor to invoke from operator()().
1624    * @param _A_bound1 Argument to bind to the functor.
1625    * @param _A_bound2 Argument to bind to the functor.
1626    * @param _A_bound3 Argument to bind to the functor.
1627    */
1628   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3)
1629     : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3)
1630     {}
1631
1632   /// The argument bound to the functor.
1633   bound_argument<T_type1> bound1_;
1634   bound_argument<T_type2> bound2_;
1635   bound_argument<T_type3> bound3_;
1636 };
1637
1638 //template specialization of visitor<>::do_visit_each<>(action, functor):
1639 /** Performs a functor on each of the targets of a functor.
1640  * The function overload for sigc::bind_functor performs a functor on the
1641  * functor and on the object instances stored in the sigc::bind_functor object.
1642  *
1643  * @ingroup bind
1644  */
1645 template <class T_functor, class T_type1, class T_type2, class T_type3>
1646 struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3> >
1647 {
1648   template <typename T_action>
1649   static void do_visit_each(const T_action& _A_action,
1650                             const bind_functor<-1, T_functor,  T_type1, T_type2, T_type3>& _A_target)
1651   {
1652     sigc::visit_each(_A_action, _A_target.functor_);
1653     sigc::visit_each(_A_action, _A_target.bound1_);
1654     sigc::visit_each(_A_action, _A_target.bound2_);
1655     sigc::visit_each(_A_action, _A_target.bound3_);
1656   }
1657 };
1658
1659 /** Adaptor that binds 4 argument(s) to the wrapped functor.
1660  * This template specialization fixes the last 4 argument(s) of the wrapped functor.
1661  *
1662  * @ingroup bind
1663  */
1664 template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4>
1665 struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil, nil, nil> : public adapts<T_functor>
1666 {
1667   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
1668
1669   template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1670   struct deduce_result_type_internal
1671     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>::type type; };
1672   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1673   struct deduce_result_type_internal<5, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1674     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>::type type; };
1675   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1676   struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1677     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>::type type; };
1678
1679   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
1680   struct deduce_result_type {
1681     typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
1682                                                  T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
1683   };
1684   typedef typename adaptor_type::result_type  result_type;
1685
1686   /** Invokes the wrapped functor passing on the bound argument only.
1687    * @return The return value of the functor invocation.
1688    */
1689   result_type
1690   operator()()
1691   {
1692     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
1693     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
1694   }
1695
1696   /** Invokes the wrapped functor passing on the arguments.
1697    * The last 4 argument(s) are fixed.
1698    * @param _A_arg1 Argument to be passed on to the functor.
1699    * @return The return value of the functor invocation.
1700    */
1701   template <class T_arg1>
1702   typename deduce_result_type<T_arg1>::type
1703   operator()(T_arg1 _A_arg1)
1704     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
1705         (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
1706     }
1707
1708   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1709   template <class T_arg1>
1710   typename deduce_result_type<T_arg1>::type
1711   sun_forte_workaround(T_arg1 _A_arg1)
1712     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
1713         (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
1714     }
1715   #endif
1716
1717   /** Invokes the wrapped functor passing on the arguments.
1718    * The last 4 argument(s) are fixed.
1719    * @param _A_arg1 Argument to be passed on to the functor.
1720    * @param _A_arg2 Argument to be passed on to the functor.
1721    * @return The return value of the functor invocation.
1722    */
1723   template <class T_arg1, class T_arg2>
1724   typename deduce_result_type<T_arg1, T_arg2>::type
1725   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
1726     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
1727         (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
1728     }
1729
1730   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1731   template <class T_arg1, class T_arg2>
1732   typename deduce_result_type<T_arg1, T_arg2>::type
1733   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
1734     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
1735         (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
1736     }
1737   #endif
1738
1739   /** Invokes the wrapped functor passing on the arguments.
1740    * The last 4 argument(s) are fixed.
1741    * @param _A_arg1 Argument to be passed on to the functor.
1742    * @param _A_arg2 Argument to be passed on to the functor.
1743    * @param _A_arg3 Argument to be passed on to the functor.
1744    * @return The return value of the functor invocation.
1745    */
1746   template <class T_arg1, class T_arg2, class T_arg3>
1747   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
1748   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
1749     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
1750         (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
1751     }
1752
1753   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1754   template <class T_arg1, class T_arg2, class T_arg3>
1755   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
1756   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2, T_arg3 _A_arg3)
1757     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>>
1758         (_A_arg1, _A_arg2, _A_arg3, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke());
1759     }
1760   #endif
1761
1762   /** Constructs a bind_functor object that binds an argument to the passed functor.
1763    * @param _A_func Functor to invoke from operator()().
1764    * @param _A_bound1 Argument to bind to the functor.
1765    * @param _A_bound2 Argument to bind to the functor.
1766    * @param _A_bound3 Argument to bind to the functor.
1767    * @param _A_bound4 Argument to bind to the functor.
1768    */
1769   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3, type_trait_take_t<T_type4> _A_bound4)
1770     : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3), bound4_(_A_bound4)
1771     {}
1772
1773   /// The argument bound to the functor.
1774   bound_argument<T_type1> bound1_;
1775   bound_argument<T_type2> bound2_;
1776   bound_argument<T_type3> bound3_;
1777   bound_argument<T_type4> bound4_;
1778 };
1779
1780 //template specialization of visitor<>::do_visit_each<>(action, functor):
1781 /** Performs a functor on each of the targets of a functor.
1782  * The function overload for sigc::bind_functor performs a functor on the
1783  * functor and on the object instances stored in the sigc::bind_functor object.
1784  *
1785  * @ingroup bind
1786  */
1787 template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4>
1788 struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4> >
1789 {
1790   template <typename T_action>
1791   static void do_visit_each(const T_action& _A_action,
1792                             const bind_functor<-1, T_functor,  T_type1, T_type2, T_type3, T_type4>& _A_target)
1793   {
1794     sigc::visit_each(_A_action, _A_target.functor_);
1795     sigc::visit_each(_A_action, _A_target.bound1_);
1796     sigc::visit_each(_A_action, _A_target.bound2_);
1797     sigc::visit_each(_A_action, _A_target.bound3_);
1798     sigc::visit_each(_A_action, _A_target.bound4_);
1799   }
1800 };
1801
1802 /** Adaptor that binds 5 argument(s) to the wrapped functor.
1803  * This template specialization fixes the last 5 argument(s) of the wrapped functor.
1804  *
1805  * @ingroup bind
1806  */
1807 template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5>
1808 struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, nil, nil> : public adapts<T_functor>
1809 {
1810   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
1811
1812   template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1813   struct deduce_result_type_internal
1814     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>::type type; };
1815   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1816   struct deduce_result_type_internal<6, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
1817     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>::type type; };
1818
1819   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
1820   struct deduce_result_type {
1821     typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
1822                                                  T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
1823   };
1824   typedef typename adaptor_type::result_type  result_type;
1825
1826   /** Invokes the wrapped functor passing on the bound argument only.
1827    * @return The return value of the functor invocation.
1828    */
1829   result_type
1830   operator()()
1831   {
1832     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
1833     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
1834   }
1835
1836   /** Invokes the wrapped functor passing on the arguments.
1837    * The last 5 argument(s) are fixed.
1838    * @param _A_arg1 Argument to be passed on to the functor.
1839    * @return The return value of the functor invocation.
1840    */
1841   template <class T_arg1>
1842   typename deduce_result_type<T_arg1>::type
1843   operator()(T_arg1 _A_arg1)
1844     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>
1845         (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
1846     }
1847
1848   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1849   template <class T_arg1>
1850   typename deduce_result_type<T_arg1>::type
1851   sun_forte_workaround(T_arg1 _A_arg1)
1852     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>
1853         (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
1854     }
1855   #endif
1856
1857   /** Invokes the wrapped functor passing on the arguments.
1858    * The last 5 argument(s) are fixed.
1859    * @param _A_arg1 Argument to be passed on to the functor.
1860    * @param _A_arg2 Argument to be passed on to the functor.
1861    * @return The return value of the functor invocation.
1862    */
1863   template <class T_arg1, class T_arg2>
1864   typename deduce_result_type<T_arg1, T_arg2>::type
1865   operator()(T_arg1 _A_arg1, T_arg2 _A_arg2)
1866     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>
1867         (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
1868     }
1869
1870   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1871   template <class T_arg1, class T_arg2>
1872   typename deduce_result_type<T_arg1, T_arg2>::type
1873   sun_forte_workaround(T_arg1 _A_arg1, T_arg2 _A_arg2)
1874     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>>
1875         (_A_arg1, _A_arg2, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke());
1876     }
1877   #endif
1878
1879   /** Constructs a bind_functor object that binds an argument to the passed functor.
1880    * @param _A_func Functor to invoke from operator()().
1881    * @param _A_bound1 Argument to bind to the functor.
1882    * @param _A_bound2 Argument to bind to the functor.
1883    * @param _A_bound3 Argument to bind to the functor.
1884    * @param _A_bound4 Argument to bind to the functor.
1885    * @param _A_bound5 Argument to bind to the functor.
1886    */
1887   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3, type_trait_take_t<T_type4> _A_bound4, type_trait_take_t<T_type5> _A_bound5)
1888     : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3), bound4_(_A_bound4), bound5_(_A_bound5)
1889     {}
1890
1891   /// The argument bound to the functor.
1892   bound_argument<T_type1> bound1_;
1893   bound_argument<T_type2> bound2_;
1894   bound_argument<T_type3> bound3_;
1895   bound_argument<T_type4> bound4_;
1896   bound_argument<T_type5> bound5_;
1897 };
1898
1899 //template specialization of visitor<>::do_visit_each<>(action, functor):
1900 /** Performs a functor on each of the targets of a functor.
1901  * The function overload for sigc::bind_functor performs a functor on the
1902  * functor and on the object instances stored in the sigc::bind_functor object.
1903  *
1904  * @ingroup bind
1905  */
1906 template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5>
1907 struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5> >
1908 {
1909   template <typename T_action>
1910   static void do_visit_each(const T_action& _A_action,
1911                             const bind_functor<-1, T_functor,  T_type1, T_type2, T_type3, T_type4, T_type5>& _A_target)
1912   {
1913     sigc::visit_each(_A_action, _A_target.functor_);
1914     sigc::visit_each(_A_action, _A_target.bound1_);
1915     sigc::visit_each(_A_action, _A_target.bound2_);
1916     sigc::visit_each(_A_action, _A_target.bound3_);
1917     sigc::visit_each(_A_action, _A_target.bound4_);
1918     sigc::visit_each(_A_action, _A_target.bound5_);
1919   }
1920 };
1921
1922 /** Adaptor that binds 6 argument(s) to the wrapped functor.
1923  * This template specialization fixes the last 6 argument(s) of the wrapped functor.
1924  *
1925  * @ingroup bind
1926  */
1927 template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6>
1928 struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, nil> : public adapts<T_functor>
1929 {
1930   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
1931
1932   template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1933   struct deduce_result_type_internal
1934     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>>::type type; };
1935
1936   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
1937   struct deduce_result_type {
1938     typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
1939                                                  T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
1940   };
1941   typedef typename adaptor_type::result_type  result_type;
1942
1943   /** Invokes the wrapped functor passing on the bound argument only.
1944    * @return The return value of the functor invocation.
1945    */
1946   result_type
1947   operator()()
1948   {
1949     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
1950     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke(), bound6_.invoke());
1951   }
1952
1953   /** Invokes the wrapped functor passing on the arguments.
1954    * The last 6 argument(s) are fixed.
1955    * @param _A_arg1 Argument to be passed on to the functor.
1956    * @return The return value of the functor invocation.
1957    */
1958   template <class T_arg1>
1959   typename deduce_result_type<T_arg1>::type
1960   operator()(T_arg1 _A_arg1)
1961     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>>
1962         (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke(), bound6_.invoke());
1963     }
1964
1965   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
1966   template <class T_arg1>
1967   typename deduce_result_type<T_arg1>::type
1968   sun_forte_workaround(T_arg1 _A_arg1)
1969     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<T_arg1>, type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>>
1970         (_A_arg1, bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke(), bound6_.invoke());
1971     }
1972   #endif
1973
1974   /** Constructs a bind_functor object that binds an argument to the passed functor.
1975    * @param _A_func Functor to invoke from operator()().
1976    * @param _A_bound1 Argument to bind to the functor.
1977    * @param _A_bound2 Argument to bind to the functor.
1978    * @param _A_bound3 Argument to bind to the functor.
1979    * @param _A_bound4 Argument to bind to the functor.
1980    * @param _A_bound5 Argument to bind to the functor.
1981    * @param _A_bound6 Argument to bind to the functor.
1982    */
1983   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3, type_trait_take_t<T_type4> _A_bound4, type_trait_take_t<T_type5> _A_bound5, type_trait_take_t<T_type6> _A_bound6)
1984     : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3), bound4_(_A_bound4), bound5_(_A_bound5), bound6_(_A_bound6)
1985     {}
1986
1987   /// The argument bound to the functor.
1988   bound_argument<T_type1> bound1_;
1989   bound_argument<T_type2> bound2_;
1990   bound_argument<T_type3> bound3_;
1991   bound_argument<T_type4> bound4_;
1992   bound_argument<T_type5> bound5_;
1993   bound_argument<T_type6> bound6_;
1994 };
1995
1996 //template specialization of visitor<>::do_visit_each<>(action, functor):
1997 /** Performs a functor on each of the targets of a functor.
1998  * The function overload for sigc::bind_functor performs a functor on the
1999  * functor and on the object instances stored in the sigc::bind_functor object.
2000  *
2001  * @ingroup bind
2002  */
2003 template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6>
2004 struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6> >
2005 {
2006   template <typename T_action>
2007   static void do_visit_each(const T_action& _A_action,
2008                             const bind_functor<-1, T_functor,  T_type1, T_type2, T_type3, T_type4, T_type5, T_type6>& _A_target)
2009   {
2010     sigc::visit_each(_A_action, _A_target.functor_);
2011     sigc::visit_each(_A_action, _A_target.bound1_);
2012     sigc::visit_each(_A_action, _A_target.bound2_);
2013     sigc::visit_each(_A_action, _A_target.bound3_);
2014     sigc::visit_each(_A_action, _A_target.bound4_);
2015     sigc::visit_each(_A_action, _A_target.bound5_);
2016     sigc::visit_each(_A_action, _A_target.bound6_);
2017   }
2018 };
2019
2020 /** Adaptor that binds 7 argument(s) to the wrapped functor.
2021  * This template specialization fixes the last 7 argument(s) of the wrapped functor.
2022  *
2023  * @ingroup bind
2024  */
2025 template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7>
2026 struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> : public adapts<T_functor>
2027 {
2028   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
2029
2030   template <int count, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
2031   struct deduce_result_type_internal
2032     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>, type_trait_pass_t<typename unwrap_reference<T_type7>::type>>::type type; };
2033
2034   template <class T_arg1=void, class T_arg2=void, class T_arg3=void, class T_arg4=void, class T_arg5=void, class T_arg6=void, class T_arg7=void>
2035   struct deduce_result_type {
2036     typedef typename deduce_result_type_internal<internal::count_void<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::value,
2037                                                  T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type type;
2038   };
2039   typedef typename adaptor_type::result_type  result_type;
2040
2041   /** Invokes the wrapped functor passing on the bound argument only.
2042    * @return The return value of the functor invocation.
2043    */
2044   result_type
2045   operator()()
2046   {
2047     //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
2048     return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_pass_t<typename unwrap_reference<T_type1>::type>, type_trait_pass_t<typename unwrap_reference<T_type2>::type>, type_trait_pass_t<typename unwrap_reference<T_type3>::type>, type_trait_pass_t<typename unwrap_reference<T_type4>::type>, type_trait_pass_t<typename unwrap_reference<T_type5>::type>, type_trait_pass_t<typename unwrap_reference<T_type6>::type>, type_trait_pass_t<typename unwrap_reference<T_type7>::type>> (bound1_.invoke(), bound2_.invoke(), bound3_.invoke(), bound4_.invoke(), bound5_.invoke(), bound6_.invoke(), bound7_.invoke());
2049   }
2050
2051   /** Constructs a bind_functor object that binds an argument to the passed functor.
2052    * @param _A_func Functor to invoke from operator()().
2053    * @param _A_bound1 Argument to bind to the functor.
2054    * @param _A_bound2 Argument to bind to the functor.
2055    * @param _A_bound3 Argument to bind to the functor.
2056    * @param _A_bound4 Argument to bind to the functor.
2057    * @param _A_bound5 Argument to bind to the functor.
2058    * @param _A_bound6 Argument to bind to the functor.
2059    * @param _A_bound7 Argument to bind to the functor.
2060    */
2061   bind_functor(type_trait_take_t<T_functor> _A_func, type_trait_take_t<T_type1> _A_bound1, type_trait_take_t<T_type2> _A_bound2, type_trait_take_t<T_type3> _A_bound3, type_trait_take_t<T_type4> _A_bound4, type_trait_take_t<T_type5> _A_bound5, type_trait_take_t<T_type6> _A_bound6, type_trait_take_t<T_type7> _A_bound7)
2062     : adapts<T_functor>(_A_func), bound1_(_A_bound1), bound2_(_A_bound2), bound3_(_A_bound3), bound4_(_A_bound4), bound5_(_A_bound5), bound6_(_A_bound6), bound7_(_A_bound7)
2063     {}
2064
2065   /// The argument bound to the functor.
2066   bound_argument<T_type1> bound1_;
2067   bound_argument<T_type2> bound2_;
2068   bound_argument<T_type3> bound3_;
2069   bound_argument<T_type4> bound4_;
2070   bound_argument<T_type5> bound5_;
2071   bound_argument<T_type6> bound6_;
2072   bound_argument<T_type7> bound7_;
2073 };
2074
2075 //template specialization of visitor<>::do_visit_each<>(action, functor):
2076 /** Performs a functor on each of the targets of a functor.
2077  * The function overload for sigc::bind_functor performs a functor on the
2078  * functor and on the object instances stored in the sigc::bind_functor object.
2079  *
2080  * @ingroup bind
2081  */
2082 template <class T_functor, class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7>
2083 struct visitor<bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >
2084 {
2085   template <typename T_action>
2086   static void do_visit_each(const T_action& _A_action,
2087                             const bind_functor<-1, T_functor,  T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>& _A_target)
2088   {
2089     sigc::visit_each(_A_action, _A_target.functor_);
2090     sigc::visit_each(_A_action, _A_target.bound1_);
2091     sigc::visit_each(_A_action, _A_target.bound2_);
2092     sigc::visit_each(_A_action, _A_target.bound3_);
2093     sigc::visit_each(_A_action, _A_target.bound4_);
2094     sigc::visit_each(_A_action, _A_target.bound5_);
2095     sigc::visit_each(_A_action, _A_target.bound6_);
2096     sigc::visit_each(_A_action, _A_target.bound7_);
2097   }
2098 };
2099 #endif // DOXYGEN_SHOULD_SKIP_THIS
2100
2101
2102 /** Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.
2103  * The optional template argument @e I_location specifies the zero-based
2104  * position of the argument to be fixed (@p -1 stands for the last argument).
2105  *
2106  * @param _A_func Functor that should be wrapped.
2107  * @param _A_b1 Argument to bind to @e _A_func.
2108  * @return Adaptor that executes @e _A_func with the bound argument on invokation.
2109  *
2110  * @ingroup bind
2111  */
2112 template <int I_location, class T_bound1, class T_functor>
2113 inline bind_functor<I_location, T_functor, T_bound1>
2114 bind(const T_functor& _A_func, T_bound1 _A_b1)
2115 {
2116   return bind_functor<I_location, T_functor, T_bound1>
2117            (_A_func, _A_b1);
2118 }
2119
2120 /** Creates an adaptor of type sigc::bind_functor which fixes the last 1 argument(s) of the passed functor.
2121  * This function overload fixes the last 1 argument(s) of @e _A_func.
2122  *
2123  * @param _A_func Functor that should be wrapped.
2124  * @param _A_b1 Argument to bind to @e _A_func.
2125  * @return Adaptor that executes _A_func with the bound argument on invokation.
2126  *
2127  * @ingroup bind
2128  */
2129 template <class T_type1, class T_functor>
2130 inline bind_functor<-1, T_functor,
2131                     T_type1>
2132 bind(const T_functor& _A_func, T_type1 _A_b1)
2133 { return bind_functor<-1, T_functor,
2134                     T_type1>
2135                     (_A_func, _A_b1);
2136 }
2137
2138 /** Creates an adaptor of type sigc::bind_functor which fixes the last 2 argument(s) of the passed functor.
2139  * This function overload fixes the last 2 argument(s) of @e _A_func.
2140  *
2141  * @param _A_func Functor that should be wrapped.
2142  * @param _A_b1 Argument to bind to @e _A_func.
2143  * @param _A_b2 Argument to bind to @e _A_func.
2144  * @return Adaptor that executes _A_func with the bound argument on invokation.
2145  *
2146  * @ingroup bind
2147  */
2148 template <class T_type1, class T_type2, class T_functor>
2149 inline bind_functor<-1, T_functor,
2150                     T_type1,
2151                     T_type2>
2152 bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2)
2153 { return bind_functor<-1, T_functor,
2154                     T_type1,
2155                     T_type2>
2156                     (_A_func, _A_b1, _A_b2);
2157 }
2158
2159 /** Creates an adaptor of type sigc::bind_functor which fixes the last 3 argument(s) of the passed functor.
2160  * This function overload fixes the last 3 argument(s) of @e _A_func.
2161  *
2162  * @param _A_func Functor that should be wrapped.
2163  * @param _A_b1 Argument to bind to @e _A_func.
2164  * @param _A_b2 Argument to bind to @e _A_func.
2165  * @param _A_b3 Argument to bind to @e _A_func.
2166  * @return Adaptor that executes _A_func with the bound argument on invokation.
2167  *
2168  * @ingroup bind
2169  */
2170 template <class T_type1, class T_type2, class T_type3, class T_functor>
2171 inline bind_functor<-1, T_functor,
2172                     T_type1,
2173                     T_type2,
2174                     T_type3>
2175 bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3)
2176 { return bind_functor<-1, T_functor,
2177                     T_type1,
2178                     T_type2,
2179                     T_type3>
2180                     (_A_func, _A_b1, _A_b2, _A_b3);
2181 }
2182
2183 /** Creates an adaptor of type sigc::bind_functor which fixes the last 4 argument(s) of the passed functor.
2184  * This function overload fixes the last 4 argument(s) of @e _A_func.
2185  *
2186  * @param _A_func Functor that should be wrapped.
2187  * @param _A_b1 Argument to bind to @e _A_func.
2188  * @param _A_b2 Argument to bind to @e _A_func.
2189  * @param _A_b3 Argument to bind to @e _A_func.
2190  * @param _A_b4 Argument to bind to @e _A_func.
2191  * @return Adaptor that executes _A_func with the bound argument on invokation.
2192  *
2193  * @ingroup bind
2194  */
2195 template <class T_type1, class T_type2, class T_type3, class T_type4, class T_functor>
2196 inline bind_functor<-1, T_functor,
2197                     T_type1,
2198                     T_type2,
2199                     T_type3,
2200                     T_type4>
2201 bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4)
2202 { return bind_functor<-1, T_functor,
2203                     T_type1,
2204                     T_type2,
2205                     T_type3,
2206                     T_type4>
2207                     (_A_func, _A_b1, _A_b2, _A_b3, _A_b4);
2208 }
2209
2210 /** Creates an adaptor of type sigc::bind_functor which fixes the last 5 argument(s) of the passed functor.
2211  * This function overload fixes the last 5 argument(s) of @e _A_func.
2212  *
2213  * @param _A_func Functor that should be wrapped.
2214  * @param _A_b1 Argument to bind to @e _A_func.
2215  * @param _A_b2 Argument to bind to @e _A_func.
2216  * @param _A_b3 Argument to bind to @e _A_func.
2217  * @param _A_b4 Argument to bind to @e _A_func.
2218  * @param _A_b5 Argument to bind to @e _A_func.
2219  * @return Adaptor that executes _A_func with the bound argument on invokation.
2220  *
2221  * @ingroup bind
2222  */
2223 template <class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_functor>
2224 inline bind_functor<-1, T_functor,
2225                     T_type1,
2226                     T_type2,
2227                     T_type3,
2228                     T_type4,
2229                     T_type5>
2230 bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5)
2231 { return bind_functor<-1, T_functor,
2232                     T_type1,
2233                     T_type2,
2234                     T_type3,
2235                     T_type4,
2236                     T_type5>
2237                     (_A_func, _A_b1, _A_b2, _A_b3, _A_b4, _A_b5);
2238 }
2239
2240 /** Creates an adaptor of type sigc::bind_functor which fixes the last 6 argument(s) of the passed functor.
2241  * This function overload fixes the last 6 argument(s) of @e _A_func.
2242  *
2243  * @param _A_func Functor that should be wrapped.
2244  * @param _A_b1 Argument to bind to @e _A_func.
2245  * @param _A_b2 Argument to bind to @e _A_func.
2246  * @param _A_b3 Argument to bind to @e _A_func.
2247  * @param _A_b4 Argument to bind to @e _A_func.
2248  * @param _A_b5 Argument to bind to @e _A_func.
2249  * @param _A_b6 Argument to bind to @e _A_func.
2250  * @return Adaptor that executes _A_func with the bound argument on invokation.
2251  *
2252  * @ingroup bind
2253  */
2254 template <class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_functor>
2255 inline bind_functor<-1, T_functor,
2256                     T_type1,
2257                     T_type2,
2258                     T_type3,
2259                     T_type4,
2260                     T_type5,
2261                     T_type6>
2262 bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6)
2263 { return bind_functor<-1, T_functor,
2264                     T_type1,
2265                     T_type2,
2266                     T_type3,
2267                     T_type4,
2268                     T_type5,
2269                     T_type6>
2270                     (_A_func, _A_b1, _A_b2, _A_b3, _A_b4, _A_b5, _A_b6);
2271 }
2272
2273 /** Creates an adaptor of type sigc::bind_functor which fixes the last 7 argument(s) of the passed functor.
2274  * This function overload fixes the last 7 argument(s) of @e _A_func.
2275  *
2276  * @param _A_func Functor that should be wrapped.
2277  * @param _A_b1 Argument to bind to @e _A_func.
2278  * @param _A_b2 Argument to bind to @e _A_func.
2279  * @param _A_b3 Argument to bind to @e _A_func.
2280  * @param _A_b4 Argument to bind to @e _A_func.
2281  * @param _A_b5 Argument to bind to @e _A_func.
2282  * @param _A_b6 Argument to bind to @e _A_func.
2283  * @param _A_b7 Argument to bind to @e _A_func.
2284  * @return Adaptor that executes _A_func with the bound argument on invokation.
2285  *
2286  * @ingroup bind
2287  */
2288 template <class T_type1, class T_type2, class T_type3, class T_type4, class T_type5, class T_type6, class T_type7, class T_functor>
2289 inline bind_functor<-1, T_functor,
2290                     T_type1,
2291                     T_type2,
2292                     T_type3,
2293                     T_type4,
2294                     T_type5,
2295                     T_type6,
2296                     T_type7>
2297 bind(const T_functor& _A_func, T_type1 _A_b1, T_type2 _A_b2, T_type3 _A_b3, T_type4 _A_b4, T_type5 _A_b5, T_type6 _A_b6, T_type7 _A_b7)
2298 { return bind_functor<-1, T_functor,
2299                     T_type1,
2300                     T_type2,
2301                     T_type3,
2302                     T_type4,
2303                     T_type5,
2304                     T_type6,
2305                     T_type7>
2306                     (_A_func, _A_b1, _A_b2, _A_b3, _A_b4, _A_b5, _A_b6, _A_b7);
2307 }
2308
2309
2310 } /* namespace sigc */
2311
2312 #ifdef SIGC_NIL_HAS_BEEN_PUSHED
2313   #undef SIGC_NIL_HAS_BEEN_PUSHED
2314   #pragma pop_macro("nil")
2315 #endif
2316 #endif /* _SIGC_ADAPTORS_BIND_H_ */