libs/sigc++2/sigc++/adaptors/retype.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_ADAPTORS_MACROS_RETYPEHM4_
   4 #define _SIGC_ADAPTORS_MACROS_RETYPEHM4_
   5 #include <sigc++/adaptors/adaptor_trait.h>
   6 #include <sigc++/functors/ptr_fun.h>
   7 #include <sigc++/functors/mem_fun.h>
   8 #include <sigc++/functors/slot.h>
   9
  10 namespace sigc {
  11
  12 /** @defgroup retype retype(), retype_return()
  13  * sigc::retype() alters a sigc::pointer_functor, a sigc::mem_functor or a sigc::slot
  14  * in that it makes C-style casts to the functor's parameter types
  15  * of all parameters passed through operator()().
  16  *
  17  * Use this adaptor for inline conversion between numeric or other simple types.
  18  * @par Example:
  19  *   @code
  20  *   void foo(int);
  21  *   sigc::retype(sigc::ptr_fun(&foo))(5.7F); // calls foo(5)
  22  *   @endcode
  23  *
  24  * The functor sigc::retype() returns can be passed into
  25  * sigc::signal::connect() directly.
  26  *
  27  * @par Example:
  28  *   @code
  29  *   sigc::signal<void,float> some_signal;
  30  *   void foo(int);
  31  *   some_signal.connect(sigc::retype(sigc::ptr_fun(&foo)));
  32  *   @endcode
  33  *
  34  * This adaptor builds an exception in that it only works on sig::pointer_functor,
  35  * sigc::mem_functor and sigc::slot because it needs sophisticated information about
  36  * the parameter types that cannot be deduced from arbitrary functor types.
  37  *
  38  * sigc::retype_return() alters the return type of an arbitrary functor.
  39  * Like in sigc::retype() a C-style cast is preformed. Usage sigc::retype_return() is
  40  * not restricted to libsigc++ functor types but you need to
  41  * specify the new return type as a template parameter.
  42  *
  43  * @par Example:
  44  *   @code
  45  *   float foo();
  46  *   std::cout << sigc::retype_return<int>(&foo)(); // converts foo's return value to an integer
  47  *   @endcode
  48  *
  49  * @ingroup adaptors
  50  */
  51
  52 /** Adaptor that performs C-style casts on the parameters passed on to the functor.
  53  * Use the convenience function sigc::retype() to create an instance of retype_functor.
  54  *
  55  * The following template arguments are used:
  56  * - @e T_functor Type of the functor to wrap.
  57  * - @e T_type1 Type of @e T_functor's 1th argument.
  58  * - @e T_type2 Type of @e T_functor's 2th argument.
  59  * - @e T_type3 Type of @e T_functor's 3th argument.
  60  * - @e T_type4 Type of @e T_functor's 4th argument.
  61  * - @e T_type5 Type of @e T_functor's 5th argument.
  62  * - @e T_type6 Type of @e T_functor's 6th argument.
  63  * - @e T_type7 Type of @e T_functor's 7th argument.
  64  *
  65  * @ingroup retype
  66  */
  67 template <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>
  68 struct retype_functor
  69   : public adapts<T_functor>
  70 {
  71   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
  72
  73   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>
  74   struct deduce_result_type
  75     { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type type; };
  76   typedef typename adapts<T_functor>::result_type result_type;
  77
  78   result_type operator()();
  79
  80   template <class T_arg1>
  81   typename deduce_result_type<T_arg1>::type
  82   operator()(T_arg1 _A_a1)
  83     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
  84         ((T_type1)_A_a1);
  85     }
  86
  87   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  88   template <class T_arg1>
  89   typename deduce_result_type<T_arg1>::type
  90   sun_forte_workaround(T_arg1 _A_a1)
  91     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
  92         ((T_type1)_A_a1);
  93     }
  94   #endif
  95
  96   template <class T_arg1,class T_arg2>
  97   typename deduce_result_type<T_arg1,T_arg2>::type
  98   operator()(T_arg1 _A_a1,T_arg2 _A_a2)
  99     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
 100         ((T_type1)_A_a1,(T_type2)_A_a2);
 101     }
 102
 103   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 104   template <class T_arg1,class T_arg2>
 105   typename deduce_result_type<T_arg1,T_arg2>::type
 106   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
 107     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
 108         ((T_type1)_A_a1,(T_type2)_A_a2);
 109     }
 110   #endif
 111
 112   template <class T_arg1,class T_arg2,class T_arg3>
 113   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
 114   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
 115     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
 116         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
 117     }
 118
 119   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 120   template <class T_arg1,class T_arg2,class T_arg3>
 121   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
 122   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
 123     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
 124         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
 125     }
 126   #endif
 127
 128   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 129   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
 130   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
 131     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
 132         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
 133     }
 134
 135   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 136   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 137   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
 138   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
 139     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
 140         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
 141     }
 142   #endif
 143
 144   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 145   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
 146   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
 147     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take>
 148         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5);
 149     }
 150
 151   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 152   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 153   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
 154   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
 155     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take>
 156         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5);
 157     }
 158   #endif
 159
 160   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 161   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
 162   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
 163     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take>
 164         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6);
 165     }
 166
 167   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 168   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 169   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
 170   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
 171     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take>
 172         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6);
 173     }
 174   #endif
 175
 176   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 177   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
 178   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
 179     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename type_trait<T_type7>::take>
 180         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7);
 181     }
 182
 183   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 184   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 185   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
 186   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
 187     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename type_trait<T_type7>::take>
 188         ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7);
 189     }
 190   #endif
 191
 192
 193   /** Constructs a retype_functor object that performs C-style casts on the parameters passed on to the functor.
 194    * @param _A_functor Functor to invoke from operator()().
 195    */
 196   explicit retype_functor(typename type_trait<T_functor>::take _A_functor)
 197     : adapts<T_functor>(_A_functor)
 198     {}
 199 };
 200
 201 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>
 202 typename retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::result_type
 203 retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
 204   { return this->functor_(); }
 205
 206
 207 /** Performs a functor on each of the targets of a functor.
 208  * The function overload for sigc::retype_functor performs a functor on the
 209  * functor stored in the sigc::retype_functor object.
 210  *
 211  * @ingroup retype
 212  */
 213 template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
 214 void visit_each(const T_action& _A_action,
 215                 const retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>& _A_target)
 216 {
 217   visit_each(_A_action, _A_target.functor_);
 218 }
 219
 220
 221 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 222  * This function template specialization works on sigc::slot.
 223  *
 224  * @param _A_functor Functor that should be wrapped.
 225  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 226  *
 227  * @ingroup retype
 228  */
 229 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 230 inline retype_functor<slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 231 retype(const slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
 232 { return retype_functor<slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 233     (_A_functor); }
 234
 235
 236 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 237  * This function template specialization works on sigc::pointer_functor.
 238  *
 239  * @param _A_functor Functor that should be wrapped.
 240  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 241  *
 242  * @ingroup retype
 243  */
 244 template <class T_return>
 245 inline retype_functor<pointer_functor0<T_return> >
 246 retype(const pointer_functor0<T_return>& _A_functor)
 247 { return retype_functor<pointer_functor0<T_return> >
 248     (_A_functor); }
 249
 250 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 251  * This function template specialization works on sigc::pointer_functor.
 252  *
 253  * @param _A_functor Functor that should be wrapped.
 254  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 255  *
 256  * @ingroup retype
 257  */
 258 template <class T_arg1, class T_return>
 259 inline retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
 260 retype(const pointer_functor1<T_arg1, T_return>& _A_functor)
 261 { return retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
 262     (_A_functor); }
 263
 264 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 265  * This function template specialization works on sigc::pointer_functor.
 266  *
 267  * @param _A_functor Functor that should be wrapped.
 268  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 269  *
 270  * @ingroup retype
 271  */
 272 template <class T_arg1,class T_arg2, class T_return>
 273 inline retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1,T_arg2 >
 274 retype(const pointer_functor2<T_arg1,T_arg2, T_return>& _A_functor)
 275 { return retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1,T_arg2 >
 276     (_A_functor); }
 277
 278 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 279  * This function template specialization works on sigc::pointer_functor.
 280  *
 281  * @param _A_functor Functor that should be wrapped.
 282  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 283  *
 284  * @ingroup retype
 285  */
 286 template <class T_arg1,class T_arg2,class T_arg3, class T_return>
 287 inline retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1,T_arg2,T_arg3 >
 288 retype(const pointer_functor3<T_arg1,T_arg2,T_arg3, T_return>& _A_functor)
 289 { return retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1,T_arg2,T_arg3 >
 290     (_A_functor); }
 291
 292 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 293  * This function template specialization works on sigc::pointer_functor.
 294  *
 295  * @param _A_functor Functor that should be wrapped.
 296  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 297  *
 298  * @ingroup retype
 299  */
 300 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_return>
 301 inline retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1,T_arg2,T_arg3,T_arg4 >
 302 retype(const pointer_functor4<T_arg1,T_arg2,T_arg3,T_arg4, T_return>& _A_functor)
 303 { return retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1,T_arg2,T_arg3,T_arg4 >
 304     (_A_functor); }
 305
 306 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 307  * This function template specialization works on sigc::pointer_functor.
 308  *
 309  * @param _A_functor Functor that should be wrapped.
 310  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 311  *
 312  * @ingroup retype
 313  */
 314 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_return>
 315 inline retype_functor<pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 316 retype(const pointer_functor5<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_return>& _A_functor)
 317 { return retype_functor<pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 318     (_A_functor); }
 319
 320 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 321  * This function template specialization works on sigc::pointer_functor.
 322  *
 323  * @param _A_functor Functor that should be wrapped.
 324  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 325  *
 326  * @ingroup retype
 327  */
 328 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_return>
 329 inline retype_functor<pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 330 retype(const pointer_functor6<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_return>& _A_functor)
 331 { return retype_functor<pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 332     (_A_functor); }
 333
 334 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 335  * This function template specialization works on sigc::pointer_functor.
 336  *
 337  * @param _A_functor Functor that should be wrapped.
 338  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 339  *
 340  * @ingroup retype
 341  */
 342 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7, class T_return>
 343 inline retype_functor<pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 344 retype(const pointer_functor7<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_return>& _A_functor)
 345 { return retype_functor<pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 346     (_A_functor); }
 347
 348
 349 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 350  * This function template specialization works on sigc::mem_functor.
 351  *
 352  * @param _A_functor Functor that should be wrapped.
 353  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 354  *
 355  * @ingroup retype
 356  */
 357 template <class T_return, class T_obj>
 358 inline retype_functor<mem_functor0<T_return, T_obj> >
 359 retype(const mem_functor0<T_return, T_obj>& _A_functor)
 360 { return retype_functor<mem_functor0<T_return, T_obj> >
 361     (_A_functor); }
 362
 363 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 364  * This function template specialization works on sigc::mem_functor.
 365  *
 366  * @param _A_functor Functor that should be wrapped.
 367  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 368  *
 369  * @ingroup retype
 370  */
 371 template <class T_return, class T_obj, class T_arg1>
 372 inline retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 373 retype(const mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 374 { return retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 375     (_A_functor); }
 376
 377 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 378  * This function template specialization works on sigc::mem_functor.
 379  *
 380  * @param _A_functor Functor that should be wrapped.
 381  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 382  *
 383  * @ingroup retype
 384  */
 385 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 386 inline retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 387 retype(const mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 388 { return retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 389     (_A_functor); }
 390
 391 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 392  * This function template specialization works on sigc::mem_functor.
 393  *
 394  * @param _A_functor Functor that should be wrapped.
 395  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 396  *
 397  * @ingroup retype
 398  */
 399 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 400 inline retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 401 retype(const mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 402 { return retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 403     (_A_functor); }
 404
 405 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 406  * This function template specialization works on sigc::mem_functor.
 407  *
 408  * @param _A_functor Functor that should be wrapped.
 409  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 410  *
 411  * @ingroup retype
 412  */
 413 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 414 inline retype_functor<mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 415 retype(const mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 416 { return retype_functor<mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 417     (_A_functor); }
 418
 419 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 420  * This function template specialization works on sigc::mem_functor.
 421  *
 422  * @param _A_functor Functor that should be wrapped.
 423  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 424  *
 425  * @ingroup retype
 426  */
 427 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 428 inline retype_functor<mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 429 retype(const mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 430 { return retype_functor<mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 431     (_A_functor); }
 432
 433 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 434  * This function template specialization works on sigc::mem_functor.
 435  *
 436  * @param _A_functor Functor that should be wrapped.
 437  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 438  *
 439  * @ingroup retype
 440  */
 441 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 442 inline retype_functor<mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 443 retype(const mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 444 { return retype_functor<mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 445     (_A_functor); }
 446
 447 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 448  * This function template specialization works on sigc::mem_functor.
 449  *
 450  * @param _A_functor Functor that should be wrapped.
 451  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 452  *
 453  * @ingroup retype
 454  */
 455 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 456 inline retype_functor<mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 457 retype(const mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
 458 { return retype_functor<mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 459     (_A_functor); }
 460
 461 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 462  * This function template specialization works on sigc::const_mem_functor.
 463  *
 464  * @param _A_functor Functor that should be wrapped.
 465  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 466  *
 467  * @ingroup retype
 468  */
 469 template <class T_return, class T_obj>
 470 inline retype_functor<const_mem_functor0<T_return, T_obj> >
 471 retype(const const_mem_functor0<T_return, T_obj>& _A_functor)
 472 { return retype_functor<const_mem_functor0<T_return, T_obj> >
 473     (_A_functor); }
 474
 475 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 476  * This function template specialization works on sigc::const_mem_functor.
 477  *
 478  * @param _A_functor Functor that should be wrapped.
 479  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 480  *
 481  * @ingroup retype
 482  */
 483 template <class T_return, class T_obj, class T_arg1>
 484 inline retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 485 retype(const const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 486 { return retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 487     (_A_functor); }
 488
 489 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 490  * This function template specialization works on sigc::const_mem_functor.
 491  *
 492  * @param _A_functor Functor that should be wrapped.
 493  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 494  *
 495  * @ingroup retype
 496  */
 497 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 498 inline retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 499 retype(const const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 500 { return retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 501     (_A_functor); }
 502
 503 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 504  * This function template specialization works on sigc::const_mem_functor.
 505  *
 506  * @param _A_functor Functor that should be wrapped.
 507  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 508  *
 509  * @ingroup retype
 510  */
 511 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 512 inline retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 513 retype(const const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 514 { return retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 515     (_A_functor); }
 516
 517 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 518  * This function template specialization works on sigc::const_mem_functor.
 519  *
 520  * @param _A_functor Functor that should be wrapped.
 521  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 522  *
 523  * @ingroup retype
 524  */
 525 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 526 inline retype_functor<const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 527 retype(const const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 528 { return retype_functor<const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 529     (_A_functor); }
 530
 531 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 532  * This function template specialization works on sigc::const_mem_functor.
 533  *
 534  * @param _A_functor Functor that should be wrapped.
 535  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 536  *
 537  * @ingroup retype
 538  */
 539 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 540 inline retype_functor<const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 541 retype(const const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 542 { return retype_functor<const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 543     (_A_functor); }
 544
 545 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 546  * This function template specialization works on sigc::const_mem_functor.
 547  *
 548  * @param _A_functor Functor that should be wrapped.
 549  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 550  *
 551  * @ingroup retype
 552  */
 553 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 554 inline retype_functor<const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 555 retype(const const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 556 { return retype_functor<const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 557     (_A_functor); }
 558
 559 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 560  * This function template specialization works on sigc::const_mem_functor.
 561  *
 562  * @param _A_functor Functor that should be wrapped.
 563  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 564  *
 565  * @ingroup retype
 566  */
 567 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 568 inline retype_functor<const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 569 retype(const const_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
 570 { return retype_functor<const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 571     (_A_functor); }
 572
 573 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 574  * This function template specialization works on sigc::volatile_mem_functor.
 575  *
 576  * @param _A_functor Functor that should be wrapped.
 577  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 578  *
 579  * @ingroup retype
 580  */
 581 template <class T_return, class T_obj>
 582 inline retype_functor<volatile_mem_functor0<T_return, T_obj> >
 583 retype(const volatile_mem_functor0<T_return, T_obj>& _A_functor)
 584 { return retype_functor<volatile_mem_functor0<T_return, T_obj> >
 585     (_A_functor); }
 586
 587 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 588  * This function template specialization works on sigc::volatile_mem_functor.
 589  *
 590  * @param _A_functor Functor that should be wrapped.
 591  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 592  *
 593  * @ingroup retype
 594  */
 595 template <class T_return, class T_obj, class T_arg1>
 596 inline retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 597 retype(const volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 598 { return retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 599     (_A_functor); }
 600
 601 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 602  * This function template specialization works on sigc::volatile_mem_functor.
 603  *
 604  * @param _A_functor Functor that should be wrapped.
 605  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 606  *
 607  * @ingroup retype
 608  */
 609 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 610 inline retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 611 retype(const volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 612 { return retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 613     (_A_functor); }
 614
 615 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 616  * This function template specialization works on sigc::volatile_mem_functor.
 617  *
 618  * @param _A_functor Functor that should be wrapped.
 619  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 620  *
 621  * @ingroup retype
 622  */
 623 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 624 inline retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 625 retype(const volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 626 { return retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 627     (_A_functor); }
 628
 629 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 630  * This function template specialization works on sigc::volatile_mem_functor.
 631  *
 632  * @param _A_functor Functor that should be wrapped.
 633  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 634  *
 635  * @ingroup retype
 636  */
 637 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 638 inline retype_functor<volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 639 retype(const volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 640 { return retype_functor<volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 641     (_A_functor); }
 642
 643 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 644  * This function template specialization works on sigc::volatile_mem_functor.
 645  *
 646  * @param _A_functor Functor that should be wrapped.
 647  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 648  *
 649  * @ingroup retype
 650  */
 651 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 652 inline retype_functor<volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 653 retype(const volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 654 { return retype_functor<volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 655     (_A_functor); }
 656
 657 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 658  * This function template specialization works on sigc::volatile_mem_functor.
 659  *
 660  * @param _A_functor Functor that should be wrapped.
 661  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 662  *
 663  * @ingroup retype
 664  */
 665 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 666 inline retype_functor<volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 667 retype(const volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 668 { return retype_functor<volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 669     (_A_functor); }
 670
 671 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 672  * This function template specialization works on sigc::volatile_mem_functor.
 673  *
 674  * @param _A_functor Functor that should be wrapped.
 675  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 676  *
 677  * @ingroup retype
 678  */
 679 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 680 inline retype_functor<volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 681 retype(const volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
 682 { return retype_functor<volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 683     (_A_functor); }
 684
 685 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 686  * This function template specialization works on sigc::const_volatile_mem_functor.
 687  *
 688  * @param _A_functor Functor that should be wrapped.
 689  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 690  *
 691  * @ingroup retype
 692  */
 693 template <class T_return, class T_obj>
 694 inline retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
 695 retype(const const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
 696 { return retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
 697     (_A_functor); }
 698
 699 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 700  * This function template specialization works on sigc::const_volatile_mem_functor.
 701  *
 702  * @param _A_functor Functor that should be wrapped.
 703  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 704  *
 705  * @ingroup retype
 706  */
 707 template <class T_return, class T_obj, class T_arg1>
 708 inline retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 709 retype(const const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 710 { return retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 711     (_A_functor); }
 712
 713 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 714  * This function template specialization works on sigc::const_volatile_mem_functor.
 715  *
 716  * @param _A_functor Functor that should be wrapped.
 717  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 718  *
 719  * @ingroup retype
 720  */
 721 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 722 inline retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 723 retype(const const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 724 { return retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 725     (_A_functor); }
 726
 727 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 728  * This function template specialization works on sigc::const_volatile_mem_functor.
 729  *
 730  * @param _A_functor Functor that should be wrapped.
 731  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 732  *
 733  * @ingroup retype
 734  */
 735 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 736 inline retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 737 retype(const const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 738 { return retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 739     (_A_functor); }
 740
 741 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 742  * This function template specialization works on sigc::const_volatile_mem_functor.
 743  *
 744  * @param _A_functor Functor that should be wrapped.
 745  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 746  *
 747  * @ingroup retype
 748  */
 749 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 750 inline retype_functor<const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 751 retype(const const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 752 { return retype_functor<const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 753     (_A_functor); }
 754
 755 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 756  * This function template specialization works on sigc::const_volatile_mem_functor.
 757  *
 758  * @param _A_functor Functor that should be wrapped.
 759  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 760  *
 761  * @ingroup retype
 762  */
 763 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 764 inline retype_functor<const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 765 retype(const const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 766 { return retype_functor<const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 767     (_A_functor); }
 768
 769 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 770  * This function template specialization works on sigc::const_volatile_mem_functor.
 771  *
 772  * @param _A_functor Functor that should be wrapped.
 773  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 774  *
 775  * @ingroup retype
 776  */
 777 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 778 inline retype_functor<const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 779 retype(const const_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 780 { return retype_functor<const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 781     (_A_functor); }
 782
 783 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 784  * This function template specialization works on sigc::const_volatile_mem_functor.
 785  *
 786  * @param _A_functor Functor that should be wrapped.
 787  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 788  *
 789  * @ingroup retype
 790  */
 791 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 792 inline retype_functor<const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 793 retype(const const_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
 794 { return retype_functor<const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 795     (_A_functor); }
 796
 797 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 798  * This function template specialization works on sigc::bound_mem_functor.
 799  *
 800  * @param _A_functor Functor that should be wrapped.
 801  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 802  *
 803  * @ingroup retype
 804  */
 805 template <class T_return, class T_obj>
 806 inline retype_functor<bound_mem_functor0<T_return, T_obj> >
 807 retype(const bound_mem_functor0<T_return, T_obj>& _A_functor)
 808 { return retype_functor<bound_mem_functor0<T_return, T_obj> >
 809     (_A_functor); }
 810
 811 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 812  * This function template specialization works on sigc::bound_mem_functor.
 813  *
 814  * @param _A_functor Functor that should be wrapped.
 815  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 816  *
 817  * @ingroup retype
 818  */
 819 template <class T_return, class T_obj, class T_arg1>
 820 inline retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 821 retype(const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 822 { return retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 823     (_A_functor); }
 824
 825 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 826  * This function template specialization works on sigc::bound_mem_functor.
 827  *
 828  * @param _A_functor Functor that should be wrapped.
 829  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 830  *
 831  * @ingroup retype
 832  */
 833 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 834 inline retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 835 retype(const bound_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 836 { return retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 837     (_A_functor); }
 838
 839 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 840  * This function template specialization works on sigc::bound_mem_functor.
 841  *
 842  * @param _A_functor Functor that should be wrapped.
 843  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 844  *
 845  * @ingroup retype
 846  */
 847 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 848 inline retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 849 retype(const bound_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 850 { return retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 851     (_A_functor); }
 852
 853 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 854  * This function template specialization works on sigc::bound_mem_functor.
 855  *
 856  * @param _A_functor Functor that should be wrapped.
 857  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 858  *
 859  * @ingroup retype
 860  */
 861 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 862 inline retype_functor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 863 retype(const bound_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 864 { return retype_functor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 865     (_A_functor); }
 866
 867 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 868  * This function template specialization works on sigc::bound_mem_functor.
 869  *
 870  * @param _A_functor Functor that should be wrapped.
 871  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 872  *
 873  * @ingroup retype
 874  */
 875 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 876 inline retype_functor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 877 retype(const bound_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 878 { return retype_functor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 879     (_A_functor); }
 880
 881 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 882  * This function template specialization works on sigc::bound_mem_functor.
 883  *
 884  * @param _A_functor Functor that should be wrapped.
 885  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 886  *
 887  * @ingroup retype
 888  */
 889 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
 890 inline retype_functor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 891 retype(const bound_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 892 { return retype_functor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
 893     (_A_functor); }
 894
 895 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 896  * This function template specialization works on sigc::bound_mem_functor.
 897  *
 898  * @param _A_functor Functor that should be wrapped.
 899  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 900  *
 901  * @ingroup retype
 902  */
 903 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
 904 inline retype_functor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 905 retype(const bound_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
 906 { return retype_functor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
 907     (_A_functor); }
 908
 909 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 910  * This function template specialization works on sigc::bound_const_mem_functor.
 911  *
 912  * @param _A_functor Functor that should be wrapped.
 913  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 914  *
 915  * @ingroup retype
 916  */
 917 template <class T_return, class T_obj>
 918 inline retype_functor<bound_const_mem_functor0<T_return, T_obj> >
 919 retype(const bound_const_mem_functor0<T_return, T_obj>& _A_functor)
 920 { return retype_functor<bound_const_mem_functor0<T_return, T_obj> >
 921     (_A_functor); }
 922
 923 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 924  * This function template specialization works on sigc::bound_const_mem_functor.
 925  *
 926  * @param _A_functor Functor that should be wrapped.
 927  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 928  *
 929  * @ingroup retype
 930  */
 931 template <class T_return, class T_obj, class T_arg1>
 932 inline retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 933 retype(const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 934 { return retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 935     (_A_functor); }
 936
 937 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 938  * This function template specialization works on sigc::bound_const_mem_functor.
 939  *
 940  * @param _A_functor Functor that should be wrapped.
 941  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 942  *
 943  * @ingroup retype
 944  */
 945 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 946 inline retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 947 retype(const bound_const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 948 { return retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 949     (_A_functor); }
 950
 951 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 952  * This function template specialization works on sigc::bound_const_mem_functor.
 953  *
 954  * @param _A_functor Functor that should be wrapped.
 955  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 956  *
 957  * @ingroup retype
 958  */
 959 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 960 inline retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 961 retype(const bound_const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 962 { return retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 963     (_A_functor); }
 964
 965 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 966  * This function template specialization works on sigc::bound_const_mem_functor.
 967  *
 968  * @param _A_functor Functor that should be wrapped.
 969  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 970  *
 971  * @ingroup retype
 972  */
 973 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 974 inline retype_functor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 975 retype(const bound_const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 976 { return retype_functor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
 977     (_A_functor); }
 978
 979 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 980  * This function template specialization works on sigc::bound_const_mem_functor.
 981  *
 982  * @param _A_functor Functor that should be wrapped.
 983  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 984  *
 985  * @ingroup retype
 986  */
 987 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 988 inline retype_functor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 989 retype(const bound_const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 990 { return retype_functor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
 991     (_A_functor); }
 992
 993 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 994  * This function template specialization works on sigc::bound_const_mem_functor.
 995  *
 996  * @param _A_functor Functor that should be wrapped.
 997  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 998  *
 999  * @ingroup retype
1000  */
1001 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
1002 inline retype_functor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
1003 retype(const bound_const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
1004 { return retype_functor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
1005     (_A_functor); }
1006
1007 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1008  * This function template specialization works on sigc::bound_const_mem_functor.
1009  *
1010  * @param _A_functor Functor that should be wrapped.
1011  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1012  *
1013  * @ingroup retype
1014  */
1015 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
1016 inline retype_functor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
1017 retype(const bound_const_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
1018 { return retype_functor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
1019     (_A_functor); }
1020
1021 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1022  * This function template specialization works on sigc::bound_volatile_mem_functor.
1023  *
1024  * @param _A_functor Functor that should be wrapped.
1025  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1026  *
1027  * @ingroup retype
1028  */
1029 template <class T_return, class T_obj>
1030 inline retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
1031 retype(const bound_volatile_mem_functor0<T_return, T_obj>& _A_functor)
1032 { return retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
1033     (_A_functor); }
1034
1035 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1036  * This function template specialization works on sigc::bound_volatile_mem_functor.
1037  *
1038  * @param _A_functor Functor that should be wrapped.
1039  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1040  *
1041  * @ingroup retype
1042  */
1043 template <class T_return, class T_obj, class T_arg1>
1044 inline retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1045 retype(const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
1046 { return retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1047     (_A_functor); }
1048
1049 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1050  * This function template specialization works on sigc::bound_volatile_mem_functor.
1051  *
1052  * @param _A_functor Functor that should be wrapped.
1053  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1054  *
1055  * @ingroup retype
1056  */
1057 template <class T_return, class T_obj, class T_arg1,class T_arg2>
1058 inline retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
1059 retype(const bound_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
1060 { return retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
1061     (_A_functor); }
1062
1063 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1064  * This function template specialization works on sigc::bound_volatile_mem_functor.
1065  *
1066  * @param _A_functor Functor that should be wrapped.
1067  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1068  *
1069  * @ingroup retype
1070  */
1071 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
1072 inline retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
1073 retype(const bound_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
1074 { return retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
1075     (_A_functor); }
1076
1077 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1078  * This function template specialization works on sigc::bound_volatile_mem_functor.
1079  *
1080  * @param _A_functor Functor that should be wrapped.
1081  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1082  *
1083  * @ingroup retype
1084  */
1085 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
1086 inline retype_functor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
1087 retype(const bound_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
1088 { return retype_functor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
1089     (_A_functor); }
1090
1091 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1092  * This function template specialization works on sigc::bound_volatile_mem_functor.
1093  *
1094  * @param _A_functor Functor that should be wrapped.
1095  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1096  *
1097  * @ingroup retype
1098  */
1099 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
1100 inline retype_functor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
1101 retype(const bound_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
1102 { return retype_functor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
1103     (_A_functor); }
1104
1105 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1106  * This function template specialization works on sigc::bound_volatile_mem_functor.
1107  *
1108  * @param _A_functor Functor that should be wrapped.
1109  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1110  *
1111  * @ingroup retype
1112  */
1113 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
1114 inline retype_functor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
1115 retype(const bound_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
1116 { return retype_functor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
1117     (_A_functor); }
1118
1119 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1120  * This function template specialization works on sigc::bound_volatile_mem_functor.
1121  *
1122  * @param _A_functor Functor that should be wrapped.
1123  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1124  *
1125  * @ingroup retype
1126  */
1127 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
1128 inline retype_functor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
1129 retype(const bound_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
1130 { return retype_functor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
1131     (_A_functor); }
1132
1133 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1134  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1135  *
1136  * @param _A_functor Functor that should be wrapped.
1137  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1138  *
1139  * @ingroup retype
1140  */
1141 template <class T_return, class T_obj>
1142 inline retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
1143 retype(const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
1144 { return retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
1145     (_A_functor); }
1146
1147 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1148  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1149  *
1150  * @param _A_functor Functor that should be wrapped.
1151  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1152  *
1153  * @ingroup retype
1154  */
1155 template <class T_return, class T_obj, class T_arg1>
1156 inline retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1157 retype(const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
1158 { return retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1159     (_A_functor); }
1160
1161 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1162  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1163  *
1164  * @param _A_functor Functor that should be wrapped.
1165  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1166  *
1167  * @ingroup retype
1168  */
1169 template <class T_return, class T_obj, class T_arg1,class T_arg2>
1170 inline retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
1171 retype(const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
1172 { return retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
1173     (_A_functor); }
1174
1175 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1176  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1177  *
1178  * @param _A_functor Functor that should be wrapped.
1179  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1180  *
1181  * @ingroup retype
1182  */
1183 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
1184 inline retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
1185 retype(const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
1186 { return retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
1187     (_A_functor); }
1188
1189 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1190  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1191  *
1192  * @param _A_functor Functor that should be wrapped.
1193  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1194  *
1195  * @ingroup retype
1196  */
1197 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
1198 inline retype_functor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
1199 retype(const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
1200 { return retype_functor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
1201     (_A_functor); }
1202
1203 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1204  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1205  *
1206  * @param _A_functor Functor that should be wrapped.
1207  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1208  *
1209  * @ingroup retype
1210  */
1211 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
1212 inline retype_functor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
1213 retype(const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
1214 { return retype_functor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
1215     (_A_functor); }
1216
1217 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1218  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1219  *
1220  * @param _A_functor Functor that should be wrapped.
1221  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1222  *
1223  * @ingroup retype
1224  */
1225 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
1226 inline retype_functor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
1227 retype(const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
1228 { return retype_functor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
1229     (_A_functor); }
1230
1231 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1232  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1233  *
1234  * @param _A_functor Functor that should be wrapped.
1235  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1236  *
1237  * @ingroup retype
1238  */
1239 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
1240 inline retype_functor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
1241 retype(const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
1242 { return retype_functor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
1243     (_A_functor); }
1244
1245
1246 } /* namespace sigc */
1247 #endif /* _SIGC_ADAPTORS_MACROS_RETYPEHM4_ */