ceph/src/boost/boost/spirit/home/classic/phoenix/functions.hpp

   1 /*=============================================================================
   2     Phoenix V1.2.1
   3     Copyright (c) 2001-2002 Joel de Guzman
   4
   5   Distributed under the Boost Software License, Version 1.0. (See accompanying
   6   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7 ==============================================================================*/
   8 #ifndef PHOENIX_FUNCTIONS_HPP
   9 #define PHOENIX_FUNCTIONS_HPP
  10
  11 ///////////////////////////////////////////////////////////////////////////////
  12 #include <boost/spirit/home/classic/phoenix/actor.hpp>
  13 #include <boost/spirit/home/classic/phoenix/composite.hpp>
  14
  15 ///////////////////////////////////////////////////////////////////////////////
  16 namespace phoenix {
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //
  20 //  function class
  21 //
  22 //      Lazy functions
  23 //
  24 //      This class provides a mechanism for lazily evaluating functions.
  25 //      Syntactically, a lazy function looks like an ordinary C/C++
  26 //      function. The function call looks the same. However, unlike
  27 //      ordinary functions, the actual function execution is deferred.
  28 //      (see actor.hpp, primitives.hpp and composite.hpp for an
  29 //      overview). For example here are sample factorial function calls:
  30 //
  31 //          factorial(4)
  32 //          factorial(arg1)
  33 //          factorial(arg1 * 6)
  34 //
  35 //      These functions are automatically lazily bound unlike ordinary
  36 //      function pointers or functor objects that need to be explicitly
  37 //      bound through the bind function (see binders.hpp).
  38 //
  39 //      A lazy function works in conjunction with a user defined functor
  40 //      (as usual with a member operator()). Only special forms of
  41 //      functor objects are allowed. This is required to enable true
  42 //      polymorphism (STL style monomorphic functors and function
  43 //      pointers can still be used through the bind facility in
  44 //      binders.hpp).
  45 //
  46 //      This special functor is expected to have a nested template class
  47 //      result<A...TN> (where N is the number of arguments of its
  48 //      member operator()). The nested template class result should have
  49 //      a typedef 'type' that reflects the return type of its member
  50 //      operator(). This is essentially a type computer that answers the
  51 //      metaprogramming question "Given arguments of type A...TN, what
  52 //      will be the operator()'s return type?".
  53 //
  54 //      There is a special case for functors that accept no arguments.
  55 //      Such nullary functors are only required to define a typedef
  56 //      result_type that reflects the return type of its operator().
  57 //
  58 //      Here's an example of a simple functor that computes the
  59 //      factorial of a number:
  60 //
  61 //          struct factorial_impl {
  62 //
  63 //              template <typename Arg>
  64 //              struct result { typedef Arg type; };
  65 //
  66 //              template <typename Arg>
  67 //              Arg operator()(Arg n) const
  68 //              { return (n <= 0) ? 1 : n * this->operator()(n-1); }
  69 //          };
  70 //
  71 //      As can be seen, the functor can be polymorphic. Its arguments
  72 //      and return type are not fixed to a particular type. The example
  73 //      above for example, can handle any type as long as it can carry
  74 //      out the required operations (i.e. <=, * and -).
  75 //
  76 //      We can now declare and instantiate a lazy 'factorial' function:
  77 //
  78 //          function<factorial_impl> factorial;
  79 //
  80 //      Invoking a lazy function 'factorial' does not immediately
  81 //      execute the functor factorial_impl. Instead, a composite (see
  82 //      composite.hpp) object is created and returned to the caller.
  83 //      Example:
  84 //
  85 //          factorial(arg1)
  86 //
  87 //      does nothing more than return a composite. A second function
  88 //      call will invoke the actual factorial function. Example:
  89 //
  90 //          int i = 4;
  91 //          cout << factorial(arg1)(i);
  92 //
  93 //      will print out "24".
  94 //
  95 //      Take note that in certain cases (e.g. for functors with state),
  96 //      an instance may be passed on to the constructor. Example:
  97 //
  98 //          function<factorial_impl> factorial(ftor);
  99 //
 100 //      where ftor is an instance of factorial_impl (this is not
 101 //      necessary in this case since factorial is a simple stateless
 102 //      functor). Take care though when using functors with state
 103 //      because the functors are taken in by value. It is best to keep
 104 //      the data manipulated by a functor outside the functor itself and
 105 //      keep a reference to this data inside the functor. Also, it is
 106 //      best to keep functors as small as possible.
 107 //
 108 ///////////////////////////////////////////////////////////////////////////////
 109 template <typename OperationT>
 110 struct function {
 111
 112     function() : op() {}
 113     function(OperationT const& op_) : op(op_) {}
 114
 115     actor<composite<OperationT> >
 116     operator()() const;
 117
 118     template <typename A>
 119     typename impl::make_composite<OperationT, A>::type
 120     operator()(A const& a) const;
 121
 122     template <typename A, typename B>
 123     typename impl::make_composite<OperationT, A, B>::type
 124     operator()(A const& a, B const& b) const;
 125
 126     template <typename A, typename B, typename C>
 127     typename impl::make_composite<OperationT, A, B, C>::type
 128     operator()(A const& a, B const& b, C const& c) const;
 129
 130 #if PHOENIX_LIMIT > 3
 131
 132     template <typename A, typename B, typename C, typename D>
 133     typename impl::make_composite<OperationT, A, B, C, D>::type
 134     operator()(A const& a, B const& b, C const& c, D const& d) const;
 135
 136     template <typename A, typename B, typename C, typename D, typename E>
 137     typename impl::make_composite<
 138         OperationT, A, B, C, D, E
 139     >::type
 140     operator()(
 141         A const& a, B const& b, C const& c, D const& d, E const& e
 142     ) const;
 143
 144     template <
 145         typename A, typename B, typename C, typename D, typename E,
 146         typename F
 147     >
 148     typename impl::make_composite<
 149         OperationT, A, B, C, D, E, F
 150     >::type
 151     operator()(
 152         A const& a, B const& b, C const& c, D const& d, E const& e,
 153         F const& f
 154     ) const;
 155
 156 #if PHOENIX_LIMIT > 6
 157
 158     template <
 159         typename A, typename B, typename C, typename D, typename E,
 160         typename F, typename G
 161     >
 162     typename impl::make_composite<
 163         OperationT, A, B, C, D, E, F, G
 164     >::type
 165     operator()(
 166         A const& a, B const& b, C const& c, D const& d, E const& e,
 167         F const& f, G const& g
 168     ) const;
 169
 170     template <
 171         typename A, typename B, typename C, typename D, typename E,
 172         typename F, typename G, typename H
 173     >
 174     typename impl::make_composite<
 175         OperationT, A, B, C, D, E, F, G, H
 176     >::type
 177     operator()(
 178         A const& a, B const& b, C const& c, D const& d, E const& e,
 179         F const& f, G const& g, H const& h
 180     ) const;
 181
 182     template <
 183         typename A, typename B, typename C, typename D, typename E,
 184         typename F, typename G, typename H, typename I
 185     >
 186     typename impl::make_composite<
 187         OperationT, A, B, C, D, E, F, G, H, I
 188     >::type
 189     operator()(
 190         A const& a, B const& b, C const& c, D const& d, E const& e,
 191         F const& f, G const& g, H const& h, I const& i
 192     ) const;
 193
 194 #if PHOENIX_LIMIT > 9
 195
 196     template <
 197         typename A, typename B, typename C, typename D, typename E,
 198         typename F, typename G, typename H, typename I, typename J
 199     >
 200     typename impl::make_composite<
 201         OperationT, A, B, C, D, E, F, G, H, I, J
 202     >::type
 203     operator()(
 204         A const& a, B const& b, C const& c, D const& d, E const& e,
 205         F const& f, G const& g, H const& h, I const& i, J const& j
 206     ) const;
 207
 208     template <
 209         typename A, typename B, typename C, typename D, typename E,
 210         typename F, typename G, typename H, typename I, typename J,
 211         typename K
 212     >
 213     typename impl::make_composite<
 214         OperationT, A, B, C, D, E, F, G, H, I, J, K
 215     >::type
 216     operator()(
 217         A const& a, B const& b, C const& c, D const& d, E const& e,
 218         F const& f, G const& g, H const& h, I const& i, J const& j,
 219         K const& k
 220     ) const;
 221
 222     template <
 223         typename A, typename B, typename C, typename D, typename E,
 224         typename F, typename G, typename H, typename I, typename J,
 225         typename K, typename L
 226     >
 227     typename impl::make_composite<
 228         OperationT, A, B, C, D, E, F, G, H, I, J, K, L
 229     >::type
 230     operator()(
 231         A const& a, B const& b, C const& c, D const& d, E const& e,
 232         F const& f, G const& g, H const& h, I const& i, J const& j,
 233         K const& k, L const& l
 234     ) const;
 235
 236 #if PHOENIX_LIMIT > 12
 237
 238     template <
 239         typename A, typename B, typename C, typename D, typename E,
 240         typename F, typename G, typename H, typename I, typename J,
 241         typename K, typename L, typename M
 242     >
 243     typename impl::make_composite<
 244         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
 245     >::type
 246     operator()(
 247         A const& a, B const& b, C const& c, D const& d, E const& e,
 248         F const& f, G const& g, H const& h, I const& i, J const& j,
 249         K const& k, L const& l, M const& m
 250     ) const;
 251
 252     template <
 253         typename A, typename B, typename C, typename D, typename E,
 254         typename F, typename G, typename H, typename I, typename J,
 255         typename K, typename L, typename M, typename N
 256     >
 257     typename impl::make_composite<
 258         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
 259     >::type
 260     operator()(
 261         A const& a, B const& b, C const& c, D const& d, E const& e,
 262         F const& f, G const& g, H const& h, I const& i, J const& j,
 263         K const& k, L const& l, M const& m, N const& n
 264     ) const;
 265
 266     template <
 267         typename A, typename B, typename C, typename D, typename E,
 268         typename F, typename G, typename H, typename I, typename J,
 269         typename K, typename L, typename M, typename N, typename O
 270     >
 271     typename impl::make_composite<
 272         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
 273     >::type
 274     operator()(
 275         A const& a, B const& b, C const& c, D const& d, E const& e,
 276         F const& f, G const& g, H const& h, I const& i, J const& j,
 277         K const& k, L const& l, M const& m, N const& n, O const& o
 278     ) const;
 279
 280 #endif
 281 #endif
 282 #endif
 283 #endif
 284
 285     OperationT op;
 286 };
 287
 288 ///////////////////////////////////////////////////////////////////////////////
 289 //
 290 //  function class implementation
 291 //
 292 ///////////////////////////////////////////////////////////////////////////////
 293 template <typename OperationT>
 294 inline actor<composite<OperationT> >
 295 function<OperationT>::operator()() const
 296 {
 297     return actor<composite<OperationT> >(op);
 298 }
 299
 300 //////////////////////////////////
 301 template <typename OperationT>
 302 template <typename A>
 303 inline typename impl::make_composite<OperationT, A>::type
 304 function<OperationT>::operator()(A const& a) const
 305 {
 306     typedef typename impl::make_composite<OperationT, A>::composite_type ret_t;
 307     return ret_t
 308     (
 309         op,
 310         as_actor<A>::convert(a)
 311     );
 312 }
 313
 314 //////////////////////////////////
 315 template <typename OperationT>
 316 template <typename A, typename B>
 317 inline typename impl::make_composite<OperationT, A, B>::type
 318 function<OperationT>::operator()(A const& a, B const& b) const
 319 {
 320     typedef
 321         typename impl::make_composite<OperationT, A, B>::composite_type
 322         ret_t;
 323
 324     return ret_t(
 325         op,
 326         as_actor<A>::convert(a),
 327         as_actor<B>::convert(b)
 328     );
 329 }
 330
 331 //////////////////////////////////
 332 template <typename OperationT>
 333 template <typename A, typename B, typename C>
 334 inline typename impl::make_composite<OperationT, A, B, C>::type
 335 function<OperationT>::operator()(A const& a, B const& b, C const& c) const
 336 {
 337     typedef
 338         typename impl::make_composite<OperationT, A, B, C>::composite_type
 339         ret_t;
 340
 341     return ret_t(
 342         op,
 343         as_actor<A>::convert(a),
 344         as_actor<B>::convert(b),
 345         as_actor<C>::convert(c)
 346     );
 347 }
 348
 349 #if PHOENIX_LIMIT > 3
 350 //////////////////////////////////
 351 template <typename OperationT>
 352 template <
 353     typename A, typename B, typename C, typename D
 354 >
 355 inline typename impl::make_composite<
 356     OperationT, A, B, C, D
 357 >::type
 358 function<OperationT>::operator()(
 359     A const& a, B const& b, C const& c, D const& d
 360 ) const
 361 {
 362     typedef typename impl::make_composite<
 363             OperationT, A, B, C, D
 364         >::composite_type ret_t;
 365
 366     return ret_t(
 367         op,
 368         as_actor<A>::convert(a),
 369         as_actor<B>::convert(b),
 370         as_actor<C>::convert(c),
 371         as_actor<D>::convert(d)
 372     );
 373 }
 374
 375 //////////////////////////////////
 376 template <typename OperationT>
 377 template <
 378     typename A, typename B, typename C, typename D, typename E
 379 >
 380 inline typename impl::make_composite<
 381     OperationT, A, B, C, D, E
 382 >::type
 383 function<OperationT>::operator()(
 384     A const& a, B const& b, C const& c, D const& d, E const& e
 385 ) const
 386 {
 387     typedef typename impl::make_composite<
 388             OperationT, A, B, C, D, E
 389         >::composite_type ret_t;
 390
 391     return ret_t(
 392         op,
 393         as_actor<A>::convert(a),
 394         as_actor<B>::convert(b),
 395         as_actor<C>::convert(c),
 396         as_actor<D>::convert(d),
 397         as_actor<E>::convert(e)
 398     );
 399 }
 400
 401 //////////////////////////////////
 402 template <typename OperationT>
 403 template <
 404     typename A, typename B, typename C, typename D, typename E,
 405     typename F
 406 >
 407 inline typename impl::make_composite<
 408     OperationT, A, B, C, D, E, F
 409 >::type
 410 function<OperationT>::operator()(
 411     A const& a, B const& b, C const& c, D const& d, E const& e,
 412     F const& f
 413 ) const
 414 {
 415     typedef typename impl::make_composite<
 416             OperationT, A, B, C, D, E, F
 417         >::composite_type ret_t;
 418
 419     return ret_t(
 420         op,
 421         as_actor<A>::convert(a),
 422         as_actor<B>::convert(b),
 423         as_actor<C>::convert(c),
 424         as_actor<D>::convert(d),
 425         as_actor<E>::convert(e),
 426         as_actor<F>::convert(f)
 427     );
 428 }
 429
 430 #if PHOENIX_LIMIT > 6
 431
 432 //////////////////////////////////
 433 template <typename OperationT>
 434 template <
 435     typename A, typename B, typename C, typename D, typename E,
 436     typename F, typename G
 437 >
 438 inline typename impl::make_composite<
 439     OperationT, A, B, C, D, E, F, G
 440 >::type
 441 function<OperationT>::operator()(
 442     A const& a, B const& b, C const& c, D const& d, E const& e,
 443     F const& f, G const& g
 444 ) const
 445 {
 446     typedef typename impl::make_composite<
 447             OperationT, A, B, C, D, E, F, G
 448         >::composite_type ret_t;
 449
 450     return ret_t(
 451         op,
 452         as_actor<A>::convert(a),
 453         as_actor<B>::convert(b),
 454         as_actor<C>::convert(c),
 455         as_actor<D>::convert(d),
 456         as_actor<E>::convert(e),
 457         as_actor<F>::convert(f),
 458         as_actor<G>::convert(g)
 459     );
 460 }
 461
 462 //////////////////////////////////
 463 template <typename OperationT>
 464 template <
 465     typename A, typename B, typename C, typename D, typename E,
 466     typename F, typename G, typename H
 467 >
 468 inline typename impl::make_composite<
 469     OperationT, A, B, C, D, E, F, G, H
 470 >::type
 471 function<OperationT>::operator()(
 472     A const& a, B const& b, C const& c, D const& d, E const& e,
 473     F const& f, G const& g, H const& h
 474 ) const
 475 {
 476     typedef typename impl::make_composite<
 477             OperationT, A, B, C, D, E, F, G, H
 478         >::composite_type ret_t;
 479
 480     return ret_t(
 481         op,
 482         as_actor<A>::convert(a),
 483         as_actor<B>::convert(b),
 484         as_actor<C>::convert(c),
 485         as_actor<D>::convert(d),
 486         as_actor<E>::convert(e),
 487         as_actor<F>::convert(f),
 488         as_actor<G>::convert(g),
 489         as_actor<H>::convert(h)
 490     );
 491 }
 492
 493 //////////////////////////////////
 494 template <typename OperationT>
 495 template <
 496     typename A, typename B, typename C, typename D, typename E,
 497     typename F, typename G, typename H, typename I
 498 >
 499 inline typename impl::make_composite<
 500     OperationT, A, B, C, D, E, F, G, H, I
 501 >::type
 502 function<OperationT>::operator()(
 503     A const& a, B const& b, C const& c, D const& d, E const& e,
 504     F const& f, G const& g, H const& h, I const& i
 505 ) const
 506 {
 507     typedef typename impl::make_composite<
 508             OperationT, A, B, C, D, E, F, G, H, I
 509         >::composite_type ret_t;
 510
 511     return ret_t(
 512         op,
 513         as_actor<A>::convert(a),
 514         as_actor<B>::convert(b),
 515         as_actor<C>::convert(c),
 516         as_actor<D>::convert(d),
 517         as_actor<E>::convert(e),
 518         as_actor<F>::convert(f),
 519         as_actor<G>::convert(g),
 520         as_actor<H>::convert(h),
 521         as_actor<I>::convert(i)
 522     );
 523 }
 524
 525 #if PHOENIX_LIMIT > 9
 526
 527 //////////////////////////////////
 528 template <typename OperationT>
 529 template <
 530     typename A, typename B, typename C, typename D, typename E,
 531     typename F, typename G, typename H, typename I, typename J
 532 >
 533 inline typename impl::make_composite<
 534     OperationT, A, B, C, D, E, F, G, H, I, J
 535 >::type
 536 function<OperationT>::operator()(
 537     A const& a, B const& b, C const& c, D const& d, E const& e,
 538     F const& f, G const& g, H const& h, I const& i, J const& j
 539 ) const
 540 {
 541     typedef typename impl::make_composite<
 542             OperationT, A, B, C, D, E, F, G, H, I, J
 543         >::composite_type ret_t;
 544
 545     return ret_t(
 546         op,
 547         as_actor<A>::convert(a),
 548         as_actor<B>::convert(b),
 549         as_actor<C>::convert(c),
 550         as_actor<D>::convert(d),
 551         as_actor<E>::convert(e),
 552         as_actor<F>::convert(f),
 553         as_actor<G>::convert(g),
 554         as_actor<H>::convert(h),
 555         as_actor<I>::convert(i),
 556         as_actor<J>::convert(j)
 557     );
 558 }
 559
 560 //////////////////////////////////
 561 template <typename OperationT>
 562 template <
 563     typename A, typename B, typename C, typename D, typename E,
 564     typename F, typename G, typename H, typename I, typename J,
 565     typename K
 566 >
 567 inline typename impl::make_composite<
 568     OperationT, A, B, C, D, E, F, G, H, I, J, K
 569 >::type
 570 function<OperationT>::operator()(
 571     A const& a, B const& b, C const& c, D const& d, E const& e,
 572     F const& f, G const& g, H const& h, I const& i, J const& j,
 573     K const& k
 574 ) const
 575 {
 576     typedef typename impl::make_composite<
 577             OperationT, A, B, C, D, E, F, G, H, I, J, K
 578         >::composite_type ret_t;
 579
 580     return ret_t(
 581         op,
 582         as_actor<A>::convert(a),
 583         as_actor<B>::convert(b),
 584         as_actor<C>::convert(c),
 585         as_actor<D>::convert(d),
 586         as_actor<E>::convert(e),
 587         as_actor<F>::convert(f),
 588         as_actor<G>::convert(g),
 589         as_actor<H>::convert(h),
 590         as_actor<I>::convert(i),
 591         as_actor<J>::convert(j),
 592         as_actor<K>::convert(k)
 593     );
 594 }
 595
 596 //////////////////////////////////
 597 template <typename OperationT>
 598 template <
 599     typename A, typename B, typename C, typename D, typename E,
 600     typename F, typename G, typename H, typename I, typename J,
 601     typename K, typename L
 602 >
 603 inline typename impl::make_composite<
 604     OperationT, A, B, C, D, E, F, G, H, I, J, K, L
 605 >::type
 606 function<OperationT>::operator()(
 607     A const& a, B const& b, C const& c, D const& d, E const& e,
 608     F const& f, G const& g, H const& h, I const& i, J const& j,
 609     K const& k, L const& l
 610 ) const
 611 {
 612     typedef typename impl::make_composite<
 613             OperationT, A, B, C, D, E, F, G, H, I, J, K, L
 614         >::composite_type ret_t;
 615
 616     return ret_t(
 617         op,
 618         as_actor<A>::convert(a),
 619         as_actor<B>::convert(b),
 620         as_actor<C>::convert(c),
 621         as_actor<D>::convert(d),
 622         as_actor<E>::convert(e),
 623         as_actor<F>::convert(f),
 624         as_actor<G>::convert(g),
 625         as_actor<H>::convert(h),
 626         as_actor<I>::convert(i),
 627         as_actor<J>::convert(j),
 628         as_actor<K>::convert(k),
 629         as_actor<L>::convert(l)
 630     );
 631 }
 632
 633 #if PHOENIX_LIMIT > 12
 634
 635 //////////////////////////////////
 636 template <typename OperationT>
 637 template <
 638     typename A, typename B, typename C, typename D, typename E,
 639     typename F, typename G, typename H, typename I, typename J,
 640     typename K, typename L, typename M
 641 >
 642 inline typename impl::make_composite<
 643     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
 644 >::type
 645 function<OperationT>::operator()(
 646     A const& a, B const& b, C const& c, D const& d, E const& e,
 647     F const& f, G const& g, H const& h, I const& i, J const& j,
 648     K const& k, L const& l, M const& m
 649 ) const
 650 {
 651     typedef typename impl::make_composite<
 652             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
 653         >::composite_type ret_t;
 654
 655     return ret_t(
 656         op,
 657         as_actor<A>::convert(a),
 658         as_actor<B>::convert(b),
 659         as_actor<C>::convert(c),
 660         as_actor<D>::convert(d),
 661         as_actor<E>::convert(e),
 662         as_actor<F>::convert(f),
 663         as_actor<G>::convert(g),
 664         as_actor<H>::convert(h),
 665         as_actor<I>::convert(i),
 666         as_actor<J>::convert(j),
 667         as_actor<K>::convert(k),
 668         as_actor<L>::convert(l),
 669         as_actor<M>::convert(m)
 670     );
 671 }
 672
 673 //////////////////////////////////
 674 template <typename OperationT>
 675 template <
 676     typename A, typename B, typename C, typename D, typename E,
 677     typename F, typename G, typename H, typename I, typename J,
 678     typename K, typename L, typename M, typename N
 679 >
 680 inline typename impl::make_composite<
 681     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
 682 >::type
 683 function<OperationT>::operator()(
 684     A const& a, B const& b, C const& c, D const& d, E const& e,
 685     F const& f, G const& g, H const& h, I const& i, J const& j,
 686     K const& k, L const& l, M const& m, N const& n
 687 ) const
 688 {
 689     typedef typename impl::make_composite<
 690             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
 691         >::composite_type ret_t;
 692
 693     return ret_t(
 694         op,
 695         as_actor<A>::convert(a),
 696         as_actor<B>::convert(b),
 697         as_actor<C>::convert(c),
 698         as_actor<D>::convert(d),
 699         as_actor<E>::convert(e),
 700         as_actor<F>::convert(f),
 701         as_actor<G>::convert(g),
 702         as_actor<H>::convert(h),
 703         as_actor<I>::convert(i),
 704         as_actor<J>::convert(j),
 705         as_actor<K>::convert(k),
 706         as_actor<L>::convert(l),
 707         as_actor<M>::convert(m),
 708         as_actor<N>::convert(n)
 709     );
 710 }
 711
 712 //////////////////////////////////
 713 template <typename OperationT>
 714 template <
 715     typename A, typename B, typename C, typename D, typename E,
 716     typename F, typename G, typename H, typename I, typename J,
 717     typename K, typename L, typename M, typename N, typename O
 718 >
 719 inline typename impl::make_composite<
 720     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
 721 >::type
 722 function<OperationT>::operator()(
 723     A const& a, B const& b, C const& c, D const& d, E const& e,
 724     F const& f, G const& g, H const& h, I const& i, J const& j,
 725     K const& k, L const& l, M const& m, N const& n, O const& o
 726 ) const
 727 {
 728     typedef typename impl::make_composite<
 729             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
 730         >::composite_type ret_t;
 731
 732     return ret_t(
 733         op,
 734         as_actor<A>::convert(a),
 735         as_actor<B>::convert(b),
 736         as_actor<C>::convert(c),
 737         as_actor<D>::convert(d),
 738         as_actor<E>::convert(e),
 739         as_actor<F>::convert(f),
 740         as_actor<G>::convert(g),
 741         as_actor<H>::convert(h),
 742         as_actor<I>::convert(i),
 743         as_actor<J>::convert(j),
 744         as_actor<K>::convert(k),
 745         as_actor<L>::convert(l),
 746         as_actor<M>::convert(m),
 747         as_actor<N>::convert(n),
 748         as_actor<O>::convert(o)
 749     );
 750 }
 751
 752 #endif
 753 #endif
 754 #endif
 755 #endif
 756
 757 ///////////////////////////////////////////////////////////////////////////////
 758 }   //  namespace phoenix
 759
 760 #endif