• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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>
applyboost::lambda::function_adaptor181   static RET apply(A1& a1) {
182     return a1();
183   }
184   template<class RET, class A1, class A2>
applyboost::lambda::function_adaptor185   static RET apply(A1& a1, A2& a2) {
186     return a1(a2);
187   }
188   template<class RET, class A1, class A2, class A3>
applyboost::lambda::function_adaptor189   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>
applyboost::lambda::function_adaptor193   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>
applyboost::lambda::function_adaptor197   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>
applyboost::lambda::function_adaptor201   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>
applyboost::lambda::function_adaptor206   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>
applyboost::lambda::function_adaptor212   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>
applyboost::lambda::function_adaptor218   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>
applyboost::lambda::function_adaptor224   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>
applyboost::lambda::function_adaptor266   static RET apply( T Object::*data, Object& o) {
267     return o.*data;
268   }
269   template <class RET>
applyboost::lambda::function_adaptor270   static RET apply( T Object::*data, const Object& o) {
271     return o.*data;
272   }
273   template <class RET>
applyboost::lambda::function_adaptor274   static RET apply( T Object::*data, volatile Object& o) {
275     return o.*data;
276   }
277   template <class RET>
applyboost::lambda::function_adaptor278   static RET apply( T Object::*data, const volatile Object& o) {
279     return o.*data;
280   }
281   template <class RET>
applyboost::lambda::function_adaptor282   static RET apply( T Object::*data, Object* o) {
283     return o->*data;
284   }
285   template <class RET>
applyboost::lambda::function_adaptor286   static RET apply( T Object::*data, const Object* o) {
287     return o->*data;
288   }
289   template <class RET>
applyboost::lambda::function_adaptor290   static RET apply( T Object::*data, volatile Object* o) {
291     return o->*data;
292   }
293   template <class RET>
applyboost::lambda::function_adaptor294   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>
applyboost::lambda::function_adaptor306   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>
applyboost::lambda::function_adaptor316   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>
applyboost::lambda::function_adaptor328   static Result apply( Result (Object::*func)() const, const Object* o) {
329     return (o->*func)();
330   }
331   template <class RET>
applyboost::lambda::function_adaptor332   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>
applyboost::lambda::function_adaptor342   static Result apply( Result (Object::*func)(), Object* o) {
343     return (o->*func)();
344   }
345   template <class RET>
applyboost::lambda::function_adaptor346   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>
applyboost::lambda::function_adaptor356   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>
applyboost::lambda::function_adaptor366   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>
applyboost::lambda::function_adaptor378   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>
applyboost::lambda::function_adaptor383   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>
applyboost::lambda::function_adaptor394   static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {
395     return (o->*func)(a1);
396   }
397   template <class RET, class A1>
applyboost::lambda::function_adaptor398   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>
applyboost::lambda::function_adaptor408   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>
applyboost::lambda::function_adaptor418   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>
applyboost::lambda::function_adaptor430   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>
applyboost::lambda::function_adaptor434   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>
applyboost::lambda::function_adaptor444   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>
applyboost::lambda::function_adaptor448   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>
applyboost::lambda::function_adaptor458   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>
applyboost::lambda::function_adaptor468   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>
applyboost::lambda::function_adaptor480   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>
applyboost::lambda::function_adaptor484   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>
applyboost::lambda::function_adaptor494   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>
applyboost::lambda::function_adaptor498   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>
applyboost::lambda::function_adaptor508   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>
applyboost::lambda::function_adaptor518   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>
applyboost::lambda::function_adaptor530   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>
applyboost::lambda::function_adaptor534   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>
applyboost::lambda::function_adaptor544   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>
applyboost::lambda::function_adaptor548   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>
applyboost::lambda::function_adaptor558   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>
applyboost::lambda::function_adaptor568   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>
applyboost::lambda::function_adaptor580   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>
applyboost::lambda::function_adaptor584   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>
applyboost::lambda::function_adaptor594   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>
applyboost::lambda::function_adaptor598   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>
applyboost::lambda::function_adaptor608   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>
applyboost::lambda::function_adaptor618   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>
applyboost::lambda::function_adaptor630   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>
applyboost::lambda::function_adaptor634   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>
applyboost::lambda::function_adaptor644   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>
applyboost::lambda::function_adaptor648   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>
applyboost::lambda::function_adaptor658   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>
applyboost::lambda::function_adaptor668   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>
applyboost::lambda::function_adaptor680   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>
applyboost::lambda::function_adaptor684   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>
applyboost::lambda::function_adaptor694   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>
applyboost::lambda::function_adaptor698   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>
applyboost::lambda::function_adaptor708   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>
applyboost::lambda::function_adaptor718   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>
applyboost::lambda::function_adaptor730   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>
applyboost::lambda::function_adaptor734   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>
applyboost::lambda::function_adaptor744   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>
applyboost::lambda::function_adaptor748   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>
applyboost::lambda::function_adaptor758   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>
applyboost::lambda::function_adaptor768   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