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 | |
790 | |