]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost Lambda Library - function_adaptors.hpp ---------------------------- |
2 | ||
3 | // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) | |
4 | // | |
5 | // Distributed under the Boost Software License, Version 1.0. (See | |
6 | // accompanying file LICENSE_1_0.txt or copy at | |
7 | // http://www.boost.org/LICENSE_1_0.txt) | |
8 | // | |
9 | // For more information, see www.boost.org | |
10 | ||
11 | ||
12 | #ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP | |
13 | #define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP | |
14 | ||
15 | #include "boost/mpl/has_xxx.hpp" | |
16 | #include "boost/tuple/tuple.hpp" | |
17 | #include "boost/type_traits/same_traits.hpp" | |
18 | #include "boost/type_traits/remove_reference.hpp" | |
19 | #include "boost/type_traits/remove_cv.hpp" | |
20 | #include "boost/type_traits/add_const.hpp" | |
21 | #include "boost/type_traits/add_volatile.hpp" | |
22 | #include "boost/utility/result_of.hpp" | |
23 | ||
24 | namespace boost { | |
25 | namespace lambda { | |
26 | ||
27 | namespace detail { | |
28 | ||
29 | BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig) | |
30 | ||
31 | template<class Tuple> | |
32 | struct remove_references_from_elements { | |
33 | typedef typename boost::tuples::cons< | |
34 | typename boost::remove_reference<typename Tuple::head_type>::type, | |
35 | typename remove_references_from_elements<typename Tuple::tail_type>::type | |
36 | > type; | |
37 | }; | |
38 | ||
39 | template<> | |
40 | struct remove_references_from_elements<boost::tuples::null_type> { | |
41 | typedef boost::tuples::null_type type; | |
42 | }; | |
43 | ||
44 | } | |
45 | ||
46 | template <class Func> struct function_adaptor { | |
47 | ||
48 | typedef typename detail::remove_reference_and_cv<Func>::type plainF; | |
49 | ||
50 | #if !defined(BOOST_NO_RESULT_OF) | |
51 | // Support functors that use the boost::result_of return type convention. | |
52 | template<class Tuple, int Length, bool HasSig> | |
53 | struct result_converter; | |
54 | template<class Tuple, int Length> | |
55 | struct result_converter<Tuple, Length, true> | |
56 | : plainF::template sig< | |
57 | typename detail::remove_references_from_elements<Tuple>::type | |
58 | > | |
59 | {}; | |
60 | template<class Tuple> | |
61 | struct result_converter<Tuple, 0, false> | |
62 | : result_of<plainF()> | |
63 | {}; | |
64 | template<class Tuple> | |
65 | struct result_converter<Tuple, 1, false> | |
66 | : result_of<plainF( | |
67 | typename tuples::element<1, Tuple>::type) | |
68 | > | |
69 | {}; | |
70 | template<class Tuple> | |
71 | struct result_converter<Tuple, 2, false> | |
72 | : result_of<plainF( | |
73 | typename tuples::element<1, Tuple>::type, | |
74 | typename tuples::element<2, Tuple>::type) | |
75 | > | |
76 | {}; | |
77 | template<class Tuple> | |
78 | struct result_converter<Tuple, 3, false> | |
79 | : result_of<plainF( | |
80 | typename tuples::element<1, Tuple>::type, | |
81 | typename tuples::element<2, Tuple>::type, | |
82 | typename tuples::element<3, Tuple>::type) | |
83 | > | |
84 | {}; | |
85 | template<class Tuple> | |
86 | struct result_converter<Tuple, 4, false> | |
87 | : result_of<plainF( | |
88 | typename tuples::element<1, Tuple>::type, | |
89 | typename tuples::element<2, Tuple>::type, | |
90 | typename tuples::element<3, Tuple>::type, | |
91 | typename tuples::element<4, Tuple>::type) | |
92 | > | |
93 | {}; | |
94 | template<class Tuple> | |
95 | struct result_converter<Tuple, 5, false> | |
96 | : result_of<plainF( | |
97 | typename tuples::element<1, Tuple>::type, | |
98 | typename tuples::element<2, Tuple>::type, | |
99 | typename tuples::element<3, Tuple>::type, | |
100 | typename tuples::element<4, Tuple>::type, | |
101 | typename tuples::element<5, Tuple>::type) | |
102 | > | |
103 | {}; | |
104 | template<class Tuple> | |
105 | struct result_converter<Tuple, 6, false> | |
106 | : result_of<plainF( | |
107 | typename tuples::element<1, Tuple>::type, | |
108 | typename tuples::element<2, Tuple>::type, | |
109 | typename tuples::element<3, Tuple>::type, | |
110 | typename tuples::element<4, Tuple>::type, | |
111 | typename tuples::element<5, Tuple>::type, | |
112 | typename tuples::element<6, Tuple>::type) | |
113 | > | |
114 | {}; | |
115 | template<class Tuple> | |
116 | struct result_converter<Tuple, 7, false> | |
117 | : result_of<plainF( | |
118 | typename tuples::element<1, Tuple>::type, | |
119 | typename tuples::element<2, Tuple>::type, | |
120 | typename tuples::element<3, Tuple>::type, | |
121 | typename tuples::element<4, Tuple>::type, | |
122 | typename tuples::element<5, Tuple>::type, | |
123 | typename tuples::element<6, Tuple>::type, | |
124 | typename tuples::element<7, Tuple>::type) | |
125 | > | |
126 | {}; | |
127 | template<class Tuple> | |
128 | struct result_converter<Tuple, 8, false> | |
129 | : result_of<plainF( | |
130 | typename tuples::element<1, Tuple>::type, | |
131 | typename tuples::element<2, Tuple>::type, | |
132 | typename tuples::element<3, Tuple>::type, | |
133 | typename tuples::element<4, Tuple>::type, | |
134 | typename tuples::element<5, Tuple>::type, | |
135 | typename tuples::element<6, Tuple>::type, | |
136 | typename tuples::element<7, Tuple>::type, | |
137 | typename tuples::element<8, Tuple>::type) | |
138 | > | |
139 | {}; | |
140 | template<class Tuple> | |
141 | struct result_converter<Tuple, 9, false> | |
142 | : result_of<plainF( | |
143 | typename tuples::element<1, Tuple>::type, | |
144 | typename tuples::element<2, Tuple>::type, | |
145 | typename tuples::element<3, Tuple>::type, | |
146 | typename tuples::element<4, Tuple>::type, | |
147 | typename tuples::element<5, Tuple>::type, | |
148 | typename tuples::element<6, Tuple>::type, | |
149 | typename tuples::element<7, Tuple>::type, | |
150 | typename tuples::element<8, Tuple>::type, | |
151 | typename tuples::element<9, Tuple>::type) | |
152 | > | |
153 | {}; | |
154 | ||
155 | // we do not know the return type off-hand, we must ask it from Func | |
156 | // To sig we pass a cons list, where the head is the function object type | |
157 | // itself (potentially cv-qualified) | |
158 | // and the tail contains the types of the actual arguments to be passed | |
159 | // to the function object. The arguments can be cv qualified | |
160 | // as well. | |
161 | template <class Args> | |
162 | struct sig | |
163 | : result_converter< | |
164 | Args | |
165 | , tuples::length<typename Args::tail_type>::value | |
166 | , detail::has_sig<plainF>::value | |
167 | > | |
168 | {}; | |
169 | #else // BOOST_NO_RESULT_OF | |
170 | ||
171 | template <class Args> class sig { | |
172 | typedef typename detail::remove_reference_and_cv<Func>::type plainF; | |
173 | public: | |
174 | typedef typename plainF::template sig< | |
175 | typename detail::remove_references_from_elements<Args>::type | |
176 | >::type type; | |
177 | }; | |
178 | #endif | |
179 | ||
180 | template<class RET, class A1> | |
181 | static RET apply(A1& a1) { | |
182 | return a1(); | |
183 | } | |
184 | template<class RET, class A1, class A2> | |
185 | static RET apply(A1& a1, A2& a2) { | |
186 | return a1(a2); | |
187 | } | |
188 | template<class RET, class A1, class A2, class A3> | |
189 | static RET apply(A1& a1, A2& a2, A3& a3) { | |
190 | return a1(a2, a3); | |
191 | } | |
192 | template<class RET, class A1, class A2, class A3, class A4> | |
193 | static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) { | |
194 | return a1(a2, a3, a4); | |
195 | } | |
196 | template<class RET, class A1, class A2, class A3, class A4, class A5> | |
197 | static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { | |
198 | return a1(a2, a3, a4, a5); | |
199 | } | |
200 | template<class RET, class A1, class A2, class A3, class A4, class A5, class A6> | |
201 | static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { | |
202 | return a1(a2, a3, a4, a5, a6); | |
203 | } | |
204 | template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, | |
205 | class A7> | |
206 | static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, | |
207 | A7& a7) { | |
208 | return a1(a2, a3, a4, a5, a6, a7); | |
209 | } | |
210 | template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, | |
211 | class A7, class A8> | |
212 | static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, | |
213 | A7& a7, A8& a8) { | |
214 | return a1(a2, a3, a4, a5, a6, a7, a8); | |
215 | } | |
216 | template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, | |
217 | class A7, class A8, class A9> | |
218 | static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, | |
219 | A7& a7, A8& a8, A9& a9) { | |
220 | return a1(a2, a3, a4, a5, a6, a7, a8, a9); | |
221 | } | |
222 | template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, | |
223 | class A7, class A8, class A9, class A10> | |
224 | static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, | |
225 | A7& a7, A8& a8, A9& a9, A10& a10) { | |
226 | return a1(a2, a3, a4, a5, a6, a7, a8, a9, a10); | |
227 | } | |
228 | }; | |
229 | ||
230 | template <class Func> struct function_adaptor<const Func>; // error | |
231 | ||
232 | // -- function adaptors with data member access | |
233 | template <class Object, class T> | |
234 | struct function_adaptor<T Object::*> { | |
235 | ||
236 | // typedef detail::unspecified type; | |
237 | ||
238 | // T can have qualifiers and can be a reference type | |
239 | // We get the return type by adding const, if the object through which | |
240 | // the data member is accessed is const, and finally adding a reference | |
241 | template<class Args> class sig { | |
242 | typedef typename boost::tuples::element<1, Args>::type argument_type; | |
243 | typedef typename boost::remove_reference< | |
244 | argument_type | |
245 | >::type unref_type; | |
246 | ||
247 | typedef typename detail::IF<boost::is_const<unref_type>::value, | |
248 | typename boost::add_const<T>::type, | |
249 | T | |
250 | >::RET properly_consted_return_type; | |
251 | ||
252 | typedef typename detail::IF<boost::is_volatile<unref_type>::value, | |
253 | typename boost::add_volatile<properly_consted_return_type>::type, | |
254 | properly_consted_return_type | |
255 | >::RET properly_cvd_return_type; | |
256 | ||
257 | ||
258 | public: | |
259 | typedef typename detail::IF<boost::is_reference<argument_type>::value, | |
260 | typename boost::add_reference<properly_cvd_return_type>::type, | |
261 | typename boost::remove_cv<T>::type | |
262 | >::RET type; | |
263 | }; | |
264 | ||
265 | template <class RET> | |
266 | static RET apply( T Object::*data, Object& o) { | |
267 | return o.*data; | |
268 | } | |
269 | template <class RET> | |
270 | static RET apply( T Object::*data, const Object& o) { | |
271 | return o.*data; | |
272 | } | |
273 | template <class RET> | |
274 | static RET apply( T Object::*data, volatile Object& o) { | |
275 | return o.*data; | |
276 | } | |
277 | template <class RET> | |
278 | static RET apply( T Object::*data, const volatile Object& o) { | |
279 | return o.*data; | |
280 | } | |
281 | template <class RET> | |
282 | static RET apply( T Object::*data, Object* o) { | |
283 | return o->*data; | |
284 | } | |
285 | template <class RET> | |
286 | static RET apply( T Object::*data, const Object* o) { | |
287 | return o->*data; | |
288 | } | |
289 | template <class RET> | |
290 | static RET apply( T Object::*data, volatile Object* o) { | |
291 | return o->*data; | |
292 | } | |
293 | template <class RET> | |
294 | static RET apply( T Object::*data, const volatile Object* o) { | |
295 | return o->*data; | |
296 | } | |
297 | }; | |
298 | ||
299 | // -- function adaptors with 1 argument apply | |
300 | ||
301 | template <class Result> | |
302 | struct function_adaptor<Result (void)> { | |
303 | ||
304 | template<class T> struct sig { typedef Result type; }; | |
305 | template <class RET> | |
306 | static Result apply(Result (*func)()) { | |
307 | return func(); | |
308 | } | |
309 | }; | |
310 | ||
311 | template <class Result> | |
312 | struct function_adaptor<Result (*)(void)> { | |
313 | ||
314 | template<class T> struct sig { typedef Result type; }; | |
315 | template <class RET> | |
316 | static Result apply(Result (*func)()) { | |
317 | return func(); | |
318 | } | |
319 | }; | |
320 | ||
321 | ||
322 | // -- function adaptors with 2 argument apply | |
323 | template <class Object, class Result> | |
324 | struct function_adaptor<Result (Object::*)() const> { | |
325 | ||
326 | template<class T> struct sig { typedef Result type; }; | |
327 | template <class RET> | |
328 | static Result apply( Result (Object::*func)() const, const Object* o) { | |
329 | return (o->*func)(); | |
330 | } | |
331 | template <class RET> | |
332 | static Result apply( Result (Object::*func)() const, const Object& o) { | |
333 | return (o.*func)(); | |
334 | } | |
335 | }; | |
336 | ||
337 | template <class Object, class Result> | |
338 | struct function_adaptor<Result (Object::*)()> { | |
339 | ||
340 | template<class T> struct sig { typedef Result type; }; | |
341 | template <class RET> | |
342 | static Result apply( Result (Object::*func)(), Object* o) { | |
343 | return (o->*func)(); | |
344 | } | |
345 | template <class RET> | |
346 | static Result apply( Result (Object::*func)(), Object& o) { | |
347 | return (o.*func)(); | |
348 | } | |
349 | }; | |
350 | ||
351 | template <class Arg1, class Result> | |
352 | struct function_adaptor<Result (Arg1)> { | |
353 | ||
354 | template<class T> struct sig { typedef Result type; }; | |
355 | template <class RET, class A1> | |
356 | static Result apply(Result (*func)(Arg1), A1& a1) { | |
357 | return func(a1); | |
358 | } | |
359 | }; | |
360 | ||
361 | template <class Arg1, class Result> | |
362 | struct function_adaptor<Result (*)(Arg1)> { | |
363 | ||
364 | template<class T> struct sig { typedef Result type; }; | |
365 | template <class RET, class A1> | |
366 | static Result apply(Result (*func)(Arg1), A1& a1) { | |
367 | return func(a1); | |
368 | } | |
369 | }; | |
370 | ||
371 | ||
372 | // -- function adaptors with 3 argument apply | |
373 | template <class Object, class Arg1, class Result> | |
374 | struct function_adaptor<Result (Object::*)(Arg1) const> { | |
375 | ||
376 | template<class T> struct sig { typedef Result type; }; | |
377 | template <class RET, class A1> | |
378 | static Result apply( Result (Object::*func)(Arg1) const, const Object* o, | |
379 | A1& a1) { | |
380 | return (o->*func)(a1); | |
381 | } | |
382 | template <class RET, class A1> | |
383 | static Result apply( Result (Object::*func)(Arg1) const, const Object& o, | |
384 | A1& a1) { | |
385 | return (o.*func)(a1); | |
386 | } | |
387 | }; | |
388 | ||
389 | template <class Object, class Arg1, class Result> | |
390 | struct function_adaptor<Result (Object::*)(Arg1)> { | |
391 | ||
392 | template<class T> struct sig { typedef Result type; }; | |
393 | template <class RET, class A1> | |
394 | static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) { | |
395 | return (o->*func)(a1); | |
396 | } | |
397 | template <class RET, class A1> | |
398 | static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) { | |
399 | return (o.*func)(a1); | |
400 | } | |
401 | }; | |
402 | ||
403 | template <class Arg1, class Arg2, class Result> | |
404 | struct function_adaptor<Result (Arg1, Arg2)> { | |
405 | ||
406 | template<class T> struct sig { typedef Result type; }; | |
407 | template <class RET, class A1, class A2> | |
408 | static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) { | |
409 | return func(a1, a2); | |
410 | } | |
411 | }; | |
412 | ||
413 | template <class Arg1, class Arg2, class Result> | |
414 | struct function_adaptor<Result (*)(Arg1, Arg2)> { | |
415 | ||
416 | template<class T> struct sig { typedef Result type; }; | |
417 | template <class RET, class A1, class A2> | |
418 | static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) { | |
419 | return func(a1, a2); | |
420 | } | |
421 | }; | |
422 | ||
423 | ||
424 | // -- function adaptors with 4 argument apply | |
425 | template <class Object, class Arg1, class Arg2, class Result> | |
426 | struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> { | |
427 | ||
428 | template<class T> struct sig { typedef Result type; }; | |
429 | template <class RET, class A1, class A2> | |
430 | static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) { | |
431 | return (o->*func)(a1, a2); | |
432 | } | |
433 | template <class RET, class A1, class A2> | |
434 | static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) { | |
435 | return (o.*func)(a1, a2); | |
436 | } | |
437 | }; | |
438 | ||
439 | template <class Object, class Arg1, class Arg2, class Result> | |
440 | struct function_adaptor<Result (Object::*)(Arg1, Arg2)> { | |
441 | ||
442 | template<class T> struct sig { typedef Result type; }; | |
443 | template <class RET, class A1, class A2> | |
444 | static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) { | |
445 | return (o->*func)(a1, a2); | |
446 | } | |
447 | template <class RET, class A1, class A2> | |
448 | static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) { | |
449 | return (o.*func)(a1, a2); | |
450 | } | |
451 | }; | |
452 | ||
453 | template <class Arg1, class Arg2, class Arg3, class Result> | |
454 | struct function_adaptor<Result (Arg1, Arg2, Arg3)> { | |
455 | ||
456 | template<class T> struct sig { typedef Result type; }; | |
457 | template <class RET, class A1, class A2, class A3> | |
458 | static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) { | |
459 | return func(a1, a2, a3); | |
460 | } | |
461 | }; | |
462 | ||
463 | template <class Arg1, class Arg2, class Arg3, class Result> | |
464 | struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> { | |
465 | ||
466 | template<class T> struct sig { typedef Result type; }; | |
467 | template <class RET, class A1, class A2, class A3> | |
468 | static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) { | |
469 | return func(a1, a2, a3); | |
470 | } | |
471 | }; | |
472 | ||
473 | ||
474 | // -- function adaptors with 5 argument apply | |
475 | template <class Object, class Arg1, class Arg2, class Arg3, class Result> | |
476 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> { | |
477 | ||
478 | template<class T> struct sig { typedef Result type; }; | |
479 | template <class RET, class A1, class A2, class A3> | |
480 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) { | |
481 | return (o->*func)(a1, a2, a3); | |
482 | } | |
483 | template <class RET, class A1, class A2, class A3> | |
484 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) { | |
485 | return (o.*func)(a1, a2, a3); | |
486 | } | |
487 | }; | |
488 | ||
489 | template <class Object, class Arg1, class Arg2, class Arg3, class Result> | |
490 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> { | |
491 | ||
492 | template<class T> struct sig { typedef Result type; }; | |
493 | template <class RET, class A1, class A2, class A3> | |
494 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) { | |
495 | return (o->*func)(a1, a2, a3); | |
496 | } | |
497 | template <class RET, class A1, class A2, class A3> | |
498 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) { | |
499 | return (o.*func)(a1, a2, a3); | |
500 | } | |
501 | }; | |
502 | ||
503 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Result> | |
504 | struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> { | |
505 | ||
506 | template<class T> struct sig { typedef Result type; }; | |
507 | template <class RET, class A1, class A2, class A3, class A4> | |
508 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) { | |
509 | return func(a1, a2, a3, a4); | |
510 | } | |
511 | }; | |
512 | ||
513 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Result> | |
514 | struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> { | |
515 | ||
516 | template<class T> struct sig { typedef Result type; }; | |
517 | template <class RET, class A1, class A2, class A3, class A4> | |
518 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) { | |
519 | return func(a1, a2, a3, a4); | |
520 | } | |
521 | }; | |
522 | ||
523 | ||
524 | // -- function adaptors with 6 argument apply | |
525 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result> | |
526 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> { | |
527 | ||
528 | template<class T> struct sig { typedef Result type; }; | |
529 | template <class RET, class A1, class A2, class A3, class A4> | |
530 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) { | |
531 | return (o->*func)(a1, a2, a3, a4); | |
532 | } | |
533 | template <class RET, class A1, class A2, class A3, class A4> | |
534 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) { | |
535 | return (o.*func)(a1, a2, a3, a4); | |
536 | } | |
537 | }; | |
538 | ||
539 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result> | |
540 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> { | |
541 | ||
542 | template<class T> struct sig { typedef Result type; }; | |
543 | template <class RET, class A1, class A2, class A3, class A4> | |
544 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) { | |
545 | return (o->*func)(a1, a2, a3, a4); | |
546 | } | |
547 | template <class RET, class A1, class A2, class A3, class A4> | |
548 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) { | |
549 | return (o.*func)(a1, a2, a3, a4); | |
550 | } | |
551 | }; | |
552 | ||
553 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result> | |
554 | struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> { | |
555 | ||
556 | template<class T> struct sig { typedef Result type; }; | |
557 | template <class RET, class A1, class A2, class A3, class A4, class A5> | |
558 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { | |
559 | return func(a1, a2, a3, a4, a5); | |
560 | } | |
561 | }; | |
562 | ||
563 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result> | |
564 | struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> { | |
565 | ||
566 | template<class T> struct sig { typedef Result type; }; | |
567 | template <class RET, class A1, class A2, class A3, class A4, class A5> | |
568 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { | |
569 | return func(a1, a2, a3, a4, a5); | |
570 | } | |
571 | }; | |
572 | ||
573 | ||
574 | // -- function adaptors with 7 argument apply | |
575 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result> | |
576 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> { | |
577 | ||
578 | template<class T> struct sig { typedef Result type; }; | |
579 | template <class RET, class A1, class A2, class A3, class A4, class A5> | |
580 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { | |
581 | return (o->*func)(a1, a2, a3, a4, a5); | |
582 | } | |
583 | template <class RET, class A1, class A2, class A3, class A4, class A5> | |
584 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { | |
585 | return (o.*func)(a1, a2, a3, a4, a5); | |
586 | } | |
587 | }; | |
588 | ||
589 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result> | |
590 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> { | |
591 | ||
592 | template<class T> struct sig { typedef Result type; }; | |
593 | template <class RET, class A1, class A2, class A3, class A4, class A5> | |
594 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { | |
595 | return (o->*func)(a1, a2, a3, a4, a5); | |
596 | } | |
597 | template <class RET, class A1, class A2, class A3, class A4, class A5> | |
598 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { | |
599 | return (o.*func)(a1, a2, a3, a4, a5); | |
600 | } | |
601 | }; | |
602 | ||
603 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result> | |
604 | struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> { | |
605 | ||
606 | template<class T> struct sig { typedef Result type; }; | |
607 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> | |
608 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { | |
609 | return func(a1, a2, a3, a4, a5, a6); | |
610 | } | |
611 | }; | |
612 | ||
613 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result> | |
614 | struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> { | |
615 | ||
616 | template<class T> struct sig { typedef Result type; }; | |
617 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> | |
618 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { | |
619 | return func(a1, a2, a3, a4, a5, a6); | |
620 | } | |
621 | }; | |
622 | ||
623 | ||
624 | // -- function adaptors with 8 argument apply | |
625 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result> | |
626 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> { | |
627 | ||
628 | template<class T> struct sig { typedef Result type; }; | |
629 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> | |
630 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { | |
631 | return (o->*func)(a1, a2, a3, a4, a5, a6); | |
632 | } | |
633 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> | |
634 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { | |
635 | return (o.*func)(a1, a2, a3, a4, a5, a6); | |
636 | } | |
637 | }; | |
638 | ||
639 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result> | |
640 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> { | |
641 | ||
642 | template<class T> struct sig { typedef Result type; }; | |
643 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> | |
644 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { | |
645 | return (o->*func)(a1, a2, a3, a4, a5, a6); | |
646 | } | |
647 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6> | |
648 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { | |
649 | return (o.*func)(a1, a2, a3, a4, a5, a6); | |
650 | } | |
651 | }; | |
652 | ||
653 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result> | |
654 | struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> { | |
655 | ||
656 | template<class T> struct sig { typedef Result type; }; | |
657 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> | |
658 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { | |
659 | return func(a1, a2, a3, a4, a5, a6, a7); | |
660 | } | |
661 | }; | |
662 | ||
663 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result> | |
664 | struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> { | |
665 | ||
666 | template<class T> struct sig { typedef Result type; }; | |
667 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> | |
668 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { | |
669 | return func(a1, a2, a3, a4, a5, a6, a7); | |
670 | } | |
671 | }; | |
672 | ||
673 | ||
674 | // -- function adaptors with 9 argument apply | |
675 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result> | |
676 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> { | |
677 | ||
678 | template<class T> struct sig { typedef Result type; }; | |
679 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> | |
680 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { | |
681 | return (o->*func)(a1, a2, a3, a4, a5, a6, a7); | |
682 | } | |
683 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> | |
684 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { | |
685 | return (o.*func)(a1, a2, a3, a4, a5, a6, a7); | |
686 | } | |
687 | }; | |
688 | ||
689 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result> | |
690 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> { | |
691 | ||
692 | template<class T> struct sig { typedef Result type; }; | |
693 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> | |
694 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { | |
695 | return (o->*func)(a1, a2, a3, a4, a5, a6, a7); | |
696 | } | |
697 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7> | |
698 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { | |
699 | return (o.*func)(a1, a2, a3, a4, a5, a6, a7); | |
700 | } | |
701 | }; | |
702 | ||
703 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result> | |
704 | struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> { | |
705 | ||
706 | template<class T> struct sig { typedef Result type; }; | |
707 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> | |
708 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { | |
709 | return func(a1, a2, a3, a4, a5, a6, a7, a8); | |
710 | } | |
711 | }; | |
712 | ||
713 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result> | |
714 | struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> { | |
715 | ||
716 | template<class T> struct sig { typedef Result type; }; | |
717 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> | |
718 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { | |
719 | return func(a1, a2, a3, a4, a5, a6, a7, a8); | |
720 | } | |
721 | }; | |
722 | ||
723 | ||
724 | // -- function adaptors with 10 argument apply | |
725 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result> | |
726 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> { | |
727 | ||
728 | template<class T> struct sig { typedef Result type; }; | |
729 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> | |
730 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { | |
731 | return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8); | |
732 | } | |
733 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> | |
734 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { | |
735 | return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8); | |
736 | } | |
737 | }; | |
738 | ||
739 | template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result> | |
740 | struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> { | |
741 | ||
742 | template<class T> struct sig { typedef Result type; }; | |
743 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> | |
744 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { | |
745 | return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8); | |
746 | } | |
747 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> | |
748 | static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { | |
749 | return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8); | |
750 | } | |
751 | }; | |
752 | ||
753 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result> | |
754 | struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> { | |
755 | ||
756 | template<class T> struct sig { typedef Result type; }; | |
757 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> | |
758 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) { | |
759 | return func(a1, a2, a3, a4, a5, a6, a7, a8, a9); | |
760 | } | |
761 | }; | |
762 | ||
763 | template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result> | |
764 | struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> { | |
765 | ||
766 | template<class T> struct sig { typedef Result type; }; | |
767 | template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> | |
768 | static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) { | |
769 | return func(a1, a2, a3, a4, a5, a6, a7, a8, a9); | |
770 | } | |
771 | }; | |
772 | ||
773 | } // namespace lambda | |
774 | } // namespace boost | |
775 | ||
776 | #endif | |
777 | ||
778 | ||
779 | ||
780 | ||
781 | ||
782 | ||
783 | ||
784 | ||
785 | ||
786 | ||
787 | ||
788 | ||
789 |