Chris@16: /*=============================================================================
Chris@16:     Phoenix V1.2.1
Chris@16:     Copyright (c) 2001-2002 Joel de Guzman
Chris@16: 
Chris@16:   Distributed under the Boost Software License, Version 1.0. (See accompanying
Chris@16:   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: ==============================================================================*/
Chris@16: #ifndef PHOENIX_FUNCTIONS_HPP
Chris@16: #define PHOENIX_FUNCTIONS_HPP
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: #include <boost/spirit/home/classic/phoenix/actor.hpp>
Chris@16: #include <boost/spirit/home/classic/phoenix/composite.hpp>
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: namespace phoenix {
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  function class
Chris@16: //
Chris@16: //      Lazy functions
Chris@16: //
Chris@16: //      This class provides a mechanism for lazily evaluating functions.
Chris@16: //      Syntactically, a lazy function looks like an ordinary C/C++
Chris@16: //      function. The function call looks the same. However, unlike
Chris@16: //      ordinary functions, the actual function execution is deferred.
Chris@16: //      (see actor.hpp, primitives.hpp and composite.hpp for an
Chris@16: //      overview). For example here are sample factorial function calls:
Chris@16: //
Chris@16: //          factorial(4)
Chris@16: //          factorial(arg1)
Chris@16: //          factorial(arg1 * 6)
Chris@16: //
Chris@16: //      These functions are automatically lazily bound unlike ordinary
Chris@16: //      function pointers or functor objects that need to be explicitly
Chris@16: //      bound through the bind function (see binders.hpp).
Chris@16: //
Chris@16: //      A lazy function works in conjunction with a user defined functor
Chris@16: //      (as usual with a member operator()). Only special forms of
Chris@16: //      functor objects are allowed. This is required to enable true
Chris@16: //      polymorphism (STL style monomorphic functors and function
Chris@16: //      pointers can still be used through the bind facility in
Chris@16: //      binders.hpp).
Chris@16: //
Chris@16: //      This special functor is expected to have a nested template class
Chris@16: //      result<A...TN> (where N is the number of arguments of its
Chris@16: //      member operator()). The nested template class result should have
Chris@16: //      a typedef 'type' that reflects the return type of its member
Chris@16: //      operator(). This is essentially a type computer that answers the
Chris@16: //      metaprogramming question "Given arguments of type A...TN, what
Chris@16: //      will be the operator()'s return type?".
Chris@16: //
Chris@16: //      There is a special case for functors that accept no arguments.
Chris@16: //      Such nullary functors are only required to define a typedef
Chris@16: //      result_type that reflects the return type of its operator().
Chris@16: //
Chris@16: //      Here's an example of a simple functor that computes the
Chris@16: //      factorial of a number:
Chris@16: //
Chris@16: //          struct factorial_impl {
Chris@16: //
Chris@16: //              template <typename Arg>
Chris@16: //              struct result { typedef Arg type; };
Chris@16: //
Chris@16: //              template <typename Arg>
Chris@16: //              Arg operator()(Arg n) const
Chris@16: //              { return (n <= 0) ? 1 : n * this->operator()(n-1); }
Chris@16: //          };
Chris@16: //
Chris@16: //      As can be seen, the functor can be polymorphic. Its arguments
Chris@16: //      and return type are not fixed to a particular type. The example
Chris@16: //      above for example, can handle any type as long as it can carry
Chris@16: //      out the required operations (i.e. <=, * and -).
Chris@16: //
Chris@16: //      We can now declare and instantiate a lazy 'factorial' function:
Chris@16: //
Chris@16: //          function<factorial_impl> factorial;
Chris@16: //
Chris@16: //      Invoking a lazy function 'factorial' does not immediately
Chris@16: //      execute the functor factorial_impl. Instead, a composite (see
Chris@16: //      composite.hpp) object is created and returned to the caller.
Chris@16: //      Example:
Chris@16: //
Chris@16: //          factorial(arg1)
Chris@16: //
Chris@16: //      does nothing more than return a composite. A second function
Chris@16: //      call will invoke the actual factorial function. Example:
Chris@16: //
Chris@16: //          int i = 4;
Chris@16: //          cout << factorial(arg1)(i);
Chris@16: //
Chris@16: //      will print out "24".
Chris@16: //
Chris@16: //      Take note that in certain cases (e.g. for functors with state),
Chris@16: //      an instance may be passed on to the constructor. Example:
Chris@16: //
Chris@16: //          function<factorial_impl> factorial(ftor);
Chris@16: //
Chris@16: //      where ftor is an instance of factorial_impl (this is not
Chris@16: //      necessary in this case since factorial is a simple stateless
Chris@16: //      functor). Take care though when using functors with state
Chris@16: //      because the functors are taken in by value. It is best to keep
Chris@16: //      the data manipulated by a functor outside the functor itself and
Chris@16: //      keep a reference to this data inside the functor. Also, it is
Chris@16: //      best to keep functors as small as possible.
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: struct function {
Chris@16: 
Chris@16:     function() : op() {}
Chris@16:     function(OperationT const& op_) : op(op_) {}
Chris@16: 
Chris@16:     actor<composite<OperationT> >
Chris@16:     operator()() const;
Chris@16: 
Chris@16:     template <typename A>
Chris@16:     typename impl::make_composite<OperationT, A>::type
Chris@16:     operator()(A const& a) const;
Chris@16: 
Chris@16:     template <typename A, typename B>
Chris@16:     typename impl::make_composite<OperationT, A, B>::type
Chris@16:     operator()(A const& a, B const& b) const;
Chris@16: 
Chris@16:     template <typename A, typename B, typename C>
Chris@16:     typename impl::make_composite<OperationT, A, B, C>::type
Chris@16:     operator()(A const& a, B const& b, C const& c) const;
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16: 
Chris@16:     template <typename A, typename B, typename C, typename D>
Chris@16:     typename impl::make_composite<OperationT, A, B, C, D>::type
Chris@16:     operator()(A const& a, B const& b, C const& c, D const& d) const;
Chris@16: 
Chris@16:     template <typename A, typename B, typename C, typename D, typename E>
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e
Chris@16:     ) const;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f
Chris@16:     ) const;
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g
Chris@16:     ) const;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G, typename H
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G, H
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g, H const& h
Chris@16:     ) const;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G, typename H, typename I
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G, H, I
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g, H const& h, I const& i
Chris@16:     ) const;
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G, typename H, typename I, typename J
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G, H, I, J
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g, H const& h, I const& i, J const& j
Chris@16:     ) const;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G, typename H, typename I, typename J,
Chris@16:         typename K
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G, H, I, J, K
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:         K const& k
Chris@16:     ) const;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G, typename H, typename I, typename J,
Chris@16:         typename K, typename L
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G, H, I, J, K, L
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:         K const& k, L const& l
Chris@16:     ) const;
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G, typename H, typename I, typename J,
Chris@16:         typename K, typename L, typename M
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:         K const& k, L const& l, M const& m
Chris@16:     ) const;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G, typename H, typename I, typename J,
Chris@16:         typename K, typename L, typename M, typename N
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:         K const& k, L const& l, M const& m, N const& n
Chris@16:     ) const;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A, typename B, typename C, typename D, typename E,
Chris@16:         typename F, typename G, typename H, typename I, typename J,
Chris@16:         typename K, typename L, typename M, typename N, typename O
Chris@16:     >
Chris@16:     typename impl::make_composite<
Chris@16:         OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
Chris@16:     >::type
Chris@16:     operator()(
Chris@16:         A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:         F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:         K const& k, L const& l, M const& m, N const& n, O const& o
Chris@16:     ) const;
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16:     OperationT op;
Chris@16: };
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  function class implementation
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: inline actor<composite<OperationT> >
Chris@16: function<OperationT>::operator()() const
Chris@16: {
Chris@16:     return actor<composite<OperationT> >(op);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <typename A>
Chris@16: inline typename impl::make_composite<OperationT, A>::type
Chris@16: function<OperationT>::operator()(A const& a) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<OperationT, A>::composite_type ret_t;
Chris@16:     return ret_t
Chris@16:     (
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <typename A, typename B>
Chris@16: inline typename impl::make_composite<OperationT, A, B>::type
Chris@16: function<OperationT>::operator()(A const& a, B const& b) const
Chris@16: {
Chris@16:     typedef 
Chris@16:         typename impl::make_composite<OperationT, A, B>::composite_type 
Chris@16:         ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <typename A, typename B, typename C>
Chris@16: inline typename impl::make_composite<OperationT, A, B, C>::type
Chris@16: function<OperationT>::operator()(A const& a, B const& b, C const& c) const
Chris@16: {
Chris@16:     typedef 
Chris@16:         typename impl::make_composite<OperationT, A, B, C>::composite_type
Chris@16:         ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D
Chris@16:         >::composite_type ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E
Chris@16:         >::composite_type ret_t;
Chris@16: 
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F
Chris@16:         >::composite_type ret_t;
Chris@16: 
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G
Chris@16:         >::composite_type ret_t;
Chris@16: 
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G, H
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g, H const& h
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G, H
Chris@16:         >::composite_type ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g),
Chris@16:         as_actor<H>::convert(h)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G, H, I
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g, H const& h, I const& i
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G, H, I
Chris@16:         >::composite_type ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g),
Chris@16:         as_actor<H>::convert(h),
Chris@16:         as_actor<I>::convert(i)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G, H, I, J
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g, H const& h, I const& i, J const& j
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G, H, I, J
Chris@16:         >::composite_type ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g),
Chris@16:         as_actor<H>::convert(h),
Chris@16:         as_actor<I>::convert(i),
Chris@16:         as_actor<J>::convert(j)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G, H, I, J, K
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:     K const& k
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G, H, I, J, K
Chris@16:         >::composite_type ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g),
Chris@16:         as_actor<H>::convert(h),
Chris@16:         as_actor<I>::convert(i),
Chris@16:         as_actor<J>::convert(j),
Chris@16:         as_actor<K>::convert(k)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G, H, I, J, K, L
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:     K const& k, L const& l
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G, H, I, J, K, L
Chris@16:         >::composite_type ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g),
Chris@16:         as_actor<H>::convert(h),
Chris@16:         as_actor<I>::convert(i),
Chris@16:         as_actor<J>::convert(j),
Chris@16:         as_actor<K>::convert(k),
Chris@16:         as_actor<L>::convert(l)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:     K const& k, L const& l, M const& m
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
Chris@16:         >::composite_type ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g),
Chris@16:         as_actor<H>::convert(h),
Chris@16:         as_actor<I>::convert(i),
Chris@16:         as_actor<J>::convert(j),
Chris@16:         as_actor<K>::convert(k),
Chris@16:         as_actor<L>::convert(l),
Chris@16:         as_actor<M>::convert(m)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:     K const& k, L const& l, M const& m, N const& n
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
Chris@16:         >::composite_type ret_t;
Chris@16: 
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g),
Chris@16:         as_actor<H>::convert(h),
Chris@16:         as_actor<I>::convert(i),
Chris@16:         as_actor<J>::convert(j),
Chris@16:         as_actor<K>::convert(k),
Chris@16:         as_actor<L>::convert(l),
Chris@16:         as_actor<M>::convert(m),
Chris@16:         as_actor<N>::convert(n)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename OperationT>
Chris@16: template <
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M, typename N, typename O
Chris@16: >
Chris@16: inline typename impl::make_composite<
Chris@16:     OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
Chris@16: >::type
Chris@16: function<OperationT>::operator()(
Chris@16:     A const& a, B const& b, C const& c, D const& d, E const& e,
Chris@16:     F const& f, G const& g, H const& h, I const& i, J const& j,
Chris@16:     K const& k, L const& l, M const& m, N const& n, O const& o
Chris@16: ) const
Chris@16: {
Chris@16:     typedef typename impl::make_composite<
Chris@16:             OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
Chris@16:         >::composite_type ret_t;
Chris@16:         
Chris@16:     return ret_t(
Chris@16:         op,
Chris@16:         as_actor<A>::convert(a),
Chris@16:         as_actor<B>::convert(b),
Chris@16:         as_actor<C>::convert(c),
Chris@16:         as_actor<D>::convert(d),
Chris@16:         as_actor<E>::convert(e),
Chris@16:         as_actor<F>::convert(f),
Chris@16:         as_actor<G>::convert(g),
Chris@16:         as_actor<H>::convert(h),
Chris@16:         as_actor<I>::convert(i),
Chris@16:         as_actor<J>::convert(j),
Chris@16:         as_actor<K>::convert(k),
Chris@16:         as_actor<L>::convert(l),
Chris@16:         as_actor<M>::convert(m),
Chris@16:         as_actor<N>::convert(n),
Chris@16:         as_actor<O>::convert(o)
Chris@16:     );
Chris@16: }
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: }   //  namespace phoenix
Chris@16: 
Chris@16: #endif