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
24namespace boost {
25namespace lambda {
26
27namespace detail {
28
29BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
30
31template<class Tuple>
32struct 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
39template<>
40struct remove_references_from_elements<boost::tuples::null_type> {
41 typedef boost::tuples::null_type type;
42};
43
44}
45
46template <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
230template <class Func> struct function_adaptor<const Func>; // error
231
232// -- function adaptors with data member access
233template <class Object, class T>
234struct 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
301template <class Result>
302struct 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
311template <class Result>
312struct 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
323template <class Object, class Result>
324struct 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
337template <class Object, class Result>
338struct 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
351template <class Arg1, class Result>
352struct 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
361template <class Arg1, class Result>
362struct 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
373template <class Object, class Arg1, class Result>
374struct 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
389template <class Object, class Arg1, class Result>
390struct 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
403template <class Arg1, class Arg2, class Result>
404struct 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
413template <class Arg1, class Arg2, class Result>
414struct 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
425template <class Object, class Arg1, class Arg2, class Result>
426struct 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
439template <class Object, class Arg1, class Arg2, class Result>
440struct 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
453template <class Arg1, class Arg2, class Arg3, class Result>
454struct 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
463template <class Arg1, class Arg2, class Arg3, class Result>
464struct 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
475template <class Object, class Arg1, class Arg2, class Arg3, class Result>
476struct 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
489template <class Object, class Arg1, class Arg2, class Arg3, class Result>
490struct 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
503template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
504struct 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
513template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
514struct 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
525template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
526struct 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
539template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
540struct 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
553template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
554struct 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
563template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
564struct 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
575template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
576struct 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
589template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
590struct 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
603template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
604struct 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
613template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
614struct 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
625template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
626struct 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
639template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
640struct 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
653template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
654struct 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
663template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
664struct 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
675template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
676struct 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
689template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
690struct 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
703template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
704struct 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
713template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
714struct 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
725template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
726struct 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
739template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
740struct 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
753template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
754struct 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
763template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
764struct 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