classic/phoenix/functions.hpp

0001 /*=============================================================================
0002     Phoenix V1.2.1
0003     Copyright (c) 2001-2002 Joel de Guzman
0004
0005   Distributed under the Boost Software License, Version 1.0. (See accompanying
0006   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0007 ==============================================================================*/
0008 #ifndef BOOST_SPIRIT_CLASSIC_PHOENIX_FUNCTIONS_HPP
0009 #define BOOST_SPIRIT_CLASSIC_PHOENIX_FUNCTIONS_HPP
0010
0011 ///////////////////////////////////////////////////////////////////////////////
0012 #include <boost/spirit/home/classic/phoenix/actor.hpp>
0013 #include <boost/spirit/home/classic/phoenix/composite.hpp>
0014
0015 ///////////////////////////////////////////////////////////////////////////////
0016 namespace phoenix {
0017
0018 ///////////////////////////////////////////////////////////////////////////////
0019 //
0020 //  function class
0021 //
0022 //      Lazy functions
0023 //
0024 //      This class provides a mechanism for lazily evaluating functions.
0025 //      Syntactically, a lazy function looks like an ordinary C/C++
0026 //      function. The function call looks the same. However, unlike
0027 //      ordinary functions, the actual function execution is deferred.
0028 //      (see actor.hpp, primitives.hpp and composite.hpp for an
0029 //      overview). For example here are sample factorial function calls:
0030 //
0031 //          factorial(4)
0032 //          factorial(arg1)
0033 //          factorial(arg1 * 6)
0034 //
0035 //      These functions are automatically lazily bound unlike ordinary
0036 //      function pointers or functor objects that need to be explicitly
0037 //      bound through the bind function (see binders.hpp).
0038 //
0039 //      A lazy function works in conjunction with a user defined functor
0040 //      (as usual with a member operator()). Only special forms of
0041 //      functor objects are allowed. This is required to enable true
0042 //      polymorphism (STL style monomorphic functors and function
0043 //      pointers can still be used through the bind facility in
0044 //      binders.hpp).
0045 //
0046 //      This special functor is expected to have a nested template class
0047 //      result<A...TN> (where N is the number of arguments of its
0048 //      member operator()). The nested template class result should have
0049 //      a typedef 'type' that reflects the return type of its member
0050 //      operator(). This is essentially a type computer that answers the
0051 //      metaprogramming question "Given arguments of type A...TN, what
0052 //      will be the operator()'s return type?".
0053 //
0054 //      There is a special case for functors that accept no arguments.
0055 //      Such nullary functors are only required to define a typedef
0056 //      result_type that reflects the return type of its operator().
0057 //
0058 //      Here's an example of a simple functor that computes the
0059 //      factorial of a number:
0060 //
0061 //          struct factorial_impl {
0062 //
0063 //              template <typename Arg>
0064 //              struct result { typedef Arg type; };
0065 //
0066 //              template <typename Arg>
0067 //              Arg operator()(Arg n) const
0068 //              { return (n <= 0) ? 1 : n * this->operator()(n-1); }
0069 //          };
0070 //
0071 //      As can be seen, the functor can be polymorphic. Its arguments
0072 //      and return type are not fixed to a particular type. The example
0073 //      above for example, can handle any type as long as it can carry
0074 //      out the required operations (i.e. <=, * and -).
0075 //
0076 //      We can now declare and instantiate a lazy 'factorial' function:
0077 //
0078 //          function<factorial_impl> factorial;
0079 //
0080 //      Invoking a lazy function 'factorial' does not immediately
0081 //      execute the functor factorial_impl. Instead, a composite (see
0082 //      composite.hpp) object is created and returned to the caller.
0083 //      Example:
0084 //
0085 //          factorial(arg1)
0086 //
0087 //      does nothing more than return a composite. A second function
0088 //      call will invoke the actual factorial function. Example:
0089 //
0090 //          int i = 4;
0091 //          cout << factorial(arg1)(i);
0092 //
0093 //      will print out "24".
0094 //
0095 //      Take note that in certain cases (e.g. for functors with state),
0096 //      an instance may be passed on to the constructor. Example:
0097 //
0098 //          function<factorial_impl> factorial(ftor);
0099 //
0100 //      where ftor is an instance of factorial_impl (this is not
0101 //      necessary in this case since factorial is a simple stateless
0102 //      functor). Take care though when using functors with state
0103 //      because the functors are taken in by value. It is best to keep
0104 //      the data manipulated by a functor outside the functor itself and
0105 //      keep a reference to this data inside the functor. Also, it is
0106 //      best to keep functors as small as possible.
0107 //
0108 ///////////////////////////////////////////////////////////////////////////////
0109 template <typename OperationT>
0110 struct function {
0111
0112     function() : op() {}
0113     function(OperationT const& op_) : op(op_) {}
0114
0115     actor<composite<OperationT> >
0116     operator()() const;
0117
0118     template <typename A>
0119     typename impl::make_composite<OperationT, A>::type
0120     operator()(A const& a) const;
0121
0122     template <typename A, typename B>
0123     typename impl::make_composite<OperationT, A, B>::type
0124     operator()(A const& a, B const& b) const;
0125
0126     template <typename A, typename B, typename C>
0127     typename impl::make_composite<OperationT, A, B, C>::type
0128     operator()(A const& a, B const& b, C const& c) const;
0129
0130 #if PHOENIX_LIMIT > 3
0131
0132     template <typename A, typename B, typename C, typename D>
0133     typename impl::make_composite<OperationT, A, B, C, D>::type
0134     operator()(A const& a, B const& b, C const& c, D const& d) const;
0135
0136     template <typename A, typename B, typename C, typename D, typename E>
0137     typename impl::make_composite<
0138         OperationT, A, B, C, D, E
0139     >::type
0140     operator()(
0141         A const& a, B const& b, C const& c, D const& d, E const& e
0142     ) const;
0143
0144     template <
0145         typename A, typename B, typename C, typename D, typename E,
0146         typename F
0147     >
0148     typename impl::make_composite<
0149         OperationT, A, B, C, D, E, F
0150     >::type
0151     operator()(
0152         A const& a, B const& b, C const& c, D const& d, E const& e,
0153         F const& f
0154     ) const;
0155
0156 #if PHOENIX_LIMIT > 6
0157
0158     template <
0159         typename A, typename B, typename C, typename D, typename E,
0160         typename F, typename G
0161     >
0162     typename impl::make_composite<
0163         OperationT, A, B, C, D, E, F, G
0164     >::type
0165     operator()(
0166         A const& a, B const& b, C const& c, D const& d, E const& e,
0167         F const& f, G const& g
0168     ) const;
0169
0170     template <
0171         typename A, typename B, typename C, typename D, typename E,
0172         typename F, typename G, typename H
0173     >
0174     typename impl::make_composite<
0175         OperationT, A, B, C, D, E, F, G, H
0176     >::type
0177     operator()(
0178         A const& a, B const& b, C const& c, D const& d, E const& e,
0179         F const& f, G const& g, H const& h
0180     ) const;
0181
0182     template <
0183         typename A, typename B, typename C, typename D, typename E,
0184         typename F, typename G, typename H, typename I
0185     >
0186     typename impl::make_composite<
0187         OperationT, A, B, C, D, E, F, G, H, I
0188     >::type
0189     operator()(
0190         A const& a, B const& b, C const& c, D const& d, E const& e,
0191         F const& f, G const& g, H const& h, I const& i
0192     ) const;
0193
0194 #if PHOENIX_LIMIT > 9
0195
0196     template <
0197         typename A, typename B, typename C, typename D, typename E,
0198         typename F, typename G, typename H, typename I, typename J
0199     >
0200     typename impl::make_composite<
0201         OperationT, A, B, C, D, E, F, G, H, I, J
0202     >::type
0203     operator()(
0204         A const& a, B const& b, C const& c, D const& d, E const& e,
0205         F const& f, G const& g, H const& h, I const& i, J const& j
0206     ) const;
0207
0208     template <
0209         typename A, typename B, typename C, typename D, typename E,
0210         typename F, typename G, typename H, typename I, typename J,
0211         typename K
0212     >
0213     typename impl::make_composite<
0214         OperationT, A, B, C, D, E, F, G, H, I, J, K
0215     >::type
0216     operator()(
0217         A const& a, B const& b, C const& c, D const& d, E const& e,
0218         F const& f, G const& g, H const& h, I const& i, J const& j,
0219         K const& k
0220     ) const;
0221
0222     template <
0223         typename A, typename B, typename C, typename D, typename E,
0224         typename F, typename G, typename H, typename I, typename J,
0225         typename K, typename L
0226     >
0227     typename impl::make_composite<
0228         OperationT, A, B, C, D, E, F, G, H, I, J, K, L
0229     >::type
0230     operator()(
0231         A const& a, B const& b, C const& c, D const& d, E const& e,
0232         F const& f, G const& g, H const& h, I const& i, J const& j,
0233         K const& k, L const& l
0234     ) const;
0235
0236 #if PHOENIX_LIMIT > 12
0237
0238     template <
0239         typename A, typename B, typename C, typename D, typename E,
0240         typename F, typename G, typename H, typename I, typename J,
0241         typename K, typename L, typename M
0242     >
0243     typename impl::make_composite<
0244         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
0245     >::type
0246     operator()(
0247         A const& a, B const& b, C const& c, D const& d, E const& e,
0248         F const& f, G const& g, H const& h, I const& i, J const& j,
0249         K const& k, L const& l, M const& m
0250     ) const;
0251
0252     template <
0253         typename A, typename B, typename C, typename D, typename E,
0254         typename F, typename G, typename H, typename I, typename J,
0255         typename K, typename L, typename M, typename N
0256     >
0257     typename impl::make_composite<
0258         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
0259     >::type
0260     operator()(
0261         A const& a, B const& b, C const& c, D const& d, E const& e,
0262         F const& f, G const& g, H const& h, I const& i, J const& j,
0263         K const& k, L const& l, M const& m, N const& n
0264     ) const;
0265
0266     template <
0267         typename A, typename B, typename C, typename D, typename E,
0268         typename F, typename G, typename H, typename I, typename J,
0269         typename K, typename L, typename M, typename N, typename O
0270     >
0271     typename impl::make_composite<
0272         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
0273     >::type
0274     operator()(
0275         A const& a, B const& b, C const& c, D const& d, E const& e,
0276         F const& f, G const& g, H const& h, I const& i, J const& j,
0277         K const& k, L const& l, M const& m, N const& n, O const& o
0278     ) const;
0279
0280 #endif
0281 #endif
0282 #endif
0283 #endif
0284
0285     OperationT op;
0286 };
0287
0288 ///////////////////////////////////////////////////////////////////////////////
0289 //
0290 //  function class implementation
0291 //
0292 ///////////////////////////////////////////////////////////////////////////////
0293 template <typename OperationT>
0294 inline actor<composite<OperationT> >
0295 function<OperationT>::operator()() const
0296 {
0297     return actor<composite<OperationT> >(op);
0298 }
0299
0300 //////////////////////////////////
0301 template <typename OperationT>
0302 template <typename A>
0303 inline typename impl::make_composite<OperationT, A>::type
0304 function<OperationT>::operator()(A const& a) const
0305 {
0306     typedef typename impl::make_composite<OperationT, A>::composite_type ret_t;
0307     return ret_t
0308     (
0309         op,
0310         as_actor<A>::convert(a)
0311     );
0312 }
0313
0314 //////////////////////////////////
0315 template <typename OperationT>
0316 template <typename A, typename B>
0317 inline typename impl::make_composite<OperationT, A, B>::type
0318 function<OperationT>::operator()(A const& a, B const& b) const
0319 {
0320     typedef
0321         typename impl::make_composite<OperationT, A, B>::composite_type
0322         ret_t;
0323
0324     return ret_t(
0325         op,
0326         as_actor<A>::convert(a),
0327         as_actor<B>::convert(b)
0328     );
0329 }
0330
0331 //////////////////////////////////
0332 template <typename OperationT>
0333 template <typename A, typename B, typename C>
0334 inline typename impl::make_composite<OperationT, A, B, C>::type
0335 function<OperationT>::operator()(A const& a, B const& b, C const& c) const
0336 {
0337     typedef
0338         typename impl::make_composite<OperationT, A, B, C>::composite_type
0339         ret_t;
0340
0341     return ret_t(
0342         op,
0343         as_actor<A>::convert(a),
0344         as_actor<B>::convert(b),
0345         as_actor<C>::convert(c)
0346     );
0347 }
0348
0349 #if PHOENIX_LIMIT > 3
0350 //////////////////////////////////
0351 template <typename OperationT>
0352 template <
0353     typename A, typename B, typename C, typename D
0354 >
0355 inline typename impl::make_composite<
0356     OperationT, A, B, C, D
0357 >::type
0358 function<OperationT>::operator()(
0359     A const& a, B const& b, C const& c, D const& d
0360 ) const
0361 {
0362     typedef typename impl::make_composite<
0363             OperationT, A, B, C, D
0364         >::composite_type ret_t;
0365
0366     return ret_t(
0367         op,
0368         as_actor<A>::convert(a),
0369         as_actor<B>::convert(b),
0370         as_actor<C>::convert(c),
0371         as_actor<D>::convert(d)
0372     );
0373 }
0374
0375 //////////////////////////////////
0376 template <typename OperationT>
0377 template <
0378     typename A, typename B, typename C, typename D, typename E
0379 >
0380 inline typename impl::make_composite<
0381     OperationT, A, B, C, D, E
0382 >::type
0383 function<OperationT>::operator()(
0384     A const& a, B const& b, C const& c, D const& d, E const& e
0385 ) const
0386 {
0387     typedef typename impl::make_composite<
0388             OperationT, A, B, C, D, E
0389         >::composite_type ret_t;
0390
0391     return ret_t(
0392         op,
0393         as_actor<A>::convert(a),
0394         as_actor<B>::convert(b),
0395         as_actor<C>::convert(c),
0396         as_actor<D>::convert(d),
0397         as_actor<E>::convert(e)
0398     );
0399 }
0400
0401 //////////////////////////////////
0402 template <typename OperationT>
0403 template <
0404     typename A, typename B, typename C, typename D, typename E,
0405     typename F
0406 >
0407 inline typename impl::make_composite<
0408     OperationT, A, B, C, D, E, F
0409 >::type
0410 function<OperationT>::operator()(
0411     A const& a, B const& b, C const& c, D const& d, E const& e,
0412     F const& f
0413 ) const
0414 {
0415     typedef typename impl::make_composite<
0416             OperationT, A, B, C, D, E, F
0417         >::composite_type ret_t;
0418
0419     return ret_t(
0420         op,
0421         as_actor<A>::convert(a),
0422         as_actor<B>::convert(b),
0423         as_actor<C>::convert(c),
0424         as_actor<D>::convert(d),
0425         as_actor<E>::convert(e),
0426         as_actor<F>::convert(f)
0427     );
0428 }
0429
0430 #if PHOENIX_LIMIT > 6
0431
0432 //////////////////////////////////
0433 template <typename OperationT>
0434 template <
0435     typename A, typename B, typename C, typename D, typename E,
0436     typename F, typename G
0437 >
0438 inline typename impl::make_composite<
0439     OperationT, A, B, C, D, E, F, G
0440 >::type
0441 function<OperationT>::operator()(
0442     A const& a, B const& b, C const& c, D const& d, E const& e,
0443     F const& f, G const& g
0444 ) const
0445 {
0446     typedef typename impl::make_composite<
0447             OperationT, A, B, C, D, E, F, G
0448         >::composite_type ret_t;
0449
0450     return ret_t(
0451         op,
0452         as_actor<A>::convert(a),
0453         as_actor<B>::convert(b),
0454         as_actor<C>::convert(c),
0455         as_actor<D>::convert(d),
0456         as_actor<E>::convert(e),
0457         as_actor<F>::convert(f),
0458         as_actor<G>::convert(g)
0459     );
0460 }
0461
0462 //////////////////////////////////
0463 template <typename OperationT>
0464 template <
0465     typename A, typename B, typename C, typename D, typename E,
0466     typename F, typename G, typename H
0467 >
0468 inline typename impl::make_composite<
0469     OperationT, A, B, C, D, E, F, G, H
0470 >::type
0471 function<OperationT>::operator()(
0472     A const& a, B const& b, C const& c, D const& d, E const& e,
0473     F const& f, G const& g, H const& h
0474 ) const
0475 {
0476     typedef typename impl::make_composite<
0477             OperationT, A, B, C, D, E, F, G, H
0478         >::composite_type ret_t;
0479
0480     return ret_t(
0481         op,
0482         as_actor<A>::convert(a),
0483         as_actor<B>::convert(b),
0484         as_actor<C>::convert(c),
0485         as_actor<D>::convert(d),
0486         as_actor<E>::convert(e),
0487         as_actor<F>::convert(f),
0488         as_actor<G>::convert(g),
0489         as_actor<H>::convert(h)
0490     );
0491 }
0492
0493 //////////////////////////////////
0494 template <typename OperationT>
0495 template <
0496     typename A, typename B, typename C, typename D, typename E,
0497     typename F, typename G, typename H, typename I
0498 >
0499 inline typename impl::make_composite<
0500     OperationT, A, B, C, D, E, F, G, H, I
0501 >::type
0502 function<OperationT>::operator()(
0503     A const& a, B const& b, C const& c, D const& d, E const& e,
0504     F const& f, G const& g, H const& h, I const& i
0505 ) const
0506 {
0507     typedef typename impl::make_composite<
0508             OperationT, A, B, C, D, E, F, G, H, I
0509         >::composite_type ret_t;
0510
0511     return ret_t(
0512         op,
0513         as_actor<A>::convert(a),
0514         as_actor<B>::convert(b),
0515         as_actor<C>::convert(c),
0516         as_actor<D>::convert(d),
0517         as_actor<E>::convert(e),
0518         as_actor<F>::convert(f),
0519         as_actor<G>::convert(g),
0520         as_actor<H>::convert(h),
0521         as_actor<I>::convert(i)
0522     );
0523 }
0524
0525 #if PHOENIX_LIMIT > 9
0526
0527 //////////////////////////////////
0528 template <typename OperationT>
0529 template <
0530     typename A, typename B, typename C, typename D, typename E,
0531     typename F, typename G, typename H, typename I, typename J
0532 >
0533 inline typename impl::make_composite<
0534     OperationT, A, B, C, D, E, F, G, H, I, J
0535 >::type
0536 function<OperationT>::operator()(
0537     A const& a, B const& b, C const& c, D const& d, E const& e,
0538     F const& f, G const& g, H const& h, I const& i, J const& j
0539 ) const
0540 {
0541     typedef typename impl::make_composite<
0542             OperationT, A, B, C, D, E, F, G, H, I, J
0543         >::composite_type ret_t;
0544
0545     return ret_t(
0546         op,
0547         as_actor<A>::convert(a),
0548         as_actor<B>::convert(b),
0549         as_actor<C>::convert(c),
0550         as_actor<D>::convert(d),
0551         as_actor<E>::convert(e),
0552         as_actor<F>::convert(f),
0553         as_actor<G>::convert(g),
0554         as_actor<H>::convert(h),
0555         as_actor<I>::convert(i),
0556         as_actor<J>::convert(j)
0557     );
0558 }
0559
0560 //////////////////////////////////
0561 template <typename OperationT>
0562 template <
0563     typename A, typename B, typename C, typename D, typename E,
0564     typename F, typename G, typename H, typename I, typename J,
0565     typename K
0566 >
0567 inline typename impl::make_composite<
0568     OperationT, A, B, C, D, E, F, G, H, I, J, K
0569 >::type
0570 function<OperationT>::operator()(
0571     A const& a, B const& b, C const& c, D const& d, E const& e,
0572     F const& f, G const& g, H const& h, I const& i, J const& j,
0573     K const& k
0574 ) const
0575 {
0576     typedef typename impl::make_composite<
0577             OperationT, A, B, C, D, E, F, G, H, I, J, K
0578         >::composite_type ret_t;
0579
0580     return ret_t(
0581         op,
0582         as_actor<A>::convert(a),
0583         as_actor<B>::convert(b),
0584         as_actor<C>::convert(c),
0585         as_actor<D>::convert(d),
0586         as_actor<E>::convert(e),
0587         as_actor<F>::convert(f),
0588         as_actor<G>::convert(g),
0589         as_actor<H>::convert(h),
0590         as_actor<I>::convert(i),
0591         as_actor<J>::convert(j),
0592         as_actor<K>::convert(k)
0593     );
0594 }
0595
0596 //////////////////////////////////
0597 template <typename OperationT>
0598 template <
0599     typename A, typename B, typename C, typename D, typename E,
0600     typename F, typename G, typename H, typename I, typename J,
0601     typename K, typename L
0602 >
0603 inline typename impl::make_composite<
0604     OperationT, A, B, C, D, E, F, G, H, I, J, K, L
0605 >::type
0606 function<OperationT>::operator()(
0607     A const& a, B const& b, C const& c, D const& d, E const& e,
0608     F const& f, G const& g, H const& h, I const& i, J const& j,
0609     K const& k, L const& l
0610 ) const
0611 {
0612     typedef typename impl::make_composite<
0613             OperationT, A, B, C, D, E, F, G, H, I, J, K, L
0614         >::composite_type ret_t;
0615
0616     return ret_t(
0617         op,
0618         as_actor<A>::convert(a),
0619         as_actor<B>::convert(b),
0620         as_actor<C>::convert(c),
0621         as_actor<D>::convert(d),
0622         as_actor<E>::convert(e),
0623         as_actor<F>::convert(f),
0624         as_actor<G>::convert(g),
0625         as_actor<H>::convert(h),
0626         as_actor<I>::convert(i),
0627         as_actor<J>::convert(j),
0628         as_actor<K>::convert(k),
0629         as_actor<L>::convert(l)
0630     );
0631 }
0632
0633 #if PHOENIX_LIMIT > 12
0634
0635 //////////////////////////////////
0636 template <typename OperationT>
0637 template <
0638     typename A, typename B, typename C, typename D, typename E,
0639     typename F, typename G, typename H, typename I, typename J,
0640     typename K, typename L, typename M
0641 >
0642 inline typename impl::make_composite<
0643     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
0644 >::type
0645 function<OperationT>::operator()(
0646     A const& a, B const& b, C const& c, D const& d, E const& e,
0647     F const& f, G const& g, H const& h, I const& i, J const& j,
0648     K const& k, L const& l, M const& m
0649 ) const
0650 {
0651     typedef typename impl::make_composite<
0652             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
0653         >::composite_type ret_t;
0654
0655     return ret_t(
0656         op,
0657         as_actor<A>::convert(a),
0658         as_actor<B>::convert(b),
0659         as_actor<C>::convert(c),
0660         as_actor<D>::convert(d),
0661         as_actor<E>::convert(e),
0662         as_actor<F>::convert(f),
0663         as_actor<G>::convert(g),
0664         as_actor<H>::convert(h),
0665         as_actor<I>::convert(i),
0666         as_actor<J>::convert(j),
0667         as_actor<K>::convert(k),
0668         as_actor<L>::convert(l),
0669         as_actor<M>::convert(m)
0670     );
0671 }
0672
0673 //////////////////////////////////
0674 template <typename OperationT>
0675 template <
0676     typename A, typename B, typename C, typename D, typename E,
0677     typename F, typename G, typename H, typename I, typename J,
0678     typename K, typename L, typename M, typename N
0679 >
0680 inline typename impl::make_composite<
0681     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
0682 >::type
0683 function<OperationT>::operator()(
0684     A const& a, B const& b, C const& c, D const& d, E const& e,
0685     F const& f, G const& g, H const& h, I const& i, J const& j,
0686     K const& k, L const& l, M const& m, N const& n
0687 ) const
0688 {
0689     typedef typename impl::make_composite<
0690             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
0691         >::composite_type ret_t;
0692
0693     return ret_t(
0694         op,
0695         as_actor<A>::convert(a),
0696         as_actor<B>::convert(b),
0697         as_actor<C>::convert(c),
0698         as_actor<D>::convert(d),
0699         as_actor<E>::convert(e),
0700         as_actor<F>::convert(f),
0701         as_actor<G>::convert(g),
0702         as_actor<H>::convert(h),
0703         as_actor<I>::convert(i),
0704         as_actor<J>::convert(j),
0705         as_actor<K>::convert(k),
0706         as_actor<L>::convert(l),
0707         as_actor<M>::convert(m),
0708         as_actor<N>::convert(n)
0709     );
0710 }
0711
0712 //////////////////////////////////
0713 template <typename OperationT>
0714 template <
0715     typename A, typename B, typename C, typename D, typename E,
0716     typename F, typename G, typename H, typename I, typename J,
0717     typename K, typename L, typename M, typename N, typename O
0718 >
0719 inline typename impl::make_composite<
0720     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
0721 >::type
0722 function<OperationT>::operator()(
0723     A const& a, B const& b, C const& c, D const& d, E const& e,
0724     F const& f, G const& g, H const& h, I const& i, J const& j,
0725     K const& k, L const& l, M const& m, N const& n, O const& o
0726 ) const
0727 {
0728     typedef typename impl::make_composite<
0729             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
0730         >::composite_type ret_t;
0731
0732     return ret_t(
0733         op,
0734         as_actor<A>::convert(a),
0735         as_actor<B>::convert(b),
0736         as_actor<C>::convert(c),
0737         as_actor<D>::convert(d),
0738         as_actor<E>::convert(e),
0739         as_actor<F>::convert(f),
0740         as_actor<G>::convert(g),
0741         as_actor<H>::convert(h),
0742         as_actor<I>::convert(i),
0743         as_actor<J>::convert(j),
0744         as_actor<K>::convert(k),
0745         as_actor<L>::convert(l),
0746         as_actor<M>::convert(m),
0747         as_actor<N>::convert(n),
0748         as_actor<O>::convert(o)
0749     );
0750 }
0751
0752 #endif
0753 #endif
0754 #endif
0755 #endif
0756
0757 ///////////////////////////////////////////////////////////////////////////////
0758 }   //  namespace phoenix
0759
0760 #endif