sl@0: /*=============================================================================
sl@0:     Phoenix V1.2.1
sl@0:     Copyright (c) 2001-2002 Joel de Guzman
sl@0: 
sl@0:     Use, modification and distribution is subject to the Boost Software
sl@0:     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
sl@0:     http://www.boost.org/LICENSE_1_0.txt)
sl@0: ==============================================================================*/
sl@0: #ifndef PHOENIX_COMPOSITE_HPP
sl@0: #define PHOENIX_COMPOSITE_HPP
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: #include <boost/spirit/phoenix/actor.hpp>
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: namespace phoenix {
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite class
sl@0: //
sl@0: //      A composite is an actor base class composed of zero or more
sl@0: //      actors (see actor.hpp) and an operation. A composite is itself
sl@0: //      an actor superclass and conforms to its conceptual interface.
sl@0: //      Its eval member function un-funnels the tupled actual arguments
sl@0: //      from the tuple by invoking each of the actors' eval member
sl@0: //      function. The results of each are then passed on as arguments to
sl@0: //      the operation. Specializations are provided to handle different
sl@0: //      numbers of actors.
sl@0: //
sl@0: //      Schematically:
sl@0: //
sl@0: //          actor0.eval(tupled_args) --> arg0 --> |
sl@0: //          actor1.eval(tupled_args) --> arg1 --> |
sl@0: //          actor2.eval(tupled_args) --> arg3 --> | --> operation(arg0...argN)
sl@0: //            ...                                 |
sl@0: //          actorN.eval(tupled_args) --> argN --> |
sl@0: //
sl@0: //      The operation can be any suitable functor that can accept the
sl@0: //      arguments passed in by the composite. The operation is expected
sl@0: //      to have a member operator() that carries out the actual
sl@0: //      operation. There should be a one to one correspondence between
sl@0: //      actors of the composite and the arguments of the operation's
sl@0: //      member operator().
sl@0: //
sl@0: //      The operation is also expected to have a nested template class
sl@0: //      result<T0...TN>. The nested template class result should have a
sl@0: //      typedef 'type' that reflects the return type of its member
sl@0: //      operator(). This is essentially a type computer that answers the
sl@0: //      metaprogramming question "Given arguments of type T0...TN, what
sl@0: //      will be its operator()'s return type?".
sl@0: //
sl@0: //      There is a special case for operations that accept no arguments.
sl@0: //      Such nullary operations are only required to define a typedef
sl@0: //      result_type that reflects the return type of its operator().
sl@0: //
sl@0: //      Here's an example of a simple operation that squares a number:
sl@0: //
sl@0: //          struct square {
sl@0: //
sl@0: //              template <typename ArgT>
sl@0: //              struct result { typedef ArgT type; };
sl@0: //
sl@0: //              template <typename ArgT>
sl@0: //              ArgT operator()(ArgT n) const { return n * n; }
sl@0: //          };
sl@0: //
sl@0: //      As can be seen, operations can be polymorphic. Its arguments and
sl@0: //      return type are not fixed to a particular type. The example
sl@0: //      above for example, can handle any ArgT type as long as it has a
sl@0: //      multiplication operator.
sl@0: //
sl@0: //      Composites are not created directly. Instead, there are meta-
sl@0: //      programs provided that indirectly create composites. See
sl@0: //      operators.hpp, binders.hpp and functions.hpp for examples.
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <
sl@0:     typename OperationT
sl@0:     ,   typename A = nil_t
sl@0:     ,   typename B = nil_t
sl@0:     ,   typename C = nil_t
sl@0: 
sl@0: #if PHOENIX_LIMIT > 3
sl@0:     ,   typename D = nil_t
sl@0:     ,   typename E = nil_t
sl@0:     ,   typename F = nil_t
sl@0: 
sl@0: #if PHOENIX_LIMIT > 6
sl@0:     ,   typename G = nil_t
sl@0:     ,   typename H = nil_t
sl@0:     ,   typename I = nil_t
sl@0: 
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     ,   typename J = nil_t
sl@0:     ,   typename K = nil_t
sl@0:     ,   typename L = nil_t
sl@0: 
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     ,   typename M = nil_t
sl@0:     ,   typename N = nil_t
sl@0:     ,   typename O = nil_t
sl@0: 
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: 
sl@0:     ,   typename NU = nil_t  // Not used
sl@0: >
sl@0: struct composite;
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <0 actor> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT>
sl@0: struct composite0_result {
sl@0: 
sl@0:     typedef typename OperationT::result_type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT>
sl@0: struct composite<OperationT,
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 3
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 6
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite0_result<
sl@0:             OperationT, TupleT
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_)
sl@0:     :   op(op_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename OperationT::result_type
sl@0:     eval(TupleT const& /*args*/) const
sl@0:     {
sl@0:         return op();
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <1 actor> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A>
sl@0: struct composite1_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A>
sl@0: struct composite<OperationT,
sl@0:     A, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 3
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 6
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite1_result<
sl@0:             OperationT, TupleT, A
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_)
sl@0:     :   op(op_), a(a_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         return op(ra);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <2 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B>
sl@0: struct composite2_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B>
sl@0: struct composite<OperationT,
sl@0:     A, B, nil_t,
sl@0: #if PHOENIX_LIMIT > 3
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 6
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite2_result<
sl@0:             OperationT, TupleT, A, B
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_)
sl@0:     :   op(op_), a(a_), b(b_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         return op(ra, rb);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <3 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C>
sl@0: struct composite3_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C>
sl@0: struct composite<OperationT,
sl@0:     A, B, C,
sl@0: #if PHOENIX_LIMIT > 3
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 6
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B, C> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite3_result<
sl@0:             OperationT, TupleT, A, B, C
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         return op(ra, rb, rc);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; //  actors
sl@0: };
sl@0: 
sl@0: #if PHOENIX_LIMIT > 3
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <4 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D>
sl@0: struct composite4_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 6
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B, C, D> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite4_result<
sl@0:             OperationT, TupleT, A, B, C, D
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         return op(ra, rb, rc, rd);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <5 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E>
sl@0: struct composite5_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, nil_t,
sl@0: #if PHOENIX_LIMIT > 6
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B, C, D, E> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite5_result<
sl@0:             OperationT, TupleT, A, B, C, D, E
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         return op(ra, rb, rc, rd, re);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <6 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F>
sl@0: struct composite6_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F,
sl@0: #if PHOENIX_LIMIT > 6
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B, C, D, E, F> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite6_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; //  actors
sl@0: };
sl@0: 
sl@0: #if PHOENIX_LIMIT > 6
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <7 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G>
sl@0: struct composite7_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B, C, D, E, F, G> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite7_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <8 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H>
sl@0: struct composite8_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type,
sl@0:         typename actor_result<H, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, H, nil_t,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B, C, D, E, F, G, H> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite8_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G, H
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_, H const& h_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_), h(h_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         typename actor_result<H, TupleT>::type rh = h.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg, rh);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; H h; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <9 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I>
sl@0: struct composite9_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type,
sl@0:         typename actor_result<H, TupleT>::plain_type,
sl@0:         typename actor_result<I, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, H, I,
sl@0: #if PHOENIX_LIMIT > 9
sl@0:     nil_t, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B, C, D, E, F, G, H, I> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite9_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G, H, I
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_, H const& h_, I const& i_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_), h(h_), i(i_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         typename actor_result<H, TupleT>::type rh = h.eval(args);
sl@0:         typename actor_result<I, TupleT>::type ri = i.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg, rh, ri);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; H h; I i; //  actors
sl@0: };
sl@0: 
sl@0: #if PHOENIX_LIMIT > 9
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <10 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J>
sl@0: struct composite10_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type,
sl@0:         typename actor_result<H, TupleT>::plain_type,
sl@0:         typename actor_result<I, TupleT>::plain_type,
sl@0:         typename actor_result<J, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT, A, B, C, D, E, F, G, H, I, J> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite10_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_), h(h_), i(i_), j(j_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         typename actor_result<H, TupleT>::type rh = h.eval(args);
sl@0:         typename actor_result<I, TupleT>::type ri = i.eval(args);
sl@0:         typename actor_result<J, TupleT>::type rj = j.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <11 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K>
sl@0: struct composite11_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type,
sl@0:         typename actor_result<H, TupleT>::plain_type,
sl@0:         typename actor_result<I, TupleT>::plain_type,
sl@0:         typename actor_result<J, TupleT>::plain_type,
sl@0:         typename actor_result<K, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, H, I, J, K, nil_t,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT,
sl@0:         A, B, C, D, E, F, G, H, I, J, K> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite11_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
sl@0:         K const& k_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_), h(h_), i(i_), j(j_),
sl@0:         k(k_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         typename actor_result<H, TupleT>::type rh = h.eval(args);
sl@0:         typename actor_result<I, TupleT>::type ri = i.eval(args);
sl@0:         typename actor_result<J, TupleT>::type rj = j.eval(args);
sl@0:         typename actor_result<K, TupleT>::type rk = k.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
sl@0:     K k;//  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <12 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K, typename L>
sl@0: struct composite12_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type,
sl@0:         typename actor_result<H, TupleT>::plain_type,
sl@0:         typename actor_result<I, TupleT>::plain_type,
sl@0:         typename actor_result<J, TupleT>::plain_type,
sl@0:         typename actor_result<K, TupleT>::plain_type,
sl@0:         typename actor_result<L, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K, typename L>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, H, I, J, K, L,
sl@0: #if PHOENIX_LIMIT > 12
sl@0:     nil_t, nil_t, nil_t,
sl@0: #endif
sl@0:     nil_t   //  Unused
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT,
sl@0:         A, B, C, D, E, F, G, H, I, J, K, L> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite12_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
sl@0:         K const& k_, L const& l_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_), h(h_), i(i_), j(j_),
sl@0:         k(k_), l(l_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         typename actor_result<H, TupleT>::type rh = h.eval(args);
sl@0:         typename actor_result<I, TupleT>::type ri = i.eval(args);
sl@0:         typename actor_result<J, TupleT>::type rj = j.eval(args);
sl@0:         typename actor_result<K, TupleT>::type rk = k.eval(args);
sl@0:         typename actor_result<L, TupleT>::type rl = l.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
sl@0:     K k; L l;//  actors
sl@0: };
sl@0: 
sl@0: #if PHOENIX_LIMIT > 12
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <13 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K, typename L, typename M>
sl@0: struct composite13_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type,
sl@0:         typename actor_result<H, TupleT>::plain_type,
sl@0:         typename actor_result<I, TupleT>::plain_type,
sl@0:         typename actor_result<J, TupleT>::plain_type,
sl@0:         typename actor_result<K, TupleT>::plain_type,
sl@0:         typename actor_result<L, TupleT>::plain_type,
sl@0:         typename actor_result<M, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K, typename L, typename M>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT,
sl@0:         A, B, C, D, E, F, G, H, I, J, K, L, M> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite13_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
sl@0:         K const& k_, L const& l_, M const& m_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_), h(h_), i(i_), j(j_),
sl@0:         k(k_), l(l_), m(m_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         typename actor_result<H, TupleT>::type rh = h.eval(args);
sl@0:         typename actor_result<I, TupleT>::type ri = i.eval(args);
sl@0:         typename actor_result<J, TupleT>::type rj = j.eval(args);
sl@0:         typename actor_result<K, TupleT>::type rk = k.eval(args);
sl@0:         typename actor_result<L, TupleT>::type rl = l.eval(args);
sl@0:         typename actor_result<M, TupleT>::type rm = m.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
sl@0:     K k; L l; M m; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <14 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K, typename L, typename M, typename N>
sl@0: struct composite14_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type,
sl@0:         typename actor_result<H, TupleT>::plain_type,
sl@0:         typename actor_result<I, TupleT>::plain_type,
sl@0:         typename actor_result<J, TupleT>::plain_type,
sl@0:         typename actor_result<K, TupleT>::plain_type,
sl@0:         typename actor_result<L, TupleT>::plain_type,
sl@0:         typename actor_result<M, TupleT>::plain_type,
sl@0:         typename actor_result<N, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K, typename L, typename M, typename N>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT,
sl@0:         A, B, C, D, E, F, G, H, I, J, K, L, M, N> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite14_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
sl@0:         K const& k_, L const& l_, M const& m_, N const& n_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_), h(h_), i(i_), j(j_),
sl@0:         k(k_), l(l_), m(m_), n(n_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         typename actor_result<H, TupleT>::type rh = h.eval(args);
sl@0:         typename actor_result<I, TupleT>::type ri = i.eval(args);
sl@0:         typename actor_result<J, TupleT>::type rj = j.eval(args);
sl@0:         typename actor_result<K, TupleT>::type rk = k.eval(args);
sl@0:         typename actor_result<L, TupleT>::type rl = l.eval(args);
sl@0:         typename actor_result<M, TupleT>::type rm = m.eval(args);
sl@0:         typename actor_result<N, TupleT>::type rn = n.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
sl@0:     K k; L l; M m; N n; //  actors
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: //  composite <15 actors> class
sl@0: //
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: template <typename OperationT, typename TupleT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K, typename L, typename M, typename N, typename O>
sl@0: struct composite15_result {
sl@0: 
sl@0:     typedef typename OperationT::template result<
sl@0:         typename actor_result<A, TupleT>::plain_type,
sl@0:         typename actor_result<B, TupleT>::plain_type,
sl@0:         typename actor_result<C, TupleT>::plain_type,
sl@0:         typename actor_result<D, TupleT>::plain_type,
sl@0:         typename actor_result<E, TupleT>::plain_type,
sl@0:         typename actor_result<F, TupleT>::plain_type,
sl@0:         typename actor_result<G, TupleT>::plain_type,
sl@0:         typename actor_result<H, TupleT>::plain_type,
sl@0:         typename actor_result<I, TupleT>::plain_type,
sl@0:         typename actor_result<J, TupleT>::plain_type,
sl@0:         typename actor_result<K, TupleT>::plain_type,
sl@0:         typename actor_result<L, TupleT>::plain_type,
sl@0:         typename actor_result<M, TupleT>::plain_type,
sl@0:         typename actor_result<N, TupleT>::plain_type,
sl@0:         typename actor_result<O, TupleT>::plain_type
sl@0:     >::type type;
sl@0: };
sl@0: 
sl@0: //////////////////////////////////
sl@0: template <typename OperationT,
sl@0:     typename A, typename B, typename C, typename D, typename E,
sl@0:     typename F, typename G, typename H, typename I, typename J,
sl@0:     typename K, typename L, typename M, typename N, typename O>
sl@0: struct composite<OperationT,
sl@0:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t
sl@0: > {
sl@0: 
sl@0:     typedef composite<OperationT,
sl@0:         A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> self_t;
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     struct result {
sl@0: 
sl@0:         typedef typename composite15_result<
sl@0:             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
sl@0:         >::type type;
sl@0:     };
sl@0: 
sl@0:     composite(OperationT const& op_,
sl@0:         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
sl@0:         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
sl@0:         K const& k_, L const& l_, M const& m_, N const& n_, O const& o_)
sl@0:     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
sl@0:         f(f_), g(g_), h(h_), i(i_), j(j_),
sl@0:         k(k_), l(l_), m(m_), n(n_), o(o_) {}
sl@0: 
sl@0:     template <typename TupleT>
sl@0:     typename actor_result<self_t, TupleT>::type
sl@0:     eval(TupleT const& args) const
sl@0:     {
sl@0:         typename actor_result<A, TupleT>::type ra = a.eval(args);
sl@0:         typename actor_result<B, TupleT>::type rb = b.eval(args);
sl@0:         typename actor_result<C, TupleT>::type rc = c.eval(args);
sl@0:         typename actor_result<D, TupleT>::type rd = d.eval(args);
sl@0:         typename actor_result<E, TupleT>::type re = e.eval(args);
sl@0:         typename actor_result<F, TupleT>::type rf = f.eval(args);
sl@0:         typename actor_result<G, TupleT>::type rg = g.eval(args);
sl@0:         typename actor_result<H, TupleT>::type rh = h.eval(args);
sl@0:         typename actor_result<I, TupleT>::type ri = i.eval(args);
sl@0:         typename actor_result<J, TupleT>::type rj = j.eval(args);
sl@0:         typename actor_result<K, TupleT>::type rk = k.eval(args);
sl@0:         typename actor_result<L, TupleT>::type rl = l.eval(args);
sl@0:         typename actor_result<M, TupleT>::type rm = m.eval(args);
sl@0:         typename actor_result<N, TupleT>::type rn = n.eval(args);
sl@0:         typename actor_result<O, TupleT>::type ro = o.eval(args);
sl@0:         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn, ro);
sl@0:     }
sl@0: 
sl@0:     mutable OperationT op; //  operation
sl@0:     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
sl@0:     K k; L l; M m; N n; O o; //  actors
sl@0: };
sl@0: 
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: 
sl@0: namespace impl {
sl@0: 
sl@0:     ///////////////////////////////////////////////////////////////////////////
sl@0:     //
sl@0:     //      make_composite is basically a type computer that answers the
sl@0:     //      question "Given types T0..TN, what composite type should I
sl@0:     //      create <composite_type> and if I were to generate an actual
sl@0:     //      composite, what type <type> should I return?"
sl@0:     //
sl@0:     ///////////////////////////////////////////////////////////////////////////
sl@0:     template <
sl@0:         typename OperationT
sl@0:         ,   typename A = nil_t
sl@0:         ,   typename B = nil_t
sl@0:         ,   typename C = nil_t
sl@0: 
sl@0: #if PHOENIX_LIMIT > 3
sl@0:         ,   typename D = nil_t
sl@0:         ,   typename E = nil_t
sl@0:         ,   typename F = nil_t
sl@0: 
sl@0: #if PHOENIX_LIMIT > 6
sl@0:         ,   typename G = nil_t
sl@0:         ,   typename H = nil_t
sl@0:         ,   typename I = nil_t
sl@0: 
sl@0: #if PHOENIX_LIMIT > 9
sl@0:         ,   typename J = nil_t
sl@0:         ,   typename K = nil_t
sl@0:         ,   typename L = nil_t
sl@0: 
sl@0: #if PHOENIX_LIMIT > 12
sl@0:         ,   typename M = nil_t
sl@0:         ,   typename N = nil_t
sl@0:         ,   typename O = nil_t
sl@0: 
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:     >
sl@0:     struct make_composite {
sl@0: 
sl@0:         typedef composite<OperationT
sl@0:             ,   typename as_actor<A>::type
sl@0:             ,   typename as_actor<B>::type
sl@0:             ,   typename as_actor<C>::type
sl@0: 
sl@0: #if PHOENIX_LIMIT > 3
sl@0:             ,   typename as_actor<D>::type
sl@0:             ,   typename as_actor<E>::type
sl@0:             ,   typename as_actor<F>::type
sl@0: 
sl@0: #if PHOENIX_LIMIT > 6
sl@0:             ,   typename as_actor<G>::type
sl@0:             ,   typename as_actor<H>::type
sl@0:             ,   typename as_actor<I>::type
sl@0: 
sl@0: #if PHOENIX_LIMIT > 9
sl@0:             ,   typename as_actor<J>::type
sl@0:             ,   typename as_actor<K>::type
sl@0:             ,   typename as_actor<L>::type
sl@0: 
sl@0: #if PHOENIX_LIMIT > 12
sl@0:             ,   typename as_actor<M>::type
sl@0:             ,   typename as_actor<N>::type
sl@0:             ,   typename as_actor<O>::type
sl@0: 
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0: #endif
sl@0:         > composite_type;
sl@0: 
sl@0:         typedef actor<composite_type> type;
sl@0:     };
sl@0: 
sl@0:     ///////////////////////////////////////////////////////////////////////////
sl@0:     //
sl@0:     //      make_unary, make_binary, make_binary1, make_binary2 and
sl@0:     //      make_binary3 utilities are provided here for easy creation of
sl@0:     //      unary and binary composites.
sl@0:     //
sl@0:     ///////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0:     //////////////////////////////////  input is an actor
sl@0:     template <typename OperationT, typename BaseT>
sl@0:     struct make_unary {
sl@0: 
sl@0:         typedef typename make_composite
sl@0:             <OperationT, actor<BaseT> >::type type;
sl@0: 
sl@0:         static type
sl@0:         construct(actor<BaseT> const& _0)
sl@0:         {
sl@0:             typedef typename make_composite
sl@0:                     <OperationT, actor<BaseT> >::composite_type
sl@0:                 ret_t;
sl@0: 
sl@0:             return ret_t(OperationT(), _0);
sl@0:         }
sl@0:     };
sl@0: 
sl@0:     //////////////////////////////////  LHS is an actor, RHS is unknown
sl@0:     template <typename OperationT, typename BaseT, typename B>
sl@0:     struct make_binary1 {
sl@0: 
sl@0:         typedef typename make_composite
sl@0:             <OperationT, actor<BaseT>, B>::type type;
sl@0: 
sl@0:         static type
sl@0:         construct(actor<BaseT> const& _0, B const& _1)
sl@0:         {
sl@0:             typedef typename make_composite
sl@0:                     <OperationT, actor<BaseT>, B>::composite_type
sl@0:                 ret_t;
sl@0:             
sl@0:             return ret_t(OperationT(), _0, as_actor<B>::convert(_1));
sl@0:         }
sl@0:     };
sl@0: 
sl@0:     //////////////////////////////////  LHS is unknown, RHS is an actor
sl@0:     template <typename OperationT, typename A, typename BaseT>
sl@0:     struct make_binary2 {
sl@0: 
sl@0:         typedef typename make_composite
sl@0:             <OperationT, A, actor<BaseT> >::type type;
sl@0: 
sl@0:         static type
sl@0:         construct(A const& _0, actor<BaseT> const& _1)
sl@0:         {
sl@0:             typedef typename make_composite
sl@0:                     <OperationT, A, actor<BaseT> >::composite_type
sl@0:                 ret_t;
sl@0: 
sl@0:             return ret_t(OperationT(), as_actor<A>::convert(_0), _1);
sl@0:         }
sl@0:     };
sl@0: 
sl@0:     //////////////////////////////////  Both LHS and RHS are actors
sl@0:     template <typename OperationT, typename BaseA, typename BaseB>
sl@0:     struct make_binary3 {
sl@0: 
sl@0:         typedef typename make_composite
sl@0:             <OperationT, actor<BaseA>, actor<BaseB> >::type type;
sl@0: 
sl@0:         static type
sl@0:         construct(actor<BaseA> const& _0, actor<BaseB> const& _1)
sl@0:         {
sl@0:             typedef typename make_composite
sl@0:                     <OperationT, actor<BaseA>, actor<BaseB> >::composite_type
sl@0:                 ret_t;
sl@0: 
sl@0:             return ret_t(OperationT(), _0, _1);
sl@0:         }
sl@0:     };
sl@0: 
sl@0: }   // namespace impl
sl@0: 
sl@0: }   //  namespace phoenix
sl@0: 
sl@0: #endif