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