1 // Boost Lambda Library - function_adaptors.hpp ----------------------------
3 // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
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)
9 // For more information, see www.boost.org
12 #ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
13 #define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
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"
29 BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
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
40 struct remove_references_from_elements<boost::tuples::null_type> {
41 typedef boost::tuples::null_type type;
46 template <class Func> struct function_adaptor {
48 typedef typename detail::remove_reference_and_cv<Func>::type plainF;
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
61 struct result_converter<Tuple, 0, false>
65 struct result_converter<Tuple, 1, false>
67 typename tuples::element<1, Tuple>::type)
71 struct result_converter<Tuple, 2, false>
73 typename tuples::element<1, Tuple>::type,
74 typename tuples::element<2, Tuple>::type)
78 struct result_converter<Tuple, 3, false>
80 typename tuples::element<1, Tuple>::type,
81 typename tuples::element<2, Tuple>::type,
82 typename tuples::element<3, Tuple>::type)
86 struct result_converter<Tuple, 4, false>
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)
95 struct result_converter<Tuple, 5, false>
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)
104 template<class Tuple>
105 struct result_converter<Tuple, 6, false>
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)
115 template<class Tuple>
116 struct result_converter<Tuple, 7, false>
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)
127 template<class Tuple>
128 struct result_converter<Tuple, 8, false>
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)
140 template<class Tuple>
141 struct result_converter<Tuple, 9, false>
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)
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
161 template <class Args>
165 , tuples::length<typename Args::tail_type>::value
166 , detail::has_sig<plainF>::value
169 #else // BOOST_NO_RESULT_OF
171 template <class Args> class sig {
172 typedef typename detail::remove_reference_and_cv<Func>::type plainF;
174 typedef typename plainF::template sig<
175 typename detail::remove_references_from_elements<Args>::type
180 template<class RET, class A1>
181 static RET apply(A1& a1) {
184 template<class RET, class A1, class A2>
185 static RET apply(A1& a1, A2& a2) {
188 template<class RET, class A1, class A2, class A3>
189 static RET apply(A1& a1, A2& a2, A3& a3) {
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);
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);
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);
204 template<class RET, class A1, class A2, class A3, class A4, class A5, class A6,
206 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6,
208 return a1(a2, a3, a4, a5, a6, a7);
210 template<class RET, class A1, class A2, class A3, class A4, class A5, class A6,
212 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6,
214 return a1(a2, a3, a4, a5, a6, a7, a8);
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);
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);
230 template <class Func> struct function_adaptor<const Func>; // error
232 // -- function adaptors with data member access
233 template <class Object, class T>
234 struct function_adaptor<T Object::*> {
236 // typedef detail::unspecified type;
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<
247 typedef typename detail::IF<boost::is_const<unref_type>::value,
248 typename boost::add_const<T>::type,
250 >::RET properly_consted_return_type;
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;
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
266 static RET apply( T Object::*data, Object& o) {
270 static RET apply( T Object::*data, const Object& o) {
274 static RET apply( T Object::*data, volatile Object& o) {
278 static RET apply( T Object::*data, const volatile Object& o) {
282 static RET apply( T Object::*data, Object* o) {
286 static RET apply( T Object::*data, const Object* o) {
290 static RET apply( T Object::*data, volatile Object* o) {
294 static RET apply( T Object::*data, const volatile Object* o) {
299 // -- function adaptors with 1 argument apply
301 template <class Result>
302 struct function_adaptor<Result (void)> {
304 template<class T> struct sig { typedef Result type; };
306 static Result apply(Result (*func)()) {
311 template <class Result>
312 struct function_adaptor<Result (*)(void)> {
314 template<class T> struct sig { typedef Result type; };
316 static Result apply(Result (*func)()) {
322 // -- function adaptors with 2 argument apply
323 template <class Object, class Result>
324 struct function_adaptor<Result (Object::*)() const> {
326 template<class T> struct sig { typedef Result type; };
328 static Result apply( Result (Object::*func)() const, const Object* o) {
332 static Result apply( Result (Object::*func)() const, const Object& o) {
337 template <class Object, class Result>
338 struct function_adaptor<Result (Object::*)()> {
340 template<class T> struct sig { typedef Result type; };
342 static Result apply( Result (Object::*func)(), Object* o) {
346 static Result apply( Result (Object::*func)(), Object& o) {
351 template <class Arg1, class Result>
352 struct function_adaptor<Result (Arg1)> {
354 template<class T> struct sig { typedef Result type; };
355 template <class RET, class A1>
356 static Result apply(Result (*func)(Arg1), A1& a1) {
361 template <class Arg1, class Result>
362 struct function_adaptor<Result (*)(Arg1)> {
364 template<class T> struct sig { typedef Result type; };
365 template <class RET, class A1>
366 static Result apply(Result (*func)(Arg1), A1& a1) {
372 // -- function adaptors with 3 argument apply
373 template <class Object, class Arg1, class Result>
374 struct function_adaptor<Result (Object::*)(Arg1) const> {
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,
380 return (o->*func)(a1);
382 template <class RET, class A1>
383 static Result apply( Result (Object::*func)(Arg1) const, const Object& o,
385 return (o.*func)(a1);
389 template <class Object, class Arg1, class Result>
390 struct function_adaptor<Result (Object::*)(Arg1)> {
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);
397 template <class RET, class A1>
398 static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) {
399 return (o.*func)(a1);
403 template <class Arg1, class Arg2, class Result>
404 struct function_adaptor<Result (Arg1, Arg2)> {
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) {
413 template <class Arg1, class Arg2, class Result>
414 struct function_adaptor<Result (*)(Arg1, Arg2)> {
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) {
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> {
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);
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);
439 template <class Object, class Arg1, class Arg2, class Result>
440 struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {
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);
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);
453 template <class Arg1, class Arg2, class Arg3, class Result>
454 struct function_adaptor<Result (Arg1, Arg2, Arg3)> {
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);
463 template <class Arg1, class Arg2, class Arg3, class Result>
464 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
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);
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> {
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);
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);
489 template <class Object, class Arg1, class Arg2, class Arg3, class Result>
490 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {
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);
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);
503 template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
504 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {
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);
513 template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
514 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
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);
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> {
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);
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);
539 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
540 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {
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);
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);
553 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
554 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {
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);
563 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
564 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
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);
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> {
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);
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);
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)> {
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);
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);
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)> {
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);
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)> {
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);
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> {
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);
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);
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)> {
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);
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);
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)> {
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);
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)> {
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);
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> {
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);
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);
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)> {
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);
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);
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)> {
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);
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)> {
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);
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> {
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);
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);
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)> {
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);
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);
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)> {
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);
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)> {
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);
773 } // namespace lambda