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         (static_cast<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         (static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<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         (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<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 //template specialization of visit_each<>(action, functor):
 208 /** Performs a functor on each of the targets of a functor.
 209  * The function overload for sigc::retype_functor performs a functor on the
 210  * functor stored in the sigc::retype_functor object.
 211  *
 212  * @ingroup retype
 213  */
 214 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>
 215 void visit_each(const T_action& _A_action,
 216                 const retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>& _A_target)
 217 {
 218   visit_each(_A_action, _A_target.functor_);
 219 }
 220
 221
 222 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 223  * This function template specialization works on sigc::slot.
 224  *
 225  * @param _A_functor Functor that should be wrapped.
 226  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 227  *
 228  * @ingroup retype
 229  */
 230 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>
 231 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 >
 232 retype(const slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
 233 { 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 >
 234     (_A_functor); }
 235
 236
 237 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 238  * This function template specialization works on sigc::pointer_functor.
 239  *
 240  * @param _A_functor Functor that should be wrapped.
 241  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 242  *
 243  * @ingroup retype
 244  */
 245 template <class T_return>
 246 inline retype_functor<pointer_functor0<T_return> >
 247 retype(const pointer_functor0<T_return>& _A_functor)
 248 { return retype_functor<pointer_functor0<T_return> >
 249     (_A_functor); }
 250
 251 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 252  * This function template specialization works on sigc::pointer_functor.
 253  *
 254  * @param _A_functor Functor that should be wrapped.
 255  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 256  *
 257  * @ingroup retype
 258  */
 259 template <class T_arg1, class T_return>
 260 inline retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
 261 retype(const pointer_functor1<T_arg1, T_return>& _A_functor)
 262 { return retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
 263     (_A_functor); }
 264
 265 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 266  * This function template specialization works on sigc::pointer_functor.
 267  *
 268  * @param _A_functor Functor that should be wrapped.
 269  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 270  *
 271  * @ingroup retype
 272  */
 273 template <class T_arg1,class T_arg2, class T_return>
 274 inline retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1,T_arg2 >
 275 retype(const pointer_functor2<T_arg1,T_arg2, T_return>& _A_functor)
 276 { return retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1,T_arg2 >
 277     (_A_functor); }
 278
 279 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 280  * This function template specialization works on sigc::pointer_functor.
 281  *
 282  * @param _A_functor Functor that should be wrapped.
 283  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 284  *
 285  * @ingroup retype
 286  */
 287 template <class T_arg1,class T_arg2,class T_arg3, class T_return>
 288 inline retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1,T_arg2,T_arg3 >
 289 retype(const pointer_functor3<T_arg1,T_arg2,T_arg3, T_return>& _A_functor)
 290 { return retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1,T_arg2,T_arg3 >
 291     (_A_functor); }
 292
 293 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 294  * This function template specialization works on sigc::pointer_functor.
 295  *
 296  * @param _A_functor Functor that should be wrapped.
 297  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 298  *
 299  * @ingroup retype
 300  */
 301 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_return>
 302 inline retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1,T_arg2,T_arg3,T_arg4 >
 303 retype(const pointer_functor4<T_arg1,T_arg2,T_arg3,T_arg4, T_return>& _A_functor)
 304 { return retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1,T_arg2,T_arg3,T_arg4 >
 305     (_A_functor); }
 306
 307 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 308  * This function template specialization works on sigc::pointer_functor.
 309  *
 310  * @param _A_functor Functor that should be wrapped.
 311  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 312  *
 313  * @ingroup retype
 314  */
 315 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_return>
 316 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 >
 317 retype(const pointer_functor5<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_return>& _A_functor)
 318 { 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 >
 319     (_A_functor); }
 320
 321 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 322  * This function template specialization works on sigc::pointer_functor.
 323  *
 324  * @param _A_functor Functor that should be wrapped.
 325  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 326  *
 327  * @ingroup retype
 328  */
 329 template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_return>
 330 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 >
 331 retype(const pointer_functor6<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_return>& _A_functor)
 332 { 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 >
 333     (_A_functor); }
 334
 335 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 336  * This function template specialization works on sigc::pointer_functor.
 337  *
 338  * @param _A_functor Functor that should be wrapped.
 339  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 340  *
 341  * @ingroup retype
 342  */
 343 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>
 344 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 >
 345 retype(const pointer_functor7<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_return>& _A_functor)
 346 { 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 >
 347     (_A_functor); }
 348
 349
 350 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 351  * This function template specialization works on sigc::mem_functor.
 352  *
 353  * @param _A_functor Functor that should be wrapped.
 354  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 355  *
 356  * @ingroup retype
 357  */
 358 template <class T_return, class T_obj>
 359 inline retype_functor<mem_functor0<T_return, T_obj> >
 360 retype(const mem_functor0<T_return, T_obj>& _A_functor)
 361 { return retype_functor<mem_functor0<T_return, T_obj> >
 362     (_A_functor); }
 363
 364 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 365  * This function template specialization works on sigc::mem_functor.
 366  *
 367  * @param _A_functor Functor that should be wrapped.
 368  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 369  *
 370  * @ingroup retype
 371  */
 372 template <class T_return, class T_obj, class T_arg1>
 373 inline retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 374 retype(const mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 375 { return retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 376     (_A_functor); }
 377
 378 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 379  * This function template specialization works on sigc::mem_functor.
 380  *
 381  * @param _A_functor Functor that should be wrapped.
 382  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 383  *
 384  * @ingroup retype
 385  */
 386 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 387 inline retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 388 retype(const mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 389 { return retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 390     (_A_functor); }
 391
 392 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 393  * This function template specialization works on sigc::mem_functor.
 394  *
 395  * @param _A_functor Functor that should be wrapped.
 396  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 397  *
 398  * @ingroup retype
 399  */
 400 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 401 inline retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 402 retype(const mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 403 { return retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 404     (_A_functor); }
 405
 406 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 407  * This function template specialization works on sigc::mem_functor.
 408  *
 409  * @param _A_functor Functor that should be wrapped.
 410  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 411  *
 412  * @ingroup retype
 413  */
 414 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 415 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 >
 416 retype(const mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 417 { 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 >
 418     (_A_functor); }
 419
 420 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 421  * This function template specialization works on sigc::mem_functor.
 422  *
 423  * @param _A_functor Functor that should be wrapped.
 424  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 425  *
 426  * @ingroup retype
 427  */
 428 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 429 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 >
 430 retype(const mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 431 { 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 >
 432     (_A_functor); }
 433
 434 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 435  * This function template specialization works on sigc::mem_functor.
 436  *
 437  * @param _A_functor Functor that should be wrapped.
 438  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 439  *
 440  * @ingroup retype
 441  */
 442 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>
 443 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 >
 444 retype(const mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 445 { 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 >
 446     (_A_functor); }
 447
 448 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 449  * This function template specialization works on sigc::mem_functor.
 450  *
 451  * @param _A_functor Functor that should be wrapped.
 452  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 453  *
 454  * @ingroup retype
 455  */
 456 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>
 457 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 >
 458 retype(const mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
 459 { 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 >
 460     (_A_functor); }
 461
 462 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 463  * This function template specialization works on sigc::const_mem_functor.
 464  *
 465  * @param _A_functor Functor that should be wrapped.
 466  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 467  *
 468  * @ingroup retype
 469  */
 470 template <class T_return, class T_obj>
 471 inline retype_functor<const_mem_functor0<T_return, T_obj> >
 472 retype(const const_mem_functor0<T_return, T_obj>& _A_functor)
 473 { return retype_functor<const_mem_functor0<T_return, T_obj> >
 474     (_A_functor); }
 475
 476 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 477  * This function template specialization works on sigc::const_mem_functor.
 478  *
 479  * @param _A_functor Functor that should be wrapped.
 480  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 481  *
 482  * @ingroup retype
 483  */
 484 template <class T_return, class T_obj, class T_arg1>
 485 inline retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 486 retype(const const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 487 { return retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 488     (_A_functor); }
 489
 490 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 491  * This function template specialization works on sigc::const_mem_functor.
 492  *
 493  * @param _A_functor Functor that should be wrapped.
 494  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 495  *
 496  * @ingroup retype
 497  */
 498 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 499 inline retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 500 retype(const const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 501 { return retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 502     (_A_functor); }
 503
 504 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 505  * This function template specialization works on sigc::const_mem_functor.
 506  *
 507  * @param _A_functor Functor that should be wrapped.
 508  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 509  *
 510  * @ingroup retype
 511  */
 512 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 513 inline retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 514 retype(const const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 515 { return retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 516     (_A_functor); }
 517
 518 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 519  * This function template specialization works on sigc::const_mem_functor.
 520  *
 521  * @param _A_functor Functor that should be wrapped.
 522  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 523  *
 524  * @ingroup retype
 525  */
 526 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 527 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 >
 528 retype(const const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 529 { 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 >
 530     (_A_functor); }
 531
 532 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 533  * This function template specialization works on sigc::const_mem_functor.
 534  *
 535  * @param _A_functor Functor that should be wrapped.
 536  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 537  *
 538  * @ingroup retype
 539  */
 540 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 541 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 >
 542 retype(const const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 543 { 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 >
 544     (_A_functor); }
 545
 546 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 547  * This function template specialization works on sigc::const_mem_functor.
 548  *
 549  * @param _A_functor Functor that should be wrapped.
 550  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 551  *
 552  * @ingroup retype
 553  */
 554 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>
 555 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 >
 556 retype(const const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 557 { 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 >
 558     (_A_functor); }
 559
 560 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 561  * This function template specialization works on sigc::const_mem_functor.
 562  *
 563  * @param _A_functor Functor that should be wrapped.
 564  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 565  *
 566  * @ingroup retype
 567  */
 568 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>
 569 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 >
 570 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)
 571 { 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 >
 572     (_A_functor); }
 573
 574 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 575  * This function template specialization works on sigc::volatile_mem_functor.
 576  *
 577  * @param _A_functor Functor that should be wrapped.
 578  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 579  *
 580  * @ingroup retype
 581  */
 582 template <class T_return, class T_obj>
 583 inline retype_functor<volatile_mem_functor0<T_return, T_obj> >
 584 retype(const volatile_mem_functor0<T_return, T_obj>& _A_functor)
 585 { return retype_functor<volatile_mem_functor0<T_return, T_obj> >
 586     (_A_functor); }
 587
 588 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 589  * This function template specialization works on sigc::volatile_mem_functor.
 590  *
 591  * @param _A_functor Functor that should be wrapped.
 592  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 593  *
 594  * @ingroup retype
 595  */
 596 template <class T_return, class T_obj, class T_arg1>
 597 inline retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 598 retype(const volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 599 { return retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 600     (_A_functor); }
 601
 602 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 603  * This function template specialization works on sigc::volatile_mem_functor.
 604  *
 605  * @param _A_functor Functor that should be wrapped.
 606  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 607  *
 608  * @ingroup retype
 609  */
 610 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 611 inline retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 612 retype(const volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 613 { return retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 614     (_A_functor); }
 615
 616 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 617  * This function template specialization works on sigc::volatile_mem_functor.
 618  *
 619  * @param _A_functor Functor that should be wrapped.
 620  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 621  *
 622  * @ingroup retype
 623  */
 624 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 625 inline retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 626 retype(const volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 627 { return retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 628     (_A_functor); }
 629
 630 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 631  * This function template specialization works on sigc::volatile_mem_functor.
 632  *
 633  * @param _A_functor Functor that should be wrapped.
 634  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 635  *
 636  * @ingroup retype
 637  */
 638 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 639 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 >
 640 retype(const volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 641 { 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 >
 642     (_A_functor); }
 643
 644 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 645  * This function template specialization works on sigc::volatile_mem_functor.
 646  *
 647  * @param _A_functor Functor that should be wrapped.
 648  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 649  *
 650  * @ingroup retype
 651  */
 652 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 653 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 >
 654 retype(const volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 655 { 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 >
 656     (_A_functor); }
 657
 658 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 659  * This function template specialization works on sigc::volatile_mem_functor.
 660  *
 661  * @param _A_functor Functor that should be wrapped.
 662  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 663  *
 664  * @ingroup retype
 665  */
 666 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>
 667 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 >
 668 retype(const volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 669 { 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 >
 670     (_A_functor); }
 671
 672 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 673  * This function template specialization works on sigc::volatile_mem_functor.
 674  *
 675  * @param _A_functor Functor that should be wrapped.
 676  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 677  *
 678  * @ingroup retype
 679  */
 680 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>
 681 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 >
 682 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)
 683 { 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 >
 684     (_A_functor); }
 685
 686 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 687  * This function template specialization works on sigc::const_volatile_mem_functor.
 688  *
 689  * @param _A_functor Functor that should be wrapped.
 690  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 691  *
 692  * @ingroup retype
 693  */
 694 template <class T_return, class T_obj>
 695 inline retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
 696 retype(const const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
 697 { return retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
 698     (_A_functor); }
 699
 700 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 701  * This function template specialization works on sigc::const_volatile_mem_functor.
 702  *
 703  * @param _A_functor Functor that should be wrapped.
 704  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 705  *
 706  * @ingroup retype
 707  */
 708 template <class T_return, class T_obj, class T_arg1>
 709 inline retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 710 retype(const const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 711 { return retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 712     (_A_functor); }
 713
 714 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 715  * This function template specialization works on sigc::const_volatile_mem_functor.
 716  *
 717  * @param _A_functor Functor that should be wrapped.
 718  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 719  *
 720  * @ingroup retype
 721  */
 722 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 723 inline retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 724 retype(const const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 725 { return retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 726     (_A_functor); }
 727
 728 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 729  * This function template specialization works on sigc::const_volatile_mem_functor.
 730  *
 731  * @param _A_functor Functor that should be wrapped.
 732  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 733  *
 734  * @ingroup retype
 735  */
 736 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 737 inline retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 738 retype(const const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 739 { return retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 740     (_A_functor); }
 741
 742 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 743  * This function template specialization works on sigc::const_volatile_mem_functor.
 744  *
 745  * @param _A_functor Functor that should be wrapped.
 746  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 747  *
 748  * @ingroup retype
 749  */
 750 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 751 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 >
 752 retype(const const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 753 { 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 >
 754     (_A_functor); }
 755
 756 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 757  * This function template specialization works on sigc::const_volatile_mem_functor.
 758  *
 759  * @param _A_functor Functor that should be wrapped.
 760  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 761  *
 762  * @ingroup retype
 763  */
 764 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 765 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 >
 766 retype(const const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 767 { 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 >
 768     (_A_functor); }
 769
 770 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 771  * This function template specialization works on sigc::const_volatile_mem_functor.
 772  *
 773  * @param _A_functor Functor that should be wrapped.
 774  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 775  *
 776  * @ingroup retype
 777  */
 778 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>
 779 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 >
 780 retype(const const_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 781 { 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 >
 782     (_A_functor); }
 783
 784 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 785  * This function template specialization works on sigc::const_volatile_mem_functor.
 786  *
 787  * @param _A_functor Functor that should be wrapped.
 788  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 789  *
 790  * @ingroup retype
 791  */
 792 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>
 793 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 >
 794 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)
 795 { 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 >
 796     (_A_functor); }
 797
 798 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 799  * This function template specialization works on sigc::bound_mem_functor.
 800  *
 801  * @param _A_functor Functor that should be wrapped.
 802  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 803  *
 804  * @ingroup retype
 805  */
 806 template <class T_return, class T_obj>
 807 inline retype_functor<bound_mem_functor0<T_return, T_obj> >
 808 retype(const bound_mem_functor0<T_return, T_obj>& _A_functor)
 809 { return retype_functor<bound_mem_functor0<T_return, T_obj> >
 810     (_A_functor); }
 811
 812 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 813  * This function template specialization works on sigc::bound_mem_functor.
 814  *
 815  * @param _A_functor Functor that should be wrapped.
 816  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 817  *
 818  * @ingroup retype
 819  */
 820 template <class T_return, class T_obj, class T_arg1>
 821 inline retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 822 retype(const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 823 { return retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 824     (_A_functor); }
 825
 826 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 827  * This function template specialization works on sigc::bound_mem_functor.
 828  *
 829  * @param _A_functor Functor that should be wrapped.
 830  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 831  *
 832  * @ingroup retype
 833  */
 834 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 835 inline retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 836 retype(const bound_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 837 { return retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 838     (_A_functor); }
 839
 840 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 841  * This function template specialization works on sigc::bound_mem_functor.
 842  *
 843  * @param _A_functor Functor that should be wrapped.
 844  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 845  *
 846  * @ingroup retype
 847  */
 848 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 849 inline retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 850 retype(const bound_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 851 { return retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 852     (_A_functor); }
 853
 854 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 855  * This function template specialization works on sigc::bound_mem_functor.
 856  *
 857  * @param _A_functor Functor that should be wrapped.
 858  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 859  *
 860  * @ingroup retype
 861  */
 862 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 863 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 >
 864 retype(const bound_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 865 { 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 >
 866     (_A_functor); }
 867
 868 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 869  * This function template specialization works on sigc::bound_mem_functor.
 870  *
 871  * @param _A_functor Functor that should be wrapped.
 872  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 873  *
 874  * @ingroup retype
 875  */
 876 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 877 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 >
 878 retype(const bound_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 879 { 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 >
 880     (_A_functor); }
 881
 882 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 883  * This function template specialization works on sigc::bound_mem_functor.
 884  *
 885  * @param _A_functor Functor that should be wrapped.
 886  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 887  *
 888  * @ingroup retype
 889  */
 890 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>
 891 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 >
 892 retype(const bound_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
 893 { 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 >
 894     (_A_functor); }
 895
 896 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 897  * This function template specialization works on sigc::bound_mem_functor.
 898  *
 899  * @param _A_functor Functor that should be wrapped.
 900  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 901  *
 902  * @ingroup retype
 903  */
 904 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>
 905 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 >
 906 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)
 907 { 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 >
 908     (_A_functor); }
 909
 910 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 911  * This function template specialization works on sigc::bound_const_mem_functor.
 912  *
 913  * @param _A_functor Functor that should be wrapped.
 914  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 915  *
 916  * @ingroup retype
 917  */
 918 template <class T_return, class T_obj>
 919 inline retype_functor<bound_const_mem_functor0<T_return, T_obj> >
 920 retype(const bound_const_mem_functor0<T_return, T_obj>& _A_functor)
 921 { return retype_functor<bound_const_mem_functor0<T_return, T_obj> >
 922     (_A_functor); }
 923
 924 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 925  * This function template specialization works on sigc::bound_const_mem_functor.
 926  *
 927  * @param _A_functor Functor that should be wrapped.
 928  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 929  *
 930  * @ingroup retype
 931  */
 932 template <class T_return, class T_obj, class T_arg1>
 933 inline retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 934 retype(const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 935 { return retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 936     (_A_functor); }
 937
 938 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 939  * This function template specialization works on sigc::bound_const_mem_functor.
 940  *
 941  * @param _A_functor Functor that should be wrapped.
 942  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 943  *
 944  * @ingroup retype
 945  */
 946 template <class T_return, class T_obj, class T_arg1,class T_arg2>
 947 inline retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 948 retype(const bound_const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
 949 { return retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
 950     (_A_functor); }
 951
 952 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 953  * This function template specialization works on sigc::bound_const_mem_functor.
 954  *
 955  * @param _A_functor Functor that should be wrapped.
 956  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 957  *
 958  * @ingroup retype
 959  */
 960 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
 961 inline retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 962 retype(const bound_const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
 963 { return retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
 964     (_A_functor); }
 965
 966 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 967  * This function template specialization works on sigc::bound_const_mem_functor.
 968  *
 969  * @param _A_functor Functor that should be wrapped.
 970  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 971  *
 972  * @ingroup retype
 973  */
 974 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
 975 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 >
 976 retype(const bound_const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
 977 { 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 >
 978     (_A_functor); }
 979
 980 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 981  * This function template specialization works on sigc::bound_const_mem_functor.
 982  *
 983  * @param _A_functor Functor that should be wrapped.
 984  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 985  *
 986  * @ingroup retype
 987  */
 988 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
 989 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 >
 990 retype(const bound_const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
 991 { 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 >
 992     (_A_functor); }
 993
 994 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 995  * This function template specialization works on sigc::bound_const_mem_functor.
 996  *
 997  * @param _A_functor Functor that should be wrapped.
 998  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 999  *
1000  * @ingroup retype
1001  */
1002 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>
1003 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 >
1004 retype(const bound_const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
1005 { 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 >
1006     (_A_functor); }
1007
1008 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1009  * This function template specialization works on sigc::bound_const_mem_functor.
1010  *
1011  * @param _A_functor Functor that should be wrapped.
1012  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1013  *
1014  * @ingroup retype
1015  */
1016 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>
1017 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 >
1018 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)
1019 { 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 >
1020     (_A_functor); }
1021
1022 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1023  * This function template specialization works on sigc::bound_volatile_mem_functor.
1024  *
1025  * @param _A_functor Functor that should be wrapped.
1026  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1027  *
1028  * @ingroup retype
1029  */
1030 template <class T_return, class T_obj>
1031 inline retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
1032 retype(const bound_volatile_mem_functor0<T_return, T_obj>& _A_functor)
1033 { return retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
1034     (_A_functor); }
1035
1036 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1037  * This function template specialization works on sigc::bound_volatile_mem_functor.
1038  *
1039  * @param _A_functor Functor that should be wrapped.
1040  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1041  *
1042  * @ingroup retype
1043  */
1044 template <class T_return, class T_obj, class T_arg1>
1045 inline retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1046 retype(const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
1047 { return retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1048     (_A_functor); }
1049
1050 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1051  * This function template specialization works on sigc::bound_volatile_mem_functor.
1052  *
1053  * @param _A_functor Functor that should be wrapped.
1054  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1055  *
1056  * @ingroup retype
1057  */
1058 template <class T_return, class T_obj, class T_arg1,class T_arg2>
1059 inline retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
1060 retype(const bound_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
1061 { return retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
1062     (_A_functor); }
1063
1064 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1065  * This function template specialization works on sigc::bound_volatile_mem_functor.
1066  *
1067  * @param _A_functor Functor that should be wrapped.
1068  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1069  *
1070  * @ingroup retype
1071  */
1072 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
1073 inline retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
1074 retype(const bound_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
1075 { return retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
1076     (_A_functor); }
1077
1078 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1079  * This function template specialization works on sigc::bound_volatile_mem_functor.
1080  *
1081  * @param _A_functor Functor that should be wrapped.
1082  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1083  *
1084  * @ingroup retype
1085  */
1086 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
1087 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 >
1088 retype(const bound_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
1089 { 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 >
1090     (_A_functor); }
1091
1092 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1093  * This function template specialization works on sigc::bound_volatile_mem_functor.
1094  *
1095  * @param _A_functor Functor that should be wrapped.
1096  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1097  *
1098  * @ingroup retype
1099  */
1100 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
1101 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 >
1102 retype(const bound_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
1103 { 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 >
1104     (_A_functor); }
1105
1106 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1107  * This function template specialization works on sigc::bound_volatile_mem_functor.
1108  *
1109  * @param _A_functor Functor that should be wrapped.
1110  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1111  *
1112  * @ingroup retype
1113  */
1114 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>
1115 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 >
1116 retype(const bound_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
1117 { 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 >
1118     (_A_functor); }
1119
1120 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1121  * This function template specialization works on sigc::bound_volatile_mem_functor.
1122  *
1123  * @param _A_functor Functor that should be wrapped.
1124  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1125  *
1126  * @ingroup retype
1127  */
1128 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>
1129 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 >
1130 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)
1131 { 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 >
1132     (_A_functor); }
1133
1134 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1135  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1136  *
1137  * @param _A_functor Functor that should be wrapped.
1138  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1139  *
1140  * @ingroup retype
1141  */
1142 template <class T_return, class T_obj>
1143 inline retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
1144 retype(const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
1145 { return retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
1146     (_A_functor); }
1147
1148 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1149  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1150  *
1151  * @param _A_functor Functor that should be wrapped.
1152  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1153  *
1154  * @ingroup retype
1155  */
1156 template <class T_return, class T_obj, class T_arg1>
1157 inline retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1158 retype(const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
1159 { return retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1160     (_A_functor); }
1161
1162 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1163  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1164  *
1165  * @param _A_functor Functor that should be wrapped.
1166  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1167  *
1168  * @ingroup retype
1169  */
1170 template <class T_return, class T_obj, class T_arg1,class T_arg2>
1171 inline retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
1172 retype(const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
1173 { return retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
1174     (_A_functor); }
1175
1176 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1177  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1178  *
1179  * @param _A_functor Functor that should be wrapped.
1180  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1181  *
1182  * @ingroup retype
1183  */
1184 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
1185 inline retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
1186 retype(const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
1187 { return retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
1188     (_A_functor); }
1189
1190 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1191  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1192  *
1193  * @param _A_functor Functor that should be wrapped.
1194  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1195  *
1196  * @ingroup retype
1197  */
1198 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
1199 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 >
1200 retype(const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
1201 { 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 >
1202     (_A_functor); }
1203
1204 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1205  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1206  *
1207  * @param _A_functor Functor that should be wrapped.
1208  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1209  *
1210  * @ingroup retype
1211  */
1212 template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
1213 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 >
1214 retype(const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
1215 { 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 >
1216     (_A_functor); }
1217
1218 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1219  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1220  *
1221  * @param _A_functor Functor that should be wrapped.
1222  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1223  *
1224  * @ingroup retype
1225  */
1226 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>
1227 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 >
1228 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)
1229 { 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 >
1230     (_A_functor); }
1231
1232 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1233  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1234  *
1235  * @param _A_functor Functor that should be wrapped.
1236  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1237  *
1238  * @ingroup retype
1239  */
1240 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>
1241 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 >
1242 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)
1243 { 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 >
1244     (_A_functor); }
1245
1246
1247 } /* namespace sigc */
1248 #endif /* _SIGC_ADAPTORS_MACROS_RETYPEHM4_ */