1 | // Boost Lambda Library lambda_functor_base.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 | |
13 | #ifndef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP |
14 | #define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_HPP |
15 | |
16 | #include "boost/type_traits/add_reference.hpp" |
17 | #include "boost/type_traits/add_const.hpp" |
18 | #include "boost/type_traits/remove_const.hpp" |
19 | #include "boost/lambda/detail/lambda_fwd.hpp" |
20 | #include "boost/lambda/detail/lambda_traits.hpp" |
21 | |
22 | namespace boost { |
23 | namespace lambda { |
24 | |
25 | #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) |
26 | #pragma warning(push) |
27 | #pragma warning(disable:4512) //assignment operator could not be generated |
28 | #endif |
29 | |
30 | // for return type deductions we wrap bound argument to this class, |
31 | // which fulfils the base class contract for lambda_functors |
32 | template <class T> |
33 | class identity { |
34 | |
35 | T elem; |
36 | public: |
37 | |
38 | typedef T element_t; |
39 | |
40 | // take all parameters as const references. Note that non-const references |
41 | // stay as they are. |
42 | typedef typename boost::add_reference< |
43 | typename boost::add_const<T>::type |
44 | >::type par_t; |
45 | |
46 | explicit identity(par_t t) : elem(t) {} |
47 | |
48 | template <typename SigArgs> |
49 | struct sig { typedef typename boost::remove_const<element_t>::type type; }; |
50 | |
51 | template<class RET, CALL_TEMPLATE_ARGS> |
52 | RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return elem; } |
53 | }; |
54 | |
55 | #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) |
56 | #pragma warning(pop) |
57 | #endif |
58 | |
59 | template <class T> |
60 | inline lambda_functor<identity<T&> > var(T& t) { return identity<T&>(t); } |
61 | |
62 | // for lambda functors, var is an identity operator. It was forbidden |
63 | // at some point, but we might want to var something that can be a |
64 | // non-lambda functor or a lambda functor. |
65 | template <class T> |
66 | lambda_functor<T> var(const lambda_functor<T>& t) { return t; } |
67 | |
68 | template <class T> struct var_type { |
69 | typedef lambda_functor<identity<T&> > type; |
70 | }; |
71 | |
72 | |
73 | template <class T> |
74 | inline |
75 | lambda_functor<identity<typename bound_argument_conversion<const T>::type> > |
76 | constant(const T& t) { |
77 | return identity<typename bound_argument_conversion<const T>::type>(t); |
78 | } |
79 | template <class T> |
80 | lambda_functor<T> constant(const lambda_functor<T>& t) { return t; } |
81 | |
82 | template <class T> struct constant_type { |
83 | typedef |
84 | lambda_functor< |
85 | identity<typename bound_argument_conversion<const T>::type> |
86 | > type; |
87 | }; |
88 | |
89 | |
90 | |
91 | template <class T> |
92 | inline lambda_functor<identity<const T&> > constant_ref(const T& t) { |
93 | return identity<const T&>(t); |
94 | } |
95 | template <class T> |
96 | lambda_functor<T> constant_ref(const lambda_functor<T>& t) { return t; } |
97 | |
98 | template <class T> struct constant_ref_type { |
99 | typedef |
100 | lambda_functor<identity<const T&> > type; |
101 | }; |
102 | |
103 | |
104 | |
105 | // as_lambda_functor turns any types to lambda functors |
106 | // non-lambda_functors will be bound argument types |
107 | template <class T> |
108 | struct as_lambda_functor { |
109 | typedef typename |
110 | detail::remove_reference_and_cv<T>::type plain_T; |
111 | typedef typename |
112 | detail::IF<is_lambda_functor<plain_T>::value, |
113 | plain_T, |
114 | lambda_functor< |
115 | identity<typename bound_argument_conversion<T>::type> |
116 | > |
117 | >::RET type; |
118 | }; |
119 | |
120 | // turns arbitrary objects into lambda functors |
121 | template <class T> |
122 | inline |
123 | lambda_functor<identity<typename bound_argument_conversion<const T>::type> > |
124 | to_lambda_functor(const T& t) { |
125 | return identity<typename bound_argument_conversion<const T>::type>(t); |
126 | } |
127 | |
128 | template <class T> |
129 | inline lambda_functor<T> |
130 | to_lambda_functor(const lambda_functor<T>& t) { |
131 | return t; |
132 | } |
133 | |
134 | namespace detail { |
135 | |
136 | |
137 | |
138 | // In a call constify_rvals<T>::go(x) |
139 | // x should be of type T. If T is a non-reference type, do |
140 | // returns x as const reference. |
141 | // Otherwise the type doesn't change. |
142 | // The purpose of this class is to avoid |
143 | // 'cannot bind temporaries to non-const references' errors. |
144 | template <class T> struct constify_rvals { |
145 | template<class U> |
146 | static inline const U& go(const U& u) { return u; } |
147 | }; |
148 | |
149 | template <class T> struct constify_rvals<T&> { |
150 | template<class U> |
151 | static inline U& go(U& u) { return u; } |
152 | }; |
153 | |
154 | // check whether one of the elements of a tuple (cons list) is of type |
155 | // null_type. Needed, because the compiler goes ahead and instantiates |
156 | // sig template for nullary case even if the nullary operator() is not |
157 | // called |
158 | template <class T> struct is_null_type |
159 | { BOOST_STATIC_CONSTANT(bool, value = false); }; |
160 | |
161 | template <> struct is_null_type<null_type> |
162 | { BOOST_STATIC_CONSTANT(bool, value = true); }; |
163 | |
164 | template<class Tuple> struct has_null_type { |
165 | BOOST_STATIC_CONSTANT(bool, value = (is_null_type<typename Tuple::head_type>::value || has_null_type<typename Tuple::tail_type>::value)); |
166 | }; |
167 | template<> struct has_null_type<null_type> { |
168 | BOOST_STATIC_CONSTANT(bool, value = false); |
169 | }; |
170 | |
171 | |
172 | // helpers ------------------- |
173 | |
174 | |
175 | template<class Args, class SigArgs> |
176 | class deduce_argument_types_ { |
177 | typedef typename as_lambda_functor<typename Args::head_type>::type lf_t; |
178 | typedef typename lf_t::inherited::template sig<SigArgs>::type el_t; |
179 | public: |
180 | typedef |
181 | boost::tuples::cons< |
182 | el_t, |
183 | typename deduce_argument_types_<typename Args::tail_type, SigArgs>::type |
184 | > type; |
185 | }; |
186 | |
187 | template<class SigArgs> |
188 | class deduce_argument_types_<null_type, SigArgs> { |
189 | public: |
190 | typedef null_type type; |
191 | }; |
192 | |
193 | |
194 | // // note that tuples cannot have plain function types as elements. |
195 | // // Hence, all other types will be non-const, except references to |
196 | // // functions. |
197 | // template <class T> struct remove_reference_except_from_functions { |
198 | // typedef typename boost::remove_reference<T>::type t; |
199 | // typedef typename detail::IF<boost::is_function<t>::value, T, t>::RET type; |
200 | // }; |
201 | |
202 | template<class Args, class SigArgs> |
203 | class deduce_non_ref_argument_types_ { |
204 | typedef typename as_lambda_functor<typename Args::head_type>::type lf_t; |
205 | typedef typename lf_t::inherited::template sig<SigArgs>::type el_t; |
206 | public: |
207 | typedef |
208 | boost::tuples::cons< |
209 | // typename detail::remove_reference_except_from_functions<el_t>::type, |
210 | typename boost::remove_reference<el_t>::type, |
211 | typename deduce_non_ref_argument_types_<typename Args::tail_type, SigArgs>::type |
212 | > type; |
213 | }; |
214 | |
215 | template<class SigArgs> |
216 | class deduce_non_ref_argument_types_<null_type, SigArgs> { |
217 | public: |
218 | typedef null_type type; |
219 | }; |
220 | |
221 | // ------------- |
222 | |
223 | // take stored Args and Open Args, and return a const list with |
224 | // deduced elements (real return types) |
225 | template<class Args, class SigArgs> |
226 | class deduce_argument_types { |
227 | typedef typename deduce_argument_types_<Args, SigArgs>::type t1; |
228 | public: |
229 | typedef typename detail::IF< |
230 | has_null_type<t1>::value, null_type, t1 |
231 | >::RET type; |
232 | }; |
233 | |
234 | // take stored Args and Open Args, and return a const list with |
235 | // deduced elements (references are stripped from the element types) |
236 | |
237 | template<class Args, class SigArgs> |
238 | class deduce_non_ref_argument_types { |
239 | typedef typename deduce_non_ref_argument_types_<Args, SigArgs>::type t1; |
240 | public: |
241 | typedef typename detail::IF< |
242 | has_null_type<t1>::value, null_type, t1 |
243 | >::RET type; |
244 | }; |
245 | |
246 | template <int N, class Args, class SigArgs> |
247 | struct nth_return_type_sig { |
248 | typedef typename |
249 | as_lambda_functor< |
250 | typename boost::tuples::element<N, Args>::type |
251 | // typename tuple_element_as_reference<N, Args>::type |
252 | >::type lf_type; |
253 | |
254 | typedef typename lf_type::inherited::template sig<SigArgs>::type type; |
255 | }; |
256 | |
257 | template<int N, class Tuple> struct element_or_null { |
258 | typedef typename boost::tuples::element<N, Tuple>::type type; |
259 | }; |
260 | |
261 | template<int N> struct element_or_null<N, null_type> { |
262 | typedef null_type type; |
263 | }; |
264 | |
265 | |
266 | |
267 | |
268 | } // end detail |
269 | |
270 | // -- lambda_functor base --------------------- |
271 | |
272 | // the explicit_return_type_action case ----------------------------------- |
273 | template<class RET, class Args> |
274 | class lambda_functor_base<explicit_return_type_action<RET>, Args> |
275 | { |
276 | public: |
277 | Args args; |
278 | |
279 | typedef RET result_type; |
280 | |
281 | explicit lambda_functor_base(const Args& a) : args(a) {} |
282 | |
283 | template <class SigArgs> struct sig { typedef RET type; }; |
284 | |
285 | template<class RET_, CALL_TEMPLATE_ARGS> |
286 | RET call(CALL_FORMAL_ARGS) const |
287 | { |
288 | return detail::constify_rvals<RET>::go( |
289 | detail::r_select<RET>::go(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)); |
290 | } |
291 | }; |
292 | |
293 | // the protect_action case ----------------------------------- |
294 | template<class Args> |
295 | class lambda_functor_base<protect_action, Args> |
296 | { |
297 | public: |
298 | Args args; |
299 | public: |
300 | |
301 | explicit lambda_functor_base(const Args& a) : args(a) {} |
302 | |
303 | |
304 | template<class RET, CALL_TEMPLATE_ARGS> |
305 | RET call(CALL_FORMAL_ARGS) const |
306 | { |
307 | CALL_USE_ARGS; |
308 | return boost::tuples::get<0>(args); |
309 | } |
310 | |
311 | template<class SigArgs> struct sig { |
312 | // typedef typename detail::tuple_element_as_reference<0, SigArgs>::type type; |
313 | typedef typename boost::tuples::element<0, Args>::type type; |
314 | }; |
315 | }; |
316 | |
317 | // Do nothing -------------------------------------------------------- |
318 | class do_nothing_action {}; |
319 | |
320 | template<class Args> |
321 | class lambda_functor_base<do_nothing_action, Args> { |
322 | // Args args; |
323 | public: |
324 | // explicit lambda_functor_base(const Args& a) {} |
325 | lambda_functor_base() {} |
326 | |
327 | |
328 | template<class RET, CALL_TEMPLATE_ARGS> RET call(CALL_FORMAL_ARGS) const { |
329 | return CALL_USE_ARGS; |
330 | } |
331 | |
332 | template<class SigArgs> struct sig { typedef void type; }; |
333 | }; |
334 | |
335 | |
336 | // These specializations provide a shorter notation to define actions. |
337 | // These lambda_functor_base instances take care of the recursive evaluation |
338 | // of the arguments and pass the evaluated arguments to the apply function |
339 | // of an action class. To make action X work with these classes, one must |
340 | // instantiate the lambda_functor_base as: |
341 | // lambda_functor_base<action<ARITY, X>, Args> |
342 | // Where ARITY is the arity of the apply function in X |
343 | |
344 | // The return type is queried as: |
345 | // return_type_N<X, EvaluatedArgumentTypes>::type |
346 | // for which there must be a specialization. |
347 | |
348 | // Function actions, casts, throws,... all go via these classes. |
349 | |
350 | |
351 | template<class Act, class Args> |
352 | class lambda_functor_base<action<0, Act>, Args> |
353 | { |
354 | public: |
355 | // Args args; not needed |
356 | explicit lambda_functor_base(const Args& /*a*/) {} |
357 | |
358 | template<class SigArgs> struct sig { |
359 | typedef typename return_type_N<Act, null_type>::type type; |
360 | }; |
361 | |
362 | template<class RET, CALL_TEMPLATE_ARGS> |
363 | RET call(CALL_FORMAL_ARGS) const { |
364 | CALL_USE_ARGS; |
365 | return Act::template apply<RET>(); |
366 | } |
367 | }; |
368 | |
369 | |
370 | #if defined BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART |
371 | #error "Multiple defines of BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART" |
372 | #endif |
373 | |
374 | |
375 | #define BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(ARITY) \ |
376 | template<class Act, class Args> \ |
377 | class lambda_functor_base<action<ARITY, Act>, Args> \ |
378 | { \ |
379 | public: \ |
380 | Args args; \ |
381 | \ |
382 | explicit lambda_functor_base(const Args& a) : args(a) {} \ |
383 | \ |
384 | template<class SigArgs> struct sig { \ |
385 | typedef typename \ |
386 | detail::deduce_argument_types<Args, SigArgs>::type rets_t; \ |
387 | public: \ |
388 | typedef typename \ |
389 | return_type_N_prot<Act, rets_t>::type type; \ |
390 | }; \ |
391 | \ |
392 | \ |
393 | template<class RET, CALL_TEMPLATE_ARGS> \ |
394 | RET call(CALL_FORMAL_ARGS) const { \ |
395 | using boost::tuples::get; \ |
396 | using detail::constify_rvals; \ |
397 | using detail::r_select; \ |
398 | using detail::element_or_null; \ |
399 | using detail::deduce_argument_types; |
400 | |
401 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(1) |
402 | |
403 | typedef typename |
404 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
405 | typedef typename element_or_null<0, rets_t>::type rt0; |
406 | |
407 | return Act::template apply<RET>( |
408 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)) |
409 | ); |
410 | } |
411 | }; |
412 | |
413 | |
414 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(2) |
415 | |
416 | typedef typename |
417 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
418 | typedef typename element_or_null<0, rets_t>::type rt0; |
419 | typedef typename element_or_null<1, rets_t>::type rt1; |
420 | |
421 | return Act::template apply<RET>( |
422 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
423 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)) |
424 | ); |
425 | } |
426 | }; |
427 | |
428 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(3) |
429 | |
430 | typedef typename |
431 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
432 | |
433 | typedef typename element_or_null<0, rets_t>::type rt0; |
434 | typedef typename element_or_null<1, rets_t>::type rt1; |
435 | typedef typename element_or_null<2, rets_t>::type rt2; |
436 | |
437 | return Act::template apply<RET>( |
438 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
439 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), |
440 | constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)) |
441 | ); |
442 | } |
443 | }; |
444 | |
445 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(4) |
446 | typedef typename |
447 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
448 | typedef typename element_or_null<0, rets_t>::type rt0; |
449 | typedef typename element_or_null<1, rets_t>::type rt1; |
450 | typedef typename element_or_null<2, rets_t>::type rt2; |
451 | typedef typename element_or_null<3, rets_t>::type rt3; |
452 | |
453 | return Act::template apply<RET>( |
454 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
455 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), |
456 | constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), |
457 | constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)) |
458 | ); |
459 | } |
460 | }; |
461 | |
462 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(5) |
463 | typedef typename |
464 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
465 | typedef typename element_or_null<0, rets_t>::type rt0; |
466 | typedef typename element_or_null<1, rets_t>::type rt1; |
467 | typedef typename element_or_null<2, rets_t>::type rt2; |
468 | typedef typename element_or_null<3, rets_t>::type rt3; |
469 | typedef typename element_or_null<4, rets_t>::type rt4; |
470 | |
471 | return Act::template apply<RET>( |
472 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
473 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), |
474 | constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), |
475 | constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), |
476 | constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)) |
477 | ); |
478 | } |
479 | }; |
480 | |
481 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(6) |
482 | |
483 | typedef typename |
484 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
485 | typedef typename element_or_null<0, rets_t>::type rt0; |
486 | typedef typename element_or_null<1, rets_t>::type rt1; |
487 | typedef typename element_or_null<2, rets_t>::type rt2; |
488 | typedef typename element_or_null<3, rets_t>::type rt3; |
489 | typedef typename element_or_null<4, rets_t>::type rt4; |
490 | typedef typename element_or_null<5, rets_t>::type rt5; |
491 | |
492 | |
493 | return Act::template apply<RET>( |
494 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
495 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), |
496 | constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), |
497 | constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), |
498 | constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), |
499 | constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)) |
500 | ); |
501 | } |
502 | }; |
503 | |
504 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(7) |
505 | typedef typename |
506 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
507 | typedef typename element_or_null<0, rets_t>::type rt0; |
508 | typedef typename element_or_null<1, rets_t>::type rt1; |
509 | typedef typename element_or_null<2, rets_t>::type rt2; |
510 | typedef typename element_or_null<3, rets_t>::type rt3; |
511 | typedef typename element_or_null<4, rets_t>::type rt4; |
512 | typedef typename element_or_null<5, rets_t>::type rt5; |
513 | typedef typename element_or_null<6, rets_t>::type rt6; |
514 | |
515 | |
516 | return Act::template apply<RET>( |
517 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
518 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), |
519 | constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), |
520 | constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), |
521 | constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), |
522 | constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), |
523 | constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)) |
524 | ); |
525 | } |
526 | }; |
527 | |
528 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(8) |
529 | typedef typename |
530 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
531 | typedef typename element_or_null<0, rets_t>::type rt0; |
532 | typedef typename element_or_null<1, rets_t>::type rt1; |
533 | typedef typename element_or_null<2, rets_t>::type rt2; |
534 | typedef typename element_or_null<3, rets_t>::type rt3; |
535 | typedef typename element_or_null<4, rets_t>::type rt4; |
536 | typedef typename element_or_null<5, rets_t>::type rt5; |
537 | typedef typename element_or_null<6, rets_t>::type rt6; |
538 | typedef typename element_or_null<7, rets_t>::type rt7; |
539 | |
540 | return Act::template apply<RET>( |
541 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
542 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), |
543 | constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), |
544 | constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), |
545 | constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), |
546 | constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), |
547 | constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), |
548 | constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)) |
549 | ); |
550 | } |
551 | }; |
552 | |
553 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(9) |
554 | typedef typename |
555 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
556 | typedef typename element_or_null<0, rets_t>::type rt0; |
557 | typedef typename element_or_null<1, rets_t>::type rt1; |
558 | typedef typename element_or_null<2, rets_t>::type rt2; |
559 | typedef typename element_or_null<3, rets_t>::type rt3; |
560 | typedef typename element_or_null<4, rets_t>::type rt4; |
561 | typedef typename element_or_null<5, rets_t>::type rt5; |
562 | typedef typename element_or_null<6, rets_t>::type rt6; |
563 | typedef typename element_or_null<7, rets_t>::type rt7; |
564 | typedef typename element_or_null<8, rets_t>::type rt8; |
565 | |
566 | return Act::template apply<RET>( |
567 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
568 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), |
569 | constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), |
570 | constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), |
571 | constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), |
572 | constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), |
573 | constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), |
574 | constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)), |
575 | constify_rvals<rt8>::go(r_select<rt8>::go(get<8>(args), CALL_ACTUAL_ARGS)) |
576 | ); |
577 | } |
578 | }; |
579 | |
580 | BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART(10) |
581 | typedef typename |
582 | deduce_argument_types<Args, tuple<CALL_REFERENCE_TYPES> >::type rets_t; |
583 | typedef typename element_or_null<0, rets_t>::type rt0; |
584 | typedef typename element_or_null<1, rets_t>::type rt1; |
585 | typedef typename element_or_null<2, rets_t>::type rt2; |
586 | typedef typename element_or_null<3, rets_t>::type rt3; |
587 | typedef typename element_or_null<4, rets_t>::type rt4; |
588 | typedef typename element_or_null<5, rets_t>::type rt5; |
589 | typedef typename element_or_null<6, rets_t>::type rt6; |
590 | typedef typename element_or_null<7, rets_t>::type rt7; |
591 | typedef typename element_or_null<8, rets_t>::type rt8; |
592 | typedef typename element_or_null<9, rets_t>::type rt9; |
593 | |
594 | return Act::template apply<RET>( |
595 | constify_rvals<rt0>::go(r_select<rt0>::go(get<0>(args), CALL_ACTUAL_ARGS)), |
596 | constify_rvals<rt1>::go(r_select<rt1>::go(get<1>(args), CALL_ACTUAL_ARGS)), |
597 | constify_rvals<rt2>::go(r_select<rt2>::go(get<2>(args), CALL_ACTUAL_ARGS)), |
598 | constify_rvals<rt3>::go(r_select<rt3>::go(get<3>(args), CALL_ACTUAL_ARGS)), |
599 | constify_rvals<rt4>::go(r_select<rt4>::go(get<4>(args), CALL_ACTUAL_ARGS)), |
600 | constify_rvals<rt5>::go(r_select<rt5>::go(get<5>(args), CALL_ACTUAL_ARGS)), |
601 | constify_rvals<rt6>::go(r_select<rt6>::go(get<6>(args), CALL_ACTUAL_ARGS)), |
602 | constify_rvals<rt7>::go(r_select<rt7>::go(get<7>(args), CALL_ACTUAL_ARGS)), |
603 | constify_rvals<rt8>::go(r_select<rt8>::go(get<8>(args), CALL_ACTUAL_ARGS)), |
604 | constify_rvals<rt9>::go(r_select<rt9>::go(get<9>(args), CALL_ACTUAL_ARGS)) |
605 | ); |
606 | } |
607 | }; |
608 | |
609 | #undef BOOST_LAMBDA_LAMBDA_FUNCTOR_BASE_FIRST_PART |
610 | |
611 | |
612 | } // namespace lambda |
613 | } // namespace boost |
614 | |
615 | #endif |
616 | |