untracked/sigc++/adaptors/retype.h

   1 // -*- c++ -*-
   2 /* Do not edit! -- generated file */
   3 #ifndef _SIGC_ADAPTORS_RETYPE_H_
   4 #define _SIGC_ADAPTORS_RETYPE_H_
   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 //TODO: See comment in functor_trait.h.
  11 #if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO)
  12   #define SIGC_NIL_HAS_BEEN_PUSHED 1
  13   #pragma push_macro("nil")
  14   #undef nil
  15 #endif
  16
  17 namespace sigc {
  18
  19 /** @defgroup retype retype(), retype_return()
  20  * sigc::retype() alters a sigc::pointer_functor, a sigc::mem_functor or a sigc::slot
  21  * in that it makes C-style casts to the functor's parameter types
  22  * of all parameters passed through operator()().
  23  *
  24  * Use this adaptor for inline conversion between numeric or other simple types.
  25  * @par Example:
  26  * @code
  27  * void foo(int);
  28  * sigc::retype(sigc::ptr_fun(&foo))(5.7F); // calls foo(5)
  29  * @endcode
  30  *
  31  * The functor that sigc::retype() returns can be passed directly into
  32  * sigc::signal::connect().
  33  *
  34  * @par Example:
  35  * @code
  36  * sigc::signal<void,float> some_signal;
  37  * void foo(int);
  38  * some_signal.connect(sigc::retype(sigc::ptr_fun(&foo)));
  39  * @endcode
  40  *
  41  * This adaptor builds an exception in that it only works on sig::pointer_functor,
  42  * sigc::mem_functor and sigc::slot because it needs sophisticated information about
  43  * the parameter types that cannot be deduced from arbitrary functor types.
  44  *
  45  * sigc::retype_return() alters the return type of an arbitrary functor.
  46  * Like in sigc::retype() a C-style cast is performed. Usage sigc::retype_return() is
  47  * not restricted to libsigc++ functor types but you need to
  48  * specify the new return type as a template parameter.
  49  *
  50  * @par Example:
  51  * @code
  52  * float foo();
  53  * std::cout << sigc::retype_return<int>(&foo)(); // converts foo's return value to an integer
  54  * @endcode
  55  *
  56  * @ingroup adaptors
  57  */
  58
  59 /** Adaptor that performs C-style casts on the parameters passed on to the functor.
  60  * Use the convenience function sigc::retype() to create an instance of retype_functor.
  61  *
  62  * The following template arguments are used:
  63  * - @e T_functor Type of the functor to wrap.
  64  * - @e T_type1 Type of @e T_functor's 1th argument.
  65  * - @e T_type2 Type of @e T_functor's 2th argument.
  66  * - @e T_type3 Type of @e T_functor's 3th argument.
  67  * - @e T_type4 Type of @e T_functor's 4th argument.
  68  * - @e T_type5 Type of @e T_functor's 5th argument.
  69  * - @e T_type6 Type of @e T_functor's 6th argument.
  70  * - @e T_type7 Type of @e T_functor's 7th argument.
  71  *
  72  * @ingroup retype
  73  */
  74 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>
  75 struct retype_functor
  76   : public adapts<T_functor>
  77 {
  78   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
  79
  80 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  81   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>
  82   struct deduce_result_type
  83     { typedef typename adaptor_type::template deduce_result_type<type_trait_pass_t<T_arg1>, type_trait_pass_t<T_arg2>, type_trait_pass_t<T_arg3>, type_trait_pass_t<T_arg4>, type_trait_pass_t<T_arg5>, type_trait_pass_t<T_arg6>, type_trait_pass_t<T_arg7>>::type type; };
  84 #endif
  85   typedef typename adapts<T_functor>::result_type result_type;
  86
  87   result_type operator()();
  88
  89   template <class T_arg1>
  90   typename deduce_result_type<T_arg1>::type
  91   operator()(T_arg1 _A_a1)
  92     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>>
  93         (static_cast<T_type1>(_A_a1));
  94     }
  95
  96   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
  97   template <class T_arg1>
  98   typename deduce_result_type<T_arg1>::type
  99   sun_forte_workaround(T_arg1 _A_a1)
 100     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>>
 101         (static_cast<T_type1>(_A_a1));
 102     }
 103   #endif
 104
 105   template <class T_arg1, class T_arg2>
 106   typename deduce_result_type<T_arg1, T_arg2>::type
 107   operator()(T_arg1 _A_a1, T_arg2 _A_a2)
 108     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>>
 109         (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2));
 110     }
 111
 112   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 113   template <class T_arg1, class T_arg2>
 114   typename deduce_result_type<T_arg1, T_arg2>::type
 115   sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2)
 116     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>>
 117         (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2));
 118     }
 119   #endif
 120
 121   template <class T_arg1, class T_arg2, class T_arg3>
 122   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 123   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
 124     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>>
 125         (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3));
 126     }
 127
 128   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 129   template <class T_arg1, class T_arg2, class T_arg3>
 130   typename deduce_result_type<T_arg1, T_arg2, T_arg3>::type
 131   sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3)
 132     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>>
 133         (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3));
 134     }
 135   #endif
 136
 137   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 138   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 139   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
 140     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>>
 141         (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4));
 142     }
 143
 144   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 145   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 146   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4>::type
 147   sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
 148     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>>
 149         (static_cast<T_type1>(_A_a1), static_cast<T_type2>(_A_a2), static_cast<T_type3>(_A_a3), static_cast<T_type4>(_A_a4));
 150     }
 151   #endif
 152
 153   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 154   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 155   operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
 156     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>>
 157         (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));
 158     }
 159
 160   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 161   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 162   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>::type
 163   sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
 164     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>>
 165         (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));
 166     }
 167   #endif
 168
 169   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 170   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 171   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)
 172     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>, type_trait_take_t<T_type6>>
 173         (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));
 174     }
 175
 176   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 177   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 178   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>::type
 179   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)
 180     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>, type_trait_take_t<T_type6>>
 181         (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));
 182     }
 183   #endif
 184
 185   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 186   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 187   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)
 188     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>, type_trait_take_t<T_type6>, type_trait_take_t<T_type7>>
 189         (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));
 190     }
 191
 192   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 193   template <class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 194   typename deduce_result_type<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>::type
 195   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)
 196     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<type_trait_take_t<T_type1>, type_trait_take_t<T_type2>, type_trait_take_t<T_type3>, type_trait_take_t<T_type4>, type_trait_take_t<T_type5>, type_trait_take_t<T_type6>, type_trait_take_t<T_type7>>
 197         (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));
 198     }
 199   #endif
 200
 201
 202   /** Constructs a retype_functor object that performs C-style casts on the parameters passed on to the functor.
 203    * @param _A_functor Functor to invoke from operator()().
 204    */
 205   explicit retype_functor(type_trait_take_t<T_functor> _A_functor)
 206     : adapts<T_functor>(_A_functor)
 207     {}
 208 };
 209
 210 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>
 211 typename retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::result_type
 212 retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>::operator()()
 213   { return this->functor_(); }
 214
 215 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 216 //template specialization of visitor<>::do_visit_each<>(action, functor):
 217 /** Performs a functor on each of the targets of a functor.
 218  * The function overload for sigc::retype_functor performs a functor on the
 219  * functor stored in the sigc::retype_functor object.
 220  *
 221  * @ingroup retype
 222  */
 223 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>
 224 struct visitor<retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> >
 225 {
 226   template <typename T_action>
 227   static void do_visit_each(const T_action& _A_action,
 228                             const retype_functor<T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7>& _A_target)
 229   {
 230     sigc::visit_each(_A_action, _A_target.functor_);
 231   }
 232 };
 233 #endif // DOXYGEN_SHOULD_SKIP_THIS
 234
 235 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 236  * This function template specialization works on sigc::slot.
 237  *
 238  * @param _A_functor Functor that should be wrapped.
 239  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 240  *
 241  * @ingroup retype
 242  */
 243 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>
 244 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 >
 245 retype(const slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
 246 { 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 >
 247     (_A_functor); }
 248
 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_return>
 259 inline retype_functor<pointer_functor0<T_return> >
 260 retype(const pointer_functor0<T_return>& _A_functor)
 261 { return retype_functor<pointer_functor0<T_return> >
 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_return>
 273 inline retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
 274 retype(const pointer_functor1<T_arg1, T_return>& _A_functor)
 275 { return retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
 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_return>
 287 inline retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1, T_arg2 >
 288 retype(const pointer_functor2<T_arg1, T_arg2, T_return>& _A_functor)
 289 { return retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1, T_arg2 >
 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_return>
 301 inline retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1, T_arg2, T_arg3 >
 302 retype(const pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>& _A_functor)
 303 { return retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1, T_arg2, T_arg3 >
 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_return>
 315 inline retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1, T_arg2, T_arg3, T_arg4 >
 316 retype(const pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>& _A_functor)
 317 { return retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1, T_arg2, T_arg3, T_arg4 >
 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_return>
 329 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 >
 330 retype(const pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>& _A_functor)
 331 { 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 >
 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_return>
 343 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 >
 344 retype(const pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>& _A_functor)
 345 { 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 >
 346     (_A_functor); }
 347
 348 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
 349  * This function template specialization works on sigc::pointer_functor.
 350  *
 351  * @param _A_functor Functor that should be wrapped.
 352  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
 353  *
 354  * @ingroup retype
 355  */
 356 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>
 357 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 >
 358 retype(const pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>& _A_functor)
 359 { 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 >
 360     (_A_functor); }
 361
 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>
 372 inline retype_functor<mem_functor0<T_return, T_obj> >
 373 retype(const mem_functor0<T_return, T_obj>& _A_functor)
 374 { return retype_functor<mem_functor0<T_return, T_obj> >
 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>
 386 inline retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 387 retype(const mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 388 { return retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 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>
 400 inline retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 401 retype(const mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
 402 { return retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 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>
 414 inline retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 415 retype(const mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
 416 { return retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 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>
 428 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 >
 429 retype(const mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
 430 { 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 >
 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>
 442 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 >
 443 retype(const mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
 444 { 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 >
 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>
 456 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 >
 457 retype(const mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
 458 { 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 >
 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::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, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 470 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 >
 471 retype(const mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& _A_functor)
 472 { 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 >
 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>
 484 inline retype_functor<const_mem_functor0<T_return, T_obj> >
 485 retype(const const_mem_functor0<T_return, T_obj>& _A_functor)
 486 { return retype_functor<const_mem_functor0<T_return, T_obj> >
 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>
 498 inline retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 499 retype(const const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 500 { return retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 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>
 512 inline retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 513 retype(const const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
 514 { return retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 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>
 526 inline retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 527 retype(const const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
 528 { return retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 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>
 540 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 >
 541 retype(const const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
 542 { 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 >
 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>
 554 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 >
 555 retype(const const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
 556 { 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 >
 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>
 568 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 >
 569 retype(const const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
 570 { 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 >
 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::const_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, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 582 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 >
 583 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)
 584 { 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 >
 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>
 596 inline retype_functor<volatile_mem_functor0<T_return, T_obj> >
 597 retype(const volatile_mem_functor0<T_return, T_obj>& _A_functor)
 598 { return retype_functor<volatile_mem_functor0<T_return, T_obj> >
 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>
 610 inline retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 611 retype(const volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 612 { return retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 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>
 624 inline retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 625 retype(const volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
 626 { return retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 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>
 638 inline retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 639 retype(const volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
 640 { return retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 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>
 652 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 >
 653 retype(const volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
 654 { 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 >
 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>
 666 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 >
 667 retype(const volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
 668 { 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 >
 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>
 680 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 >
 681 retype(const volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
 682 { 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 >
 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::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, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 694 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 >
 695 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)
 696 { 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 >
 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>
 708 inline retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
 709 retype(const const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
 710 { return retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
 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>
 722 inline retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 723 retype(const const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 724 { return retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 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>
 736 inline retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 737 retype(const const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
 738 { return retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 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>
 750 inline retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 751 retype(const const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
 752 { return retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 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>
 764 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 >
 765 retype(const const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
 766 { 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 >
 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>
 778 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 >
 779 retype(const const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
 780 { 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 >
 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>
 792 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 >
 793 retype(const const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
 794 { 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 >
 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::const_volatile_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, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 806 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 >
 807 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)
 808 { 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 >
 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>
 820 inline retype_functor<bound_mem_functor0<T_return, T_obj> >
 821 retype(const bound_mem_functor0<T_return, T_obj>& _A_functor)
 822 { return retype_functor<bound_mem_functor0<T_return, T_obj> >
 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>
 834 inline retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 835 retype(const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 836 { return retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 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>
 848 inline retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 849 retype(const bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
 850 { return retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 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>
 862 inline retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 863 retype(const bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
 864 { return retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 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>
 876 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 >
 877 retype(const bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
 878 { 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 >
 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>
 890 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 >
 891 retype(const bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
 892 { 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 >
 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>
 904 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 >
 905 retype(const bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
 906 { 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 >
 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_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, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 918 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 >
 919 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)
 920 { 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 >
 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>
 932 inline retype_functor<bound_const_mem_functor0<T_return, T_obj> >
 933 retype(const bound_const_mem_functor0<T_return, T_obj>& _A_functor)
 934 { return retype_functor<bound_const_mem_functor0<T_return, T_obj> >
 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>
 946 inline retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 947 retype(const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
 948 { return retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
 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>
 960 inline retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 961 retype(const bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
 962 { return retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
 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>
 974 inline retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 975 retype(const bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
 976 { return retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
 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>
 988 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 >
 989 retype(const bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
 990 { 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 >
 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>
1002 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 >
1003 retype(const bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
1004 { 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 >
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>
1016 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 >
1017 retype(const bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
1018 { 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 >
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_const_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, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1030 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 >
1031 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)
1032 { 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 >
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>
1044 inline retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
1045 retype(const bound_volatile_mem_functor0<T_return, T_obj>& _A_functor)
1046 { return retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
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>
1058 inline retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1059 retype(const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
1060 { return retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
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>
1072 inline retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
1073 retype(const bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
1074 { return retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
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>
1086 inline retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
1087 retype(const bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
1088 { return retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
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>
1100 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 >
1101 retype(const bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
1102 { 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 >
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>
1114 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 >
1115 retype(const bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
1116 { 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 >
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>
1128 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 >
1129 retype(const bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& _A_functor)
1130 { 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 >
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_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, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
1142 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 >
1143 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)
1144 { 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 >
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>
1156 inline retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
1157 retype(const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
1158 { return retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
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>
1170 inline retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
1171 retype(const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
1172 { return retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
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>
1184 inline retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
1185 retype(const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>& _A_functor)
1186 { return retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1, T_arg2 >
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>
1198 inline retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
1199 retype(const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>& _A_functor)
1200 { return retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1, T_arg2, T_arg3 >
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>
1212 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 >
1213 retype(const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>& _A_functor)
1214 { 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 >
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>
1226 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 >
1227 retype(const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& _A_functor)
1228 { 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 >
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>
1240 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 >
1241 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)
1242 { 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 >
1243     (_A_functor); }
1244
1245 /** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
1246  * This function template specialization works on sigc::bound_const_volatile_mem_functor.
1247  *
1248  * @param _A_functor Functor that should be wrapped.
1249  * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
1250  *
1251  * @ingroup retype
1252  */
1253 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>
1254 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 >
1255 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)
1256 { 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 >
1257     (_A_functor); }
1258
1259
1260 } /* namespace sigc */
1261
1262 #ifdef SIGC_NIL_HAS_BEEN_PUSHED
1263   #undef SIGC_NIL_HAS_BEEN_PUSHED
1264   #pragma pop_macro("nil")
1265 #endif
1266 #endif /* _SIGC_ADAPTORS_RETYPE_H_ */