Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
1 // Boost Lambda Library - function_adaptors.hpp ----------------------------
3 // Copyright (C) 1999, 2000 Jaakko Järvi (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/type_traits/same_traits.hpp"
20 template <class Func> struct function_adaptor {
22 // we do not know the return type off-hand, we must ask it from Func
23 template <class Args> class sig {
24 typedef typename Args::head_type F;
25 typedef typename detail::remove_reference_and_cv<Func>::type plainF;
27 // To sig we pass a cons list, where the head is the function object type
28 // itself (potentially cv-qualified)
29 // and the tail contains the types of the actual arguments to be passed
30 // to the function object. The arguments can be cv qualified
32 typedef typename plainF::template sig<Args>::type type;
35 template<class RET, class A1>
36 static RET apply(A1& a1) {
39 template<class RET, class A1, class A2>
40 static RET apply(A1& a1, A2& a2) {
43 template<class RET, class A1, class A2, class A3>
44 static RET apply(A1& a1, A2& a2, A3& a3) {
47 template<class RET, class A1, class A2, class A3, class A4>
48 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
49 return a1(a2, a3, a4);
51 template<class RET, class A1, class A2, class A3, class A4, class A5>
52 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
53 return a1(a2, a3, a4, a5);
55 template<class RET, class A1, class A2, class A3, class A4, class A5, class A6>
56 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
57 return a1(a2, a3, a4, a5, a6);
59 template<class RET, class A1, class A2, class A3, class A4, class A5, class A6,
61 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6,
63 return a1(a2, a3, a4, a5, a6, a7);
65 template<class RET, class A1, class A2, class A3, class A4, class A5, class A6,
67 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6,
69 return a1(a2, a3, a4, a5, a6, a7, a8);
71 template<class RET, class A1, class A2, class A3, class A4, class A5, class A6,
72 class A7, class A8, class A9>
73 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6,
74 A7& a7, A8& a8, A9& a9) {
75 return a1(a2, a3, a4, a5, a6, a7, a8, a9);
77 template<class RET, class A1, class A2, class A3, class A4, class A5, class A6,
78 class A7, class A8, class A9, class A10>
79 static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6,
80 A7& a7, A8& a8, A9& a9, A10& a10) {
81 return a1(a2, a3, a4, a5, a6, a7, a8, a9, a10);
85 template <class Func> struct function_adaptor<const Func>; // error
87 // -- function adaptors with data member access
88 template <class Object, class T>
89 struct function_adaptor<T Object::*> {
91 // typedef detail::unspecified type;
93 // T can have qualifiers and can be a reference type
94 // We get the return type by adding const, if the object through which
95 // the data member is accessed is const, and finally adding a reference
96 template<class Args> class sig {
97 typedef typename boost::tuples::element<1, Args>::type argument_type;
99 typedef typename detail::IF<boost::is_const<argument_type>::value,
100 typename boost::add_const<T>::type,
102 >::RET properly_consted_return_type;
104 typedef typename detail::IF<
105 boost::is_volatile<properly_consted_return_type>::value,
106 typename boost::add_volatile<properly_consted_return_type>::type,
107 properly_consted_return_type
108 >::RET properly_cvd_return_type;
113 boost::add_reference<properly_cvd_return_type>::type type;
117 static RET apply( T Object::*data, Object& o) {
121 static RET apply( T Object::*data, const Object& o) {
125 static RET apply( T Object::*data, volatile Object& o) {
129 static RET apply( T Object::*data, const volatile Object& o) {
133 static RET apply( T Object::*data, Object* o) {
137 static RET apply( T Object::*data, const Object* o) {
141 static RET apply( T Object::*data, volatile Object* o) {
145 static RET apply( T Object::*data, const volatile Object* o) {
150 // -- function adaptors with 1 argument apply
152 template <class Result>
153 struct function_adaptor<Result (void)> {
155 template<class T> struct sig { typedef Result type; };
157 static Result apply(Result (*func)()) {
162 template <class Result>
163 struct function_adaptor<Result (*)(void)> {
165 template<class T> struct sig { typedef Result type; };
167 static Result apply(Result (*func)()) {
173 // -- function adaptors with 2 argument apply
174 template <class Object, class Result>
175 struct function_adaptor<Result (Object::*)() const> {
177 template<class T> struct sig { typedef Result type; };
179 static Result apply( Result (Object::*func)() const, const Object* o) {
183 static Result apply( Result (Object::*func)() const, const Object& o) {
188 template <class Object, class Result>
189 struct function_adaptor<Result (Object::*)()> {
191 template<class T> struct sig { typedef Result type; };
193 static Result apply( Result (Object::*func)(), Object* o) {
197 static Result apply( Result (Object::*func)(), Object& o) {
202 template <class Arg1, class Result>
203 struct function_adaptor<Result (Arg1)> {
205 template<class T> struct sig { typedef Result type; };
206 template <class RET, class A1>
207 static Result apply(Result (*func)(Arg1), A1& a1) {
212 template <class Arg1, class Result>
213 struct function_adaptor<Result (*)(Arg1)> {
215 template<class T> struct sig { typedef Result type; };
216 template <class RET, class A1>
217 static Result apply(Result (*func)(Arg1), A1& a1) {
223 // -- function adaptors with 3 argument apply
224 template <class Object, class Arg1, class Result>
225 struct function_adaptor<Result (Object::*)(Arg1) const> {
227 template<class T> struct sig { typedef Result type; };
228 template <class RET, class A1>
229 static Result apply( Result (Object::*func)(Arg1) const, const Object* o,
231 return (o->*func)(a1);
233 template <class RET, class A1>
234 static Result apply( Result (Object::*func)(Arg1) const, const Object& o,
236 return (o.*func)(a1);
240 template <class Object, class Arg1, class Result>
241 struct function_adaptor<Result (Object::*)(Arg1)> {
243 template<class T> struct sig { typedef Result type; };
244 template <class RET, class A1>
245 static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {
246 return (o->*func)(a1);
248 template <class RET, class A1>
249 static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) {
250 return (o.*func)(a1);
254 template <class Arg1, class Arg2, class Result>
255 struct function_adaptor<Result (Arg1, Arg2)> {
257 template<class T> struct sig { typedef Result type; };
258 template <class RET, class A1, class A2>
259 static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
264 template <class Arg1, class Arg2, class Result>
265 struct function_adaptor<Result (*)(Arg1, Arg2)> {
267 template<class T> struct sig { typedef Result type; };
268 template <class RET, class A1, class A2>
269 static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
275 // -- function adaptors with 4 argument apply
276 template <class Object, class Arg1, class Arg2, class Result>
277 struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {
279 template<class T> struct sig { typedef Result type; };
280 template <class RET, class A1, class A2>
281 static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) {
282 return (o->*func)(a1, a2);
284 template <class RET, class A1, class A2>
285 static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) {
286 return (o.*func)(a1, a2);
290 template <class Object, class Arg1, class Arg2, class Result>
291 struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {
293 template<class T> struct sig { typedef Result type; };
294 template <class RET, class A1, class A2>
295 static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) {
296 return (o->*func)(a1, a2);
298 template <class RET, class A1, class A2>
299 static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) {
300 return (o.*func)(a1, a2);
304 template <class Arg1, class Arg2, class Arg3, class Result>
305 struct function_adaptor<Result (Arg1, Arg2, Arg3)> {
307 template<class T> struct sig { typedef Result type; };
308 template <class RET, class A1, class A2, class A3>
309 static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
310 return func(a1, a2, a3);
314 template <class Arg1, class Arg2, class Arg3, class Result>
315 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
317 template<class T> struct sig { typedef Result type; };
318 template <class RET, class A1, class A2, class A3>
319 static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
320 return func(a1, a2, a3);
325 // -- function adaptors with 5 argument apply
326 template <class Object, class Arg1, class Arg2, class Arg3, class Result>
327 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {
329 template<class T> struct sig { typedef Result type; };
330 template <class RET, class A1, class A2, class A3>
331 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) {
332 return (o->*func)(a1, a2, a3);
334 template <class RET, class A1, class A2, class A3>
335 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) {
336 return (o.*func)(a1, a2, a3);
340 template <class Object, class Arg1, class Arg2, class Arg3, class Result>
341 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {
343 template<class T> struct sig { typedef Result type; };
344 template <class RET, class A1, class A2, class A3>
345 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) {
346 return (o->*func)(a1, a2, a3);
348 template <class RET, class A1, class A2, class A3>
349 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) {
350 return (o.*func)(a1, a2, a3);
354 template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
355 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {
357 template<class T> struct sig { typedef Result type; };
358 template <class RET, class A1, class A2, class A3, class A4>
359 static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
360 return func(a1, a2, a3, a4);
364 template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
365 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
367 template<class T> struct sig { typedef Result type; };
368 template <class RET, class A1, class A2, class A3, class A4>
369 static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
370 return func(a1, a2, a3, a4);
375 // -- function adaptors with 6 argument apply
376 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
377 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {
379 template<class T> struct sig { typedef Result type; };
380 template <class RET, class A1, class A2, class A3, class A4>
381 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
382 return (o->*func)(a1, a2, a3, a4);
384 template <class RET, class A1, class A2, class A3, class A4>
385 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
386 return (o.*func)(a1, a2, a3, a4);
390 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
391 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {
393 template<class T> struct sig { typedef Result type; };
394 template <class RET, class A1, class A2, class A3, class A4>
395 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
396 return (o->*func)(a1, a2, a3, a4);
398 template <class RET, class A1, class A2, class A3, class A4>
399 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
400 return (o.*func)(a1, a2, a3, a4);
404 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
405 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {
407 template<class T> struct sig { typedef Result type; };
408 template <class RET, class A1, class A2, class A3, class A4, class A5>
409 static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
410 return func(a1, a2, a3, a4, a5);
414 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
415 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
417 template<class T> struct sig { typedef Result type; };
418 template <class RET, class A1, class A2, class A3, class A4, class A5>
419 static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
420 return func(a1, a2, a3, a4, a5);
425 // -- function adaptors with 7 argument apply
426 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
427 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> {
429 template<class T> struct sig { typedef Result type; };
430 template <class RET, class A1, class A2, class A3, class A4, class A5>
431 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) {
432 return (o->*func)(a1, a2, a3, a4, a5);
434 template <class RET, class A1, class A2, class A3, class A4, class A5>
435 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) {
436 return (o.*func)(a1, a2, a3, a4, a5);
440 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
441 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
443 template<class T> struct sig { typedef Result type; };
444 template <class RET, class A1, class A2, class A3, class A4, class A5>
445 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
446 return (o->*func)(a1, a2, a3, a4, a5);
448 template <class RET, class A1, class A2, class A3, class A4, class A5>
449 static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
450 return (o.*func)(a1, a2, a3, a4, a5);
454 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
455 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
457 template<class T> struct sig { typedef Result type; };
458 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
459 static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
460 return func(a1, a2, a3, a4, a5, a6);
464 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
465 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
467 template<class T> struct sig { typedef Result type; };
468 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
469 static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
470 return func(a1, a2, a3, a4, a5, a6);
475 // -- function adaptors with 8 argument apply
476 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
477 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> {
479 template<class T> struct sig { typedef Result type; };
480 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
481 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) {
482 return (o->*func)(a1, a2, a3, a4, a5, a6);
484 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
485 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) {
486 return (o.*func)(a1, a2, a3, a4, a5, a6);
490 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
491 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
493 template<class T> struct sig { typedef Result type; };
494 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
495 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) {
496 return (o->*func)(a1, a2, a3, a4, a5, a6);
498 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
499 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) {
500 return (o.*func)(a1, a2, a3, a4, a5, a6);
504 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
505 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
507 template<class T> struct sig { typedef Result type; };
508 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
509 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) {
510 return func(a1, a2, a3, a4, a5, a6, a7);
514 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
515 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
517 template<class T> struct sig { typedef Result type; };
518 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
519 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) {
520 return func(a1, a2, a3, a4, a5, a6, a7);
525 // -- function adaptors with 9 argument apply
526 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
527 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> {
529 template<class T> struct sig { typedef Result type; };
530 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
531 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) {
532 return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
534 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
535 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) {
536 return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
540 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
541 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
543 template<class T> struct sig { typedef Result type; };
544 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
545 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) {
546 return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
548 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
549 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) {
550 return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
554 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
555 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
557 template<class T> struct sig { typedef Result type; };
558 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
559 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) {
560 return func(a1, a2, a3, a4, a5, a6, a7, a8);
564 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
565 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
567 template<class T> struct sig { typedef Result type; };
568 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
569 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) {
570 return func(a1, a2, a3, a4, a5, a6, a7, a8);
575 // -- function adaptors with 10 argument apply
576 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
577 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> {
579 template<class T> struct sig { typedef Result type; };
580 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
581 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) {
582 return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
584 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
585 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) {
586 return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
590 template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
591 struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
593 template<class T> struct sig { typedef Result type; };
594 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
595 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) {
596 return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
598 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
599 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) {
600 return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
604 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
605 struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
607 template<class T> struct sig { typedef Result type; };
608 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
609 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) {
610 return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
614 template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
615 struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
617 template<class T> struct sig { typedef Result type; };
618 template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
619 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) {
620 return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
624 } // namespace lambda