ceph/src/boost/boost/lambda/detail/lambda_functor_base.hpp

   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