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
operatorretype_functor91 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
sun_forte_workaroundretype_functor99 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
operatorretype_functor107 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
sun_forte_workaroundretype_functor115 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
operatorretype_functor123 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
sun_forte_workaroundretype_functor131 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
operatorretype_functor139 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
sun_forte_workaroundretype_functor147 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
operatorretype_functor155 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
sun_forte_workaroundretype_functor163 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
operatorretype_functor171 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
sun_forte_workaroundretype_functor179 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
operatorretype_functor187 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
sun_forte_workaroundretype_functor195 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 */
retype_functorretype_functor205 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
operator()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_ */
1267