Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-12-16 10:09:05 

0001 /*=============================================================================
0002     Phoenix V1.2.1
0003     Copyright (c) 2001-2002 Joel de Guzman
0004 
0005   Distributed under the Boost Software License, Version 1.0. (See accompanying
0006   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0007 ==============================================================================*/
0008 #ifndef BOOST_SPIRIT_CLASSIC_PHOENIX_COMPOSITE_HPP
0009 #define BOOST_SPIRIT_CLASSIC_PHOENIX_COMPOSITE_HPP
0010 
0011 ///////////////////////////////////////////////////////////////////////////////
0012 #include <boost/spirit/home/classic/phoenix/actor.hpp>
0013 
0014 ///////////////////////////////////////////////////////////////////////////////
0015 namespace phoenix {
0016 
0017 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
0018 #pragma warning(push)
0019 #pragma warning(disable:4512) //assignment operator could not be generated
0020 #endif
0021 
0022 ///////////////////////////////////////////////////////////////////////////////
0023 //
0024 //  composite class
0025 //
0026 //      A composite is an actor base class composed of zero or more
0027 //      actors (see actor.hpp) and an operation. A composite is itself
0028 //      an actor superclass and conforms to its conceptual interface.
0029 //      Its eval member function un-funnels the tupled actual arguments
0030 //      from the tuple by invoking each of the actors' eval member
0031 //      function. The results of each are then passed on as arguments to
0032 //      the operation. Specializations are provided to handle different
0033 //      numbers of actors.
0034 //
0035 //      Schematically:
0036 //
0037 //          actor0.eval(tupled_args) --> arg0 --> |
0038 //          actor1.eval(tupled_args) --> arg1 --> |
0039 //          actor2.eval(tupled_args) --> arg3 --> | --> operation(arg0...argN)
0040 //            ...                                 |
0041 //          actorN.eval(tupled_args) --> argN --> |
0042 //
0043 //      The operation can be any suitable functor that can accept the
0044 //      arguments passed in by the composite. The operation is expected
0045 //      to have a member operator() that carries out the actual
0046 //      operation. There should be a one to one correspondence between
0047 //      actors of the composite and the arguments of the operation's
0048 //      member operator().
0049 //
0050 //      The operation is also expected to have a nested template class
0051 //      result<T0...TN>. The nested template class result should have a
0052 //      typedef 'type' that reflects the return type of its member
0053 //      operator(). This is essentially a type computer that answers the
0054 //      metaprogramming question "Given arguments of type T0...TN, what
0055 //      will be its operator()'s return type?".
0056 //
0057 //      There is a special case for operations that accept no arguments.
0058 //      Such nullary operations are only required to define a typedef
0059 //      result_type that reflects the return type of its operator().
0060 //
0061 //      Here's an example of a simple operation that squares a number:
0062 //
0063 //          struct square {
0064 //
0065 //              template <typename ArgT>
0066 //              struct result { typedef ArgT type; };
0067 //
0068 //              template <typename ArgT>
0069 //              ArgT operator()(ArgT n) const { return n * n; }
0070 //          };
0071 //
0072 //      As can be seen, operations can be polymorphic. Its arguments and
0073 //      return type are not fixed to a particular type. The example
0074 //      above for example, can handle any ArgT type as long as it has a
0075 //      multiplication operator.
0076 //
0077 //      Composites are not created directly. Instead, there are meta-
0078 //      programs provided that indirectly create composites. See
0079 //      operators.hpp, binders.hpp and functions.hpp for examples.
0080 //
0081 ///////////////////////////////////////////////////////////////////////////////
0082 template <
0083     typename OperationT
0084     ,   typename A = nil_t
0085     ,   typename B = nil_t
0086     ,   typename C = nil_t
0087 
0088 #if PHOENIX_LIMIT > 3
0089     ,   typename D = nil_t
0090     ,   typename E = nil_t
0091     ,   typename F = nil_t
0092 
0093 #if PHOENIX_LIMIT > 6
0094     ,   typename G = nil_t
0095     ,   typename H = nil_t
0096     ,   typename I = nil_t
0097 
0098 #if PHOENIX_LIMIT > 9
0099     ,   typename J = nil_t
0100     ,   typename K = nil_t
0101     ,   typename L = nil_t
0102 
0103 #if PHOENIX_LIMIT > 12
0104     ,   typename M = nil_t
0105     ,   typename N = nil_t
0106     ,   typename O = nil_t
0107 
0108 #endif
0109 #endif
0110 #endif
0111 #endif
0112 
0113     ,   typename NU = nil_t  // Not used
0114 >
0115 struct composite;
0116 
0117 ///////////////////////////////////////////////////////////////////////////////
0118 //
0119 //  composite <0 actor> class
0120 //
0121 ///////////////////////////////////////////////////////////////////////////////
0122 template <typename OperationT, typename TupleT>
0123 struct composite0_result {
0124 
0125     typedef typename OperationT::result_type type;
0126 };
0127 
0128 //////////////////////////////////
0129 template <typename OperationT>
0130 struct composite<OperationT,
0131     nil_t, nil_t, nil_t,
0132 #if PHOENIX_LIMIT > 3
0133     nil_t, nil_t, nil_t,
0134 #if PHOENIX_LIMIT > 6
0135     nil_t, nil_t, nil_t,
0136 #if PHOENIX_LIMIT > 9
0137     nil_t, nil_t, nil_t,
0138 #if PHOENIX_LIMIT > 12
0139     nil_t, nil_t, nil_t,
0140 #endif
0141 #endif
0142 #endif
0143 #endif
0144     nil_t   //  Unused
0145 > {
0146 
0147     typedef composite<OperationT> self_t;
0148 
0149     template <typename TupleT>
0150     struct result {
0151 
0152         typedef typename composite0_result<
0153             OperationT, TupleT
0154         >::type type;
0155     };
0156 
0157     composite(OperationT const& op_)
0158     :   op(op_) {}
0159 
0160     template <typename TupleT>
0161     typename OperationT::result_type
0162     eval(TupleT const& /*args*/) const
0163     {
0164         return op();
0165     }
0166 
0167     mutable OperationT op; //  operation
0168 };
0169 
0170 ///////////////////////////////////////////////////////////////////////////////
0171 //
0172 //  composite <1 actor> class
0173 //
0174 ///////////////////////////////////////////////////////////////////////////////
0175 template <typename OperationT, typename TupleT,
0176     typename A>
0177 struct composite1_result {
0178 
0179     typedef typename OperationT::template result<
0180         typename actor_result<A, TupleT>::plain_type
0181     >::type type;
0182 };
0183 
0184 //////////////////////////////////
0185 template <typename OperationT,
0186     typename A>
0187 struct composite<OperationT,
0188     A, nil_t, nil_t,
0189 #if PHOENIX_LIMIT > 3
0190     nil_t, nil_t, nil_t,
0191 #if PHOENIX_LIMIT > 6
0192     nil_t, nil_t, nil_t,
0193 #if PHOENIX_LIMIT > 9
0194     nil_t, nil_t, nil_t,
0195 #if PHOENIX_LIMIT > 12
0196     nil_t, nil_t, nil_t,
0197 #endif
0198 #endif
0199 #endif
0200 #endif
0201     nil_t   //  Unused
0202 > {
0203 
0204     typedef composite<OperationT, A> self_t;
0205 
0206     template <typename TupleT>
0207     struct result {
0208 
0209         typedef typename composite1_result<
0210             OperationT, TupleT, A
0211         >::type type;
0212     };
0213 
0214     composite(OperationT const& op_,
0215         A const& a_)
0216     :   op(op_), a(a_) {}
0217 
0218     template <typename TupleT>
0219     typename actor_result<self_t, TupleT>::type
0220     eval(TupleT const& args) const
0221     {
0222         typename actor_result<A, TupleT>::type ra = a.eval(args);
0223         return op(ra);
0224     }
0225 
0226     mutable OperationT op; //  operation
0227     A a; //  actors
0228 };
0229 
0230 ///////////////////////////////////////////////////////////////////////////////
0231 //
0232 //  composite <2 actors> class
0233 //
0234 ///////////////////////////////////////////////////////////////////////////////
0235 template <typename OperationT, typename TupleT,
0236     typename A, typename B>
0237 struct composite2_result {
0238 
0239     typedef typename OperationT::template result<
0240         typename actor_result<A, TupleT>::plain_type,
0241         typename actor_result<B, TupleT>::plain_type
0242     >::type type;
0243 };
0244 
0245 //////////////////////////////////
0246 template <typename OperationT,
0247     typename A, typename B>
0248 struct composite<OperationT,
0249     A, B, nil_t,
0250 #if PHOENIX_LIMIT > 3
0251     nil_t, nil_t, nil_t,
0252 #if PHOENIX_LIMIT > 6
0253     nil_t, nil_t, nil_t,
0254 #if PHOENIX_LIMIT > 9
0255     nil_t, nil_t, nil_t,
0256 #if PHOENIX_LIMIT > 12
0257     nil_t, nil_t, nil_t,
0258 #endif
0259 #endif
0260 #endif
0261 #endif
0262     nil_t   //  Unused
0263 > {
0264 
0265     typedef composite<OperationT, A, B> self_t;
0266 
0267     template <typename TupleT>
0268     struct result {
0269 
0270         typedef typename composite2_result<
0271             OperationT, TupleT, A, B
0272         >::type type;
0273     };
0274 
0275     composite(OperationT const& op_,
0276         A const& a_, B const& b_)
0277     :   op(op_), a(a_), b(b_) {}
0278 
0279     template <typename TupleT>
0280     typename actor_result<self_t, TupleT>::type
0281     eval(TupleT const& args) const
0282     {
0283         typename actor_result<A, TupleT>::type ra = a.eval(args);
0284         typename actor_result<B, TupleT>::type rb = b.eval(args);
0285         return op(ra, rb);
0286     }
0287 
0288     mutable OperationT op; //  operation
0289     A a; B b; //  actors
0290 };
0291 
0292 ///////////////////////////////////////////////////////////////////////////////
0293 //
0294 //  composite <3 actors> class
0295 //
0296 ///////////////////////////////////////////////////////////////////////////////
0297 template <typename OperationT, typename TupleT,
0298     typename A, typename B, typename C>
0299 struct composite3_result {
0300 
0301     typedef typename OperationT::template result<
0302         typename actor_result<A, TupleT>::plain_type,
0303         typename actor_result<B, TupleT>::plain_type,
0304         typename actor_result<C, TupleT>::plain_type
0305     >::type type;
0306 };
0307 
0308 //////////////////////////////////
0309 template <typename OperationT,
0310     typename A, typename B, typename C>
0311 struct composite<OperationT,
0312     A, B, C,
0313 #if PHOENIX_LIMIT > 3
0314     nil_t, nil_t, nil_t,
0315 #if PHOENIX_LIMIT > 6
0316     nil_t, nil_t, nil_t,
0317 #if PHOENIX_LIMIT > 9
0318     nil_t, nil_t, nil_t,
0319 #if PHOENIX_LIMIT > 12
0320     nil_t, nil_t, nil_t,
0321 #endif
0322 #endif
0323 #endif
0324 #endif
0325     nil_t   //  Unused
0326 > {
0327 
0328     typedef composite<OperationT, A, B, C> self_t;
0329 
0330     template <typename TupleT>
0331     struct result {
0332 
0333         typedef typename composite3_result<
0334             OperationT, TupleT, A, B, C
0335         >::type type;
0336     };
0337 
0338     composite(OperationT const& op_,
0339         A const& a_, B const& b_, C const& c_)
0340     :   op(op_), a(a_), b(b_), c(c_) {}
0341 
0342     template <typename TupleT>
0343     typename actor_result<self_t, TupleT>::type
0344     eval(TupleT const& args) const
0345     {
0346         typename actor_result<A, TupleT>::type ra = a.eval(args);
0347         typename actor_result<B, TupleT>::type rb = b.eval(args);
0348         typename actor_result<C, TupleT>::type rc = c.eval(args);
0349         return op(ra, rb, rc);
0350     }
0351 
0352     mutable OperationT op; //  operation
0353     A a; B b; C c; //  actors
0354 };
0355 
0356 #if PHOENIX_LIMIT > 3
0357 ///////////////////////////////////////////////////////////////////////////////
0358 //
0359 //  composite <4 actors> class
0360 //
0361 ///////////////////////////////////////////////////////////////////////////////
0362 template <typename OperationT, typename TupleT,
0363     typename A, typename B, typename C, typename D>
0364 struct composite4_result {
0365 
0366     typedef typename OperationT::template result<
0367         typename actor_result<A, TupleT>::plain_type,
0368         typename actor_result<B, TupleT>::plain_type,
0369         typename actor_result<C, TupleT>::plain_type,
0370         typename actor_result<D, TupleT>::plain_type
0371     >::type type;
0372 };
0373 
0374 //////////////////////////////////
0375 template <typename OperationT,
0376     typename A, typename B, typename C, typename D>
0377 struct composite<OperationT,
0378     A, B, C, D, nil_t, nil_t,
0379 #if PHOENIX_LIMIT > 6
0380     nil_t, nil_t, nil_t,
0381 #if PHOENIX_LIMIT > 9
0382     nil_t, nil_t, nil_t,
0383 #if PHOENIX_LIMIT > 12
0384     nil_t, nil_t, nil_t,
0385 #endif
0386 #endif
0387 #endif
0388     nil_t   //  Unused
0389 > {
0390 
0391     typedef composite<OperationT, A, B, C, D> self_t;
0392 
0393     template <typename TupleT>
0394     struct result {
0395 
0396         typedef typename composite4_result<
0397             OperationT, TupleT, A, B, C, D
0398         >::type type;
0399     };
0400 
0401     composite(OperationT const& op_,
0402         A const& a_, B const& b_, C const& c_, D const& d_)
0403     :   op(op_), a(a_), b(b_), c(c_), d(d_) {}
0404 
0405     template <typename TupleT>
0406     typename actor_result<self_t, TupleT>::type
0407     eval(TupleT const& args) const
0408     {
0409         typename actor_result<A, TupleT>::type ra = a.eval(args);
0410         typename actor_result<B, TupleT>::type rb = b.eval(args);
0411         typename actor_result<C, TupleT>::type rc = c.eval(args);
0412         typename actor_result<D, TupleT>::type rd = d.eval(args);
0413         return op(ra, rb, rc, rd);
0414     }
0415 
0416     mutable OperationT op; //  operation
0417     A a; B b; C c; D d; //  actors
0418 };
0419 
0420 ///////////////////////////////////////////////////////////////////////////////
0421 //
0422 //  composite <5 actors> class
0423 //
0424 ///////////////////////////////////////////////////////////////////////////////
0425 template <typename OperationT, typename TupleT,
0426     typename A, typename B, typename C, typename D, typename E>
0427 struct composite5_result {
0428 
0429     typedef typename OperationT::template result<
0430         typename actor_result<A, TupleT>::plain_type,
0431         typename actor_result<B, TupleT>::plain_type,
0432         typename actor_result<C, TupleT>::plain_type,
0433         typename actor_result<D, TupleT>::plain_type,
0434         typename actor_result<E, TupleT>::plain_type
0435     >::type type;
0436 };
0437 
0438 //////////////////////////////////
0439 template <typename OperationT,
0440     typename A, typename B, typename C, typename D, typename E>
0441 struct composite<OperationT,
0442     A, B, C, D, E, nil_t,
0443 #if PHOENIX_LIMIT > 6
0444     nil_t, nil_t, nil_t,
0445 #if PHOENIX_LIMIT > 9
0446     nil_t, nil_t, nil_t,
0447 #if PHOENIX_LIMIT > 12
0448     nil_t, nil_t, nil_t,
0449 #endif
0450 #endif
0451 #endif
0452     nil_t   //  Unused
0453 > {
0454 
0455     typedef composite<OperationT, A, B, C, D, E> self_t;
0456 
0457     template <typename TupleT>
0458     struct result {
0459 
0460         typedef typename composite5_result<
0461             OperationT, TupleT, A, B, C, D, E
0462         >::type type;
0463     };
0464 
0465     composite(OperationT const& op_,
0466         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_)
0467     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_) {}
0468 
0469     template <typename TupleT>
0470     typename actor_result<self_t, TupleT>::type
0471     eval(TupleT const& args) const
0472     {
0473         typename actor_result<A, TupleT>::type ra = a.eval(args);
0474         typename actor_result<B, TupleT>::type rb = b.eval(args);
0475         typename actor_result<C, TupleT>::type rc = c.eval(args);
0476         typename actor_result<D, TupleT>::type rd = d.eval(args);
0477         typename actor_result<E, TupleT>::type re = e.eval(args);
0478         return op(ra, rb, rc, rd, re);
0479     }
0480 
0481     mutable OperationT op; //  operation
0482     A a; B b; C c; D d; E e; //  actors
0483 };
0484 
0485 ///////////////////////////////////////////////////////////////////////////////
0486 //
0487 //  composite <6 actors> class
0488 //
0489 ///////////////////////////////////////////////////////////////////////////////
0490 template <typename OperationT, typename TupleT,
0491     typename A, typename B, typename C, typename D, typename E,
0492     typename F>
0493 struct composite6_result {
0494 
0495     typedef typename OperationT::template result<
0496         typename actor_result<A, TupleT>::plain_type,
0497         typename actor_result<B, TupleT>::plain_type,
0498         typename actor_result<C, TupleT>::plain_type,
0499         typename actor_result<D, TupleT>::plain_type,
0500         typename actor_result<E, TupleT>::plain_type,
0501         typename actor_result<F, TupleT>::plain_type
0502     >::type type;
0503 };
0504 
0505 //////////////////////////////////
0506 template <typename OperationT,
0507     typename A, typename B, typename C, typename D, typename E,
0508     typename F>
0509 struct composite<OperationT,
0510     A, B, C, D, E, F,
0511 #if PHOENIX_LIMIT > 6
0512     nil_t, nil_t, nil_t,
0513 #if PHOENIX_LIMIT > 9
0514     nil_t, nil_t, nil_t,
0515 #if PHOENIX_LIMIT > 12
0516     nil_t, nil_t, nil_t,
0517 #endif
0518 #endif
0519 #endif
0520     nil_t   //  Unused
0521 > {
0522 
0523     typedef composite<OperationT, A, B, C, D, E, F> self_t;
0524 
0525     template <typename TupleT>
0526     struct result {
0527 
0528         typedef typename composite6_result<
0529             OperationT, TupleT, A, B, C, D, E, F
0530         >::type type;
0531     };
0532 
0533     composite(OperationT const& op_,
0534         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
0535         F const& f_)
0536     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
0537         f(f_) {}
0538 
0539     template <typename TupleT>
0540     typename actor_result<self_t, TupleT>::type
0541     eval(TupleT const& args) const
0542     {
0543         typename actor_result<A, TupleT>::type ra = a.eval(args);
0544         typename actor_result<B, TupleT>::type rb = b.eval(args);
0545         typename actor_result<C, TupleT>::type rc = c.eval(args);
0546         typename actor_result<D, TupleT>::type rd = d.eval(args);
0547         typename actor_result<E, TupleT>::type re = e.eval(args);
0548         typename actor_result<F, TupleT>::type rf = f.eval(args);
0549         return op(ra, rb, rc, rd, re, rf);
0550     }
0551 
0552     mutable OperationT op; //  operation
0553     A a; B b; C c; D d; E e; F f; //  actors
0554 };
0555 
0556 #if PHOENIX_LIMIT > 6
0557 ///////////////////////////////////////////////////////////////////////////////
0558 //
0559 //  composite <7 actors> class
0560 //
0561 ///////////////////////////////////////////////////////////////////////////////
0562 template <typename OperationT, typename TupleT,
0563     typename A, typename B, typename C, typename D, typename E,
0564     typename F, typename G>
0565 struct composite7_result {
0566 
0567     typedef typename OperationT::template result<
0568         typename actor_result<A, TupleT>::plain_type,
0569         typename actor_result<B, TupleT>::plain_type,
0570         typename actor_result<C, TupleT>::plain_type,
0571         typename actor_result<D, TupleT>::plain_type,
0572         typename actor_result<E, TupleT>::plain_type,
0573         typename actor_result<F, TupleT>::plain_type,
0574         typename actor_result<G, TupleT>::plain_type
0575     >::type type;
0576 };
0577 
0578 //////////////////////////////////
0579 template <typename OperationT,
0580     typename A, typename B, typename C, typename D, typename E,
0581     typename F, typename G>
0582 struct composite<OperationT,
0583     A, B, C, D, E, F, G, nil_t, nil_t,
0584 #if PHOENIX_LIMIT > 9
0585     nil_t, nil_t, nil_t,
0586 #if PHOENIX_LIMIT > 12
0587     nil_t, nil_t, nil_t,
0588 #endif
0589 #endif
0590     nil_t   //  Unused
0591 > {
0592 
0593     typedef composite<OperationT, A, B, C, D, E, F, G> self_t;
0594 
0595     template <typename TupleT>
0596     struct result {
0597 
0598         typedef typename composite7_result<
0599             OperationT, TupleT, A, B, C, D, E, F, G
0600         >::type type;
0601     };
0602 
0603     composite(OperationT const& op_,
0604         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
0605         F const& f_, G const& g_)
0606     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
0607         f(f_), g(g_) {}
0608 
0609     template <typename TupleT>
0610     typename actor_result<self_t, TupleT>::type
0611     eval(TupleT const& args) const
0612     {
0613         typename actor_result<A, TupleT>::type ra = a.eval(args);
0614         typename actor_result<B, TupleT>::type rb = b.eval(args);
0615         typename actor_result<C, TupleT>::type rc = c.eval(args);
0616         typename actor_result<D, TupleT>::type rd = d.eval(args);
0617         typename actor_result<E, TupleT>::type re = e.eval(args);
0618         typename actor_result<F, TupleT>::type rf = f.eval(args);
0619         typename actor_result<G, TupleT>::type rg = g.eval(args);
0620         return op(ra, rb, rc, rd, re, rf, rg);
0621     }
0622 
0623     mutable OperationT op; //  operation
0624     A a; B b; C c; D d; E e; F f; G g; //  actors
0625 };
0626 
0627 ///////////////////////////////////////////////////////////////////////////////
0628 //
0629 //  composite <8 actors> class
0630 //
0631 ///////////////////////////////////////////////////////////////////////////////
0632 template <typename OperationT, typename TupleT,
0633     typename A, typename B, typename C, typename D, typename E,
0634     typename F, typename G, typename H>
0635 struct composite8_result {
0636 
0637     typedef typename OperationT::template result<
0638         typename actor_result<A, TupleT>::plain_type,
0639         typename actor_result<B, TupleT>::plain_type,
0640         typename actor_result<C, TupleT>::plain_type,
0641         typename actor_result<D, TupleT>::plain_type,
0642         typename actor_result<E, TupleT>::plain_type,
0643         typename actor_result<F, TupleT>::plain_type,
0644         typename actor_result<G, TupleT>::plain_type,
0645         typename actor_result<H, TupleT>::plain_type
0646     >::type type;
0647 };
0648 
0649 //////////////////////////////////
0650 template <typename OperationT,
0651     typename A, typename B, typename C, typename D, typename E,
0652     typename F, typename G, typename H>
0653 struct composite<OperationT,
0654     A, B, C, D, E, F, G, H, nil_t,
0655 #if PHOENIX_LIMIT > 9
0656     nil_t, nil_t, nil_t,
0657 #if PHOENIX_LIMIT > 12
0658     nil_t, nil_t, nil_t,
0659 #endif
0660 #endif
0661     nil_t   //  Unused
0662 > {
0663 
0664     typedef composite<OperationT, A, B, C, D, E, F, G, H> self_t;
0665 
0666     template <typename TupleT>
0667     struct result {
0668 
0669         typedef typename composite8_result<
0670             OperationT, TupleT, A, B, C, D, E, F, G, H
0671         >::type type;
0672     };
0673 
0674     composite(OperationT const& op_,
0675         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
0676         F const& f_, G const& g_, H const& h_)
0677     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
0678         f(f_), g(g_), h(h_) {}
0679 
0680     template <typename TupleT>
0681     typename actor_result<self_t, TupleT>::type
0682     eval(TupleT const& args) const
0683     {
0684         typename actor_result<A, TupleT>::type ra = a.eval(args);
0685         typename actor_result<B, TupleT>::type rb = b.eval(args);
0686         typename actor_result<C, TupleT>::type rc = c.eval(args);
0687         typename actor_result<D, TupleT>::type rd = d.eval(args);
0688         typename actor_result<E, TupleT>::type re = e.eval(args);
0689         typename actor_result<F, TupleT>::type rf = f.eval(args);
0690         typename actor_result<G, TupleT>::type rg = g.eval(args);
0691         typename actor_result<H, TupleT>::type rh = h.eval(args);
0692         return op(ra, rb, rc, rd, re, rf, rg, rh);
0693     }
0694 
0695     mutable OperationT op; //  operation
0696     A a; B b; C c; D d; E e; F f; G g; H h; //  actors
0697 };
0698 
0699 ///////////////////////////////////////////////////////////////////////////////
0700 //
0701 //  composite <9 actors> class
0702 //
0703 ///////////////////////////////////////////////////////////////////////////////
0704 template <typename OperationT, typename TupleT,
0705     typename A, typename B, typename C, typename D, typename E,
0706     typename F, typename G, typename H, typename I>
0707 struct composite9_result {
0708 
0709     typedef typename OperationT::template result<
0710         typename actor_result<A, TupleT>::plain_type,
0711         typename actor_result<B, TupleT>::plain_type,
0712         typename actor_result<C, TupleT>::plain_type,
0713         typename actor_result<D, TupleT>::plain_type,
0714         typename actor_result<E, TupleT>::plain_type,
0715         typename actor_result<F, TupleT>::plain_type,
0716         typename actor_result<G, TupleT>::plain_type,
0717         typename actor_result<H, TupleT>::plain_type,
0718         typename actor_result<I, TupleT>::plain_type
0719     >::type type;
0720 };
0721 
0722 //////////////////////////////////
0723 template <typename OperationT,
0724     typename A, typename B, typename C, typename D, typename E,
0725     typename F, typename G, typename H, typename I>
0726 struct composite<OperationT,
0727     A, B, C, D, E, F, G, H, I,
0728 #if PHOENIX_LIMIT > 9
0729     nil_t, nil_t, nil_t,
0730 #if PHOENIX_LIMIT > 12
0731     nil_t, nil_t, nil_t,
0732 #endif
0733 #endif
0734     nil_t   //  Unused
0735 > {
0736 
0737     typedef composite<OperationT, A, B, C, D, E, F, G, H, I> self_t;
0738 
0739     template <typename TupleT>
0740     struct result {
0741 
0742         typedef typename composite9_result<
0743             OperationT, TupleT, A, B, C, D, E, F, G, H, I
0744         >::type type;
0745     };
0746 
0747     composite(OperationT const& op_,
0748         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
0749         F const& f_, G const& g_, H const& h_, I const& i_)
0750     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
0751         f(f_), g(g_), h(h_), i(i_) {}
0752 
0753     template <typename TupleT>
0754     typename actor_result<self_t, TupleT>::type
0755     eval(TupleT const& args) const
0756     {
0757         typename actor_result<A, TupleT>::type ra = a.eval(args);
0758         typename actor_result<B, TupleT>::type rb = b.eval(args);
0759         typename actor_result<C, TupleT>::type rc = c.eval(args);
0760         typename actor_result<D, TupleT>::type rd = d.eval(args);
0761         typename actor_result<E, TupleT>::type re = e.eval(args);
0762         typename actor_result<F, TupleT>::type rf = f.eval(args);
0763         typename actor_result<G, TupleT>::type rg = g.eval(args);
0764         typename actor_result<H, TupleT>::type rh = h.eval(args);
0765         typename actor_result<I, TupleT>::type ri = i.eval(args);
0766         return op(ra, rb, rc, rd, re, rf, rg, rh, ri);
0767     }
0768 
0769     mutable OperationT op; //  operation
0770     A a; B b; C c; D d; E e; F f; G g; H h; I i; //  actors
0771 };
0772 
0773 #if PHOENIX_LIMIT > 9
0774 ///////////////////////////////////////////////////////////////////////////////
0775 //
0776 //  composite <10 actors> class
0777 //
0778 ///////////////////////////////////////////////////////////////////////////////
0779 template <typename OperationT, typename TupleT,
0780     typename A, typename B, typename C, typename D, typename E,
0781     typename F, typename G, typename H, typename I, typename J>
0782 struct composite10_result {
0783 
0784     typedef typename OperationT::template result<
0785         typename actor_result<A, TupleT>::plain_type,
0786         typename actor_result<B, TupleT>::plain_type,
0787         typename actor_result<C, TupleT>::plain_type,
0788         typename actor_result<D, TupleT>::plain_type,
0789         typename actor_result<E, TupleT>::plain_type,
0790         typename actor_result<F, TupleT>::plain_type,
0791         typename actor_result<G, TupleT>::plain_type,
0792         typename actor_result<H, TupleT>::plain_type,
0793         typename actor_result<I, TupleT>::plain_type,
0794         typename actor_result<J, TupleT>::plain_type
0795     >::type type;
0796 };
0797 
0798 //////////////////////////////////
0799 template <typename OperationT,
0800     typename A, typename B, typename C, typename D, typename E,
0801     typename F, typename G, typename H, typename I, typename J>
0802 struct composite<OperationT,
0803     A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
0804 #if PHOENIX_LIMIT > 12
0805     nil_t, nil_t, nil_t,
0806 #endif
0807     nil_t   //  Unused
0808 > {
0809 
0810     typedef composite<OperationT, A, B, C, D, E, F, G, H, I, J> self_t;
0811 
0812     template <typename TupleT>
0813     struct result {
0814 
0815         typedef typename composite10_result<
0816             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J
0817         >::type type;
0818     };
0819 
0820     composite(OperationT const& op_,
0821         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
0822         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_)
0823     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
0824         f(f_), g(g_), h(h_), i(i_), j(j_) {}
0825 
0826     template <typename TupleT>
0827     typename actor_result<self_t, TupleT>::type
0828     eval(TupleT const& args) const
0829     {
0830         typename actor_result<A, TupleT>::type ra = a.eval(args);
0831         typename actor_result<B, TupleT>::type rb = b.eval(args);
0832         typename actor_result<C, TupleT>::type rc = c.eval(args);
0833         typename actor_result<D, TupleT>::type rd = d.eval(args);
0834         typename actor_result<E, TupleT>::type re = e.eval(args);
0835         typename actor_result<F, TupleT>::type rf = f.eval(args);
0836         typename actor_result<G, TupleT>::type rg = g.eval(args);
0837         typename actor_result<H, TupleT>::type rh = h.eval(args);
0838         typename actor_result<I, TupleT>::type ri = i.eval(args);
0839         typename actor_result<J, TupleT>::type rj = j.eval(args);
0840         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj);
0841     }
0842 
0843     mutable OperationT op; //  operation
0844     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; //  actors
0845 };
0846 
0847 ///////////////////////////////////////////////////////////////////////////////
0848 //
0849 //  composite <11 actors> class
0850 //
0851 ///////////////////////////////////////////////////////////////////////////////
0852 template <typename OperationT, typename TupleT,
0853     typename A, typename B, typename C, typename D, typename E,
0854     typename F, typename G, typename H, typename I, typename J,
0855     typename K>
0856 struct composite11_result {
0857 
0858     typedef typename OperationT::template result<
0859         typename actor_result<A, TupleT>::plain_type,
0860         typename actor_result<B, TupleT>::plain_type,
0861         typename actor_result<C, TupleT>::plain_type,
0862         typename actor_result<D, TupleT>::plain_type,
0863         typename actor_result<E, TupleT>::plain_type,
0864         typename actor_result<F, TupleT>::plain_type,
0865         typename actor_result<G, TupleT>::plain_type,
0866         typename actor_result<H, TupleT>::plain_type,
0867         typename actor_result<I, TupleT>::plain_type,
0868         typename actor_result<J, TupleT>::plain_type,
0869         typename actor_result<K, TupleT>::plain_type
0870     >::type type;
0871 };
0872 
0873 //////////////////////////////////
0874 template <typename OperationT,
0875     typename A, typename B, typename C, typename D, typename E,
0876     typename F, typename G, typename H, typename I, typename J,
0877     typename K>
0878 struct composite<OperationT,
0879     A, B, C, D, E, F, G, H, I, J, K, nil_t,
0880 #if PHOENIX_LIMIT > 12
0881     nil_t, nil_t, nil_t,
0882 #endif
0883     nil_t   //  Unused
0884 > {
0885 
0886     typedef composite<OperationT,
0887         A, B, C, D, E, F, G, H, I, J, K> self_t;
0888 
0889     template <typename TupleT>
0890     struct result {
0891 
0892         typedef typename composite11_result<
0893             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K
0894         >::type type;
0895     };
0896 
0897     composite(OperationT const& op_,
0898         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
0899         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
0900         K const& k_)
0901     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
0902         f(f_), g(g_), h(h_), i(i_), j(j_),
0903         k(k_) {}
0904 
0905     template <typename TupleT>
0906     typename actor_result<self_t, TupleT>::type
0907     eval(TupleT const& args) const
0908     {
0909         typename actor_result<A, TupleT>::type ra = a.eval(args);
0910         typename actor_result<B, TupleT>::type rb = b.eval(args);
0911         typename actor_result<C, TupleT>::type rc = c.eval(args);
0912         typename actor_result<D, TupleT>::type rd = d.eval(args);
0913         typename actor_result<E, TupleT>::type re = e.eval(args);
0914         typename actor_result<F, TupleT>::type rf = f.eval(args);
0915         typename actor_result<G, TupleT>::type rg = g.eval(args);
0916         typename actor_result<H, TupleT>::type rh = h.eval(args);
0917         typename actor_result<I, TupleT>::type ri = i.eval(args);
0918         typename actor_result<J, TupleT>::type rj = j.eval(args);
0919         typename actor_result<K, TupleT>::type rk = k.eval(args);
0920         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk);
0921     }
0922 
0923     mutable OperationT op; //  operation
0924     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
0925     K k;//  actors
0926 };
0927 
0928 ///////////////////////////////////////////////////////////////////////////////
0929 //
0930 //  composite <12 actors> class
0931 //
0932 ///////////////////////////////////////////////////////////////////////////////
0933 template <typename OperationT, typename TupleT,
0934     typename A, typename B, typename C, typename D, typename E,
0935     typename F, typename G, typename H, typename I, typename J,
0936     typename K, typename L>
0937 struct composite12_result {
0938 
0939     typedef typename OperationT::template result<
0940         typename actor_result<A, TupleT>::plain_type,
0941         typename actor_result<B, TupleT>::plain_type,
0942         typename actor_result<C, TupleT>::plain_type,
0943         typename actor_result<D, TupleT>::plain_type,
0944         typename actor_result<E, TupleT>::plain_type,
0945         typename actor_result<F, TupleT>::plain_type,
0946         typename actor_result<G, TupleT>::plain_type,
0947         typename actor_result<H, TupleT>::plain_type,
0948         typename actor_result<I, TupleT>::plain_type,
0949         typename actor_result<J, TupleT>::plain_type,
0950         typename actor_result<K, TupleT>::plain_type,
0951         typename actor_result<L, TupleT>::plain_type
0952     >::type type;
0953 };
0954 
0955 //////////////////////////////////
0956 template <typename OperationT,
0957     typename A, typename B, typename C, typename D, typename E,
0958     typename F, typename G, typename H, typename I, typename J,
0959     typename K, typename L>
0960 struct composite<OperationT,
0961     A, B, C, D, E, F, G, H, I, J, K, L,
0962 #if PHOENIX_LIMIT > 12
0963     nil_t, nil_t, nil_t,
0964 #endif
0965     nil_t   //  Unused
0966 > {
0967 
0968     typedef composite<OperationT,
0969         A, B, C, D, E, F, G, H, I, J, K, L> self_t;
0970 
0971     template <typename TupleT>
0972     struct result {
0973 
0974         typedef typename composite12_result<
0975             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L
0976         >::type type;
0977     };
0978 
0979     composite(OperationT const& op_,
0980         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
0981         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
0982         K const& k_, L const& l_)
0983     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
0984         f(f_), g(g_), h(h_), i(i_), j(j_),
0985         k(k_), l(l_) {}
0986 
0987     template <typename TupleT>
0988     typename actor_result<self_t, TupleT>::type
0989     eval(TupleT const& args) const
0990     {
0991         typename actor_result<A, TupleT>::type ra = a.eval(args);
0992         typename actor_result<B, TupleT>::type rb = b.eval(args);
0993         typename actor_result<C, TupleT>::type rc = c.eval(args);
0994         typename actor_result<D, TupleT>::type rd = d.eval(args);
0995         typename actor_result<E, TupleT>::type re = e.eval(args);
0996         typename actor_result<F, TupleT>::type rf = f.eval(args);
0997         typename actor_result<G, TupleT>::type rg = g.eval(args);
0998         typename actor_result<H, TupleT>::type rh = h.eval(args);
0999         typename actor_result<I, TupleT>::type ri = i.eval(args);
1000         typename actor_result<J, TupleT>::type rj = j.eval(args);
1001         typename actor_result<K, TupleT>::type rk = k.eval(args);
1002         typename actor_result<L, TupleT>::type rl = l.eval(args);
1003         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl);
1004     }
1005 
1006     mutable OperationT op; //  operation
1007     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1008     K k; L l;//  actors
1009 };
1010 
1011 #if PHOENIX_LIMIT > 12
1012 ///////////////////////////////////////////////////////////////////////////////
1013 //
1014 //  composite <13 actors> class
1015 //
1016 ///////////////////////////////////////////////////////////////////////////////
1017 template <typename OperationT, typename TupleT,
1018     typename A, typename B, typename C, typename D, typename E,
1019     typename F, typename G, typename H, typename I, typename J,
1020     typename K, typename L, typename M>
1021 struct composite13_result {
1022 
1023     typedef typename OperationT::template result<
1024         typename actor_result<A, TupleT>::plain_type,
1025         typename actor_result<B, TupleT>::plain_type,
1026         typename actor_result<C, TupleT>::plain_type,
1027         typename actor_result<D, TupleT>::plain_type,
1028         typename actor_result<E, TupleT>::plain_type,
1029         typename actor_result<F, TupleT>::plain_type,
1030         typename actor_result<G, TupleT>::plain_type,
1031         typename actor_result<H, TupleT>::plain_type,
1032         typename actor_result<I, TupleT>::plain_type,
1033         typename actor_result<J, TupleT>::plain_type,
1034         typename actor_result<K, TupleT>::plain_type,
1035         typename actor_result<L, TupleT>::plain_type,
1036         typename actor_result<M, TupleT>::plain_type
1037     >::type type;
1038 };
1039 
1040 //////////////////////////////////
1041 template <typename OperationT,
1042     typename A, typename B, typename C, typename D, typename E,
1043     typename F, typename G, typename H, typename I, typename J,
1044     typename K, typename L, typename M>
1045 struct composite<OperationT,
1046     A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t
1047 > {
1048 
1049     typedef composite<OperationT,
1050         A, B, C, D, E, F, G, H, I, J, K, L, M> self_t;
1051 
1052     template <typename TupleT>
1053     struct result {
1054 
1055         typedef typename composite13_result<
1056             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M
1057         >::type type;
1058     };
1059 
1060     composite(OperationT const& op_,
1061         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1062         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
1063         K const& k_, L const& l_, M const& m_)
1064     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1065         f(f_), g(g_), h(h_), i(i_), j(j_),
1066         k(k_), l(l_), m(m_) {}
1067 
1068     template <typename TupleT>
1069     typename actor_result<self_t, TupleT>::type
1070     eval(TupleT const& args) const
1071     {
1072         typename actor_result<A, TupleT>::type ra = a.eval(args);
1073         typename actor_result<B, TupleT>::type rb = b.eval(args);
1074         typename actor_result<C, TupleT>::type rc = c.eval(args);
1075         typename actor_result<D, TupleT>::type rd = d.eval(args);
1076         typename actor_result<E, TupleT>::type re = e.eval(args);
1077         typename actor_result<F, TupleT>::type rf = f.eval(args);
1078         typename actor_result<G, TupleT>::type rg = g.eval(args);
1079         typename actor_result<H, TupleT>::type rh = h.eval(args);
1080         typename actor_result<I, TupleT>::type ri = i.eval(args);
1081         typename actor_result<J, TupleT>::type rj = j.eval(args);
1082         typename actor_result<K, TupleT>::type rk = k.eval(args);
1083         typename actor_result<L, TupleT>::type rl = l.eval(args);
1084         typename actor_result<M, TupleT>::type rm = m.eval(args);
1085         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm);
1086     }
1087 
1088     mutable OperationT op; //  operation
1089     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1090     K k; L l; M m; //  actors
1091 };
1092 
1093 ///////////////////////////////////////////////////////////////////////////////
1094 //
1095 //  composite <14 actors> class
1096 //
1097 ///////////////////////////////////////////////////////////////////////////////
1098 template <typename OperationT, typename TupleT,
1099     typename A, typename B, typename C, typename D, typename E,
1100     typename F, typename G, typename H, typename I, typename J,
1101     typename K, typename L, typename M, typename N>
1102 struct composite14_result {
1103 
1104     typedef typename OperationT::template result<
1105         typename actor_result<A, TupleT>::plain_type,
1106         typename actor_result<B, TupleT>::plain_type,
1107         typename actor_result<C, TupleT>::plain_type,
1108         typename actor_result<D, TupleT>::plain_type,
1109         typename actor_result<E, TupleT>::plain_type,
1110         typename actor_result<F, TupleT>::plain_type,
1111         typename actor_result<G, TupleT>::plain_type,
1112         typename actor_result<H, TupleT>::plain_type,
1113         typename actor_result<I, TupleT>::plain_type,
1114         typename actor_result<J, TupleT>::plain_type,
1115         typename actor_result<K, TupleT>::plain_type,
1116         typename actor_result<L, TupleT>::plain_type,
1117         typename actor_result<M, TupleT>::plain_type,
1118         typename actor_result<N, TupleT>::plain_type
1119     >::type type;
1120 };
1121 
1122 //////////////////////////////////
1123 template <typename OperationT,
1124     typename A, typename B, typename C, typename D, typename E,
1125     typename F, typename G, typename H, typename I, typename J,
1126     typename K, typename L, typename M, typename N>
1127 struct composite<OperationT,
1128     A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t
1129 > {
1130 
1131     typedef composite<OperationT,
1132         A, B, C, D, E, F, G, H, I, J, K, L, M, N> self_t;
1133 
1134     template <typename TupleT>
1135     struct result {
1136 
1137         typedef typename composite14_result<
1138             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
1139         >::type type;
1140     };
1141 
1142     composite(OperationT const& op_,
1143         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1144         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
1145         K const& k_, L const& l_, M const& m_, N const& n_)
1146     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1147         f(f_), g(g_), h(h_), i(i_), j(j_),
1148         k(k_), l(l_), m(m_), n(n_) {}
1149 
1150     template <typename TupleT>
1151     typename actor_result<self_t, TupleT>::type
1152     eval(TupleT const& args) const
1153     {
1154         typename actor_result<A, TupleT>::type ra = a.eval(args);
1155         typename actor_result<B, TupleT>::type rb = b.eval(args);
1156         typename actor_result<C, TupleT>::type rc = c.eval(args);
1157         typename actor_result<D, TupleT>::type rd = d.eval(args);
1158         typename actor_result<E, TupleT>::type re = e.eval(args);
1159         typename actor_result<F, TupleT>::type rf = f.eval(args);
1160         typename actor_result<G, TupleT>::type rg = g.eval(args);
1161         typename actor_result<H, TupleT>::type rh = h.eval(args);
1162         typename actor_result<I, TupleT>::type ri = i.eval(args);
1163         typename actor_result<J, TupleT>::type rj = j.eval(args);
1164         typename actor_result<K, TupleT>::type rk = k.eval(args);
1165         typename actor_result<L, TupleT>::type rl = l.eval(args);
1166         typename actor_result<M, TupleT>::type rm = m.eval(args);
1167         typename actor_result<N, TupleT>::type rn = n.eval(args);
1168         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn);
1169     }
1170 
1171     mutable OperationT op; //  operation
1172     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1173     K k; L l; M m; N n; //  actors
1174 };
1175 
1176 ///////////////////////////////////////////////////////////////////////////////
1177 //
1178 //  composite <15 actors> class
1179 //
1180 ///////////////////////////////////////////////////////////////////////////////
1181 template <typename OperationT, typename TupleT,
1182     typename A, typename B, typename C, typename D, typename E,
1183     typename F, typename G, typename H, typename I, typename J,
1184     typename K, typename L, typename M, typename N, typename O>
1185 struct composite15_result {
1186 
1187     typedef typename OperationT::template result<
1188         typename actor_result<A, TupleT>::plain_type,
1189         typename actor_result<B, TupleT>::plain_type,
1190         typename actor_result<C, TupleT>::plain_type,
1191         typename actor_result<D, TupleT>::plain_type,
1192         typename actor_result<E, TupleT>::plain_type,
1193         typename actor_result<F, TupleT>::plain_type,
1194         typename actor_result<G, TupleT>::plain_type,
1195         typename actor_result<H, TupleT>::plain_type,
1196         typename actor_result<I, TupleT>::plain_type,
1197         typename actor_result<J, TupleT>::plain_type,
1198         typename actor_result<K, TupleT>::plain_type,
1199         typename actor_result<L, TupleT>::plain_type,
1200         typename actor_result<M, TupleT>::plain_type,
1201         typename actor_result<N, TupleT>::plain_type,
1202         typename actor_result<O, TupleT>::plain_type
1203     >::type type;
1204 };
1205 
1206 //////////////////////////////////
1207 template <typename OperationT,
1208     typename A, typename B, typename C, typename D, typename E,
1209     typename F, typename G, typename H, typename I, typename J,
1210     typename K, typename L, typename M, typename N, typename O>
1211 struct composite<OperationT,
1212     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t
1213 > {
1214 
1215     typedef composite<OperationT,
1216         A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> self_t;
1217 
1218     template <typename TupleT>
1219     struct result {
1220 
1221         typedef typename composite15_result<
1222             OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
1223         >::type type;
1224     };
1225 
1226     composite(OperationT const& op_,
1227         A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1228         F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
1229         K const& k_, L const& l_, M const& m_, N const& n_, O const& o_)
1230     :   op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1231         f(f_), g(g_), h(h_), i(i_), j(j_),
1232         k(k_), l(l_), m(m_), n(n_), o(o_) {}
1233 
1234     template <typename TupleT>
1235     typename actor_result<self_t, TupleT>::type
1236     eval(TupleT const& args) const
1237     {
1238         typename actor_result<A, TupleT>::type ra = a.eval(args);
1239         typename actor_result<B, TupleT>::type rb = b.eval(args);
1240         typename actor_result<C, TupleT>::type rc = c.eval(args);
1241         typename actor_result<D, TupleT>::type rd = d.eval(args);
1242         typename actor_result<E, TupleT>::type re = e.eval(args);
1243         typename actor_result<F, TupleT>::type rf = f.eval(args);
1244         typename actor_result<G, TupleT>::type rg = g.eval(args);
1245         typename actor_result<H, TupleT>::type rh = h.eval(args);
1246         typename actor_result<I, TupleT>::type ri = i.eval(args);
1247         typename actor_result<J, TupleT>::type rj = j.eval(args);
1248         typename actor_result<K, TupleT>::type rk = k.eval(args);
1249         typename actor_result<L, TupleT>::type rl = l.eval(args);
1250         typename actor_result<M, TupleT>::type rm = m.eval(args);
1251         typename actor_result<N, TupleT>::type rn = n.eval(args);
1252         typename actor_result<O, TupleT>::type ro = o.eval(args);
1253         return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn, ro);
1254     }
1255 
1256     mutable OperationT op; //  operation
1257     A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1258     K k; L l; M m; N n; O o; //  actors
1259 };
1260 
1261 #endif
1262 #endif
1263 #endif
1264 #endif
1265 
1266 namespace impl {
1267 
1268     ///////////////////////////////////////////////////////////////////////////
1269     //
1270     //      make_composite is basically a type computer that answers the
1271     //      question "Given types T0..TN, what composite type should I
1272     //      create <composite_type> and if I were to generate an actual
1273     //      composite, what type <type> should I return?"
1274     //
1275     ///////////////////////////////////////////////////////////////////////////
1276     template <
1277         typename OperationT
1278         ,   typename A = nil_t
1279         ,   typename B = nil_t
1280         ,   typename C = nil_t
1281 
1282 #if PHOENIX_LIMIT > 3
1283         ,   typename D = nil_t
1284         ,   typename E = nil_t
1285         ,   typename F = nil_t
1286 
1287 #if PHOENIX_LIMIT > 6
1288         ,   typename G = nil_t
1289         ,   typename H = nil_t
1290         ,   typename I = nil_t
1291 
1292 #if PHOENIX_LIMIT > 9
1293         ,   typename J = nil_t
1294         ,   typename K = nil_t
1295         ,   typename L = nil_t
1296 
1297 #if PHOENIX_LIMIT > 12
1298         ,   typename M = nil_t
1299         ,   typename N = nil_t
1300         ,   typename O = nil_t
1301 
1302 #endif
1303 #endif
1304 #endif
1305 #endif
1306     >
1307     struct make_composite {
1308 
1309         typedef composite<OperationT
1310             ,   typename as_actor<A>::type
1311             ,   typename as_actor<B>::type
1312             ,   typename as_actor<C>::type
1313 
1314 #if PHOENIX_LIMIT > 3
1315             ,   typename as_actor<D>::type
1316             ,   typename as_actor<E>::type
1317             ,   typename as_actor<F>::type
1318 
1319 #if PHOENIX_LIMIT > 6
1320             ,   typename as_actor<G>::type
1321             ,   typename as_actor<H>::type
1322             ,   typename as_actor<I>::type
1323 
1324 #if PHOENIX_LIMIT > 9
1325             ,   typename as_actor<J>::type
1326             ,   typename as_actor<K>::type
1327             ,   typename as_actor<L>::type
1328 
1329 #if PHOENIX_LIMIT > 12
1330             ,   typename as_actor<M>::type
1331             ,   typename as_actor<N>::type
1332             ,   typename as_actor<O>::type
1333 
1334 #endif
1335 #endif
1336 #endif
1337 #endif
1338         > composite_type;
1339 
1340         typedef actor<composite_type> type;
1341     };
1342 
1343     ///////////////////////////////////////////////////////////////////////////
1344     //
1345     //      make_unary, make_binary, make_binary1, make_binary2 and
1346     //      make_binary3 utilities are provided here for easy creation of
1347     //      unary and binary composites.
1348     //
1349     ///////////////////////////////////////////////////////////////////////////
1350 
1351     //////////////////////////////////  input is an actor
1352     template <typename OperationT, typename BaseT>
1353     struct make_unary {
1354 
1355         typedef typename make_composite
1356             <OperationT, actor<BaseT> >::type type;
1357 
1358         static type
1359         construct(actor<BaseT> const& _0)
1360         {
1361             typedef typename make_composite
1362                     <OperationT, actor<BaseT> >::composite_type
1363                 ret_t;
1364 
1365             return ret_t(OperationT(), _0);
1366         }
1367     };
1368 
1369     //////////////////////////////////  LHS is an actor, RHS is unknown
1370     template <typename OperationT, typename BaseT, typename B>
1371     struct make_binary1 {
1372 
1373         typedef typename make_composite
1374             <OperationT, actor<BaseT>, B>::type type;
1375 
1376         static type
1377         construct(actor<BaseT> const& _0_, B const& _1_)
1378         {
1379             typedef typename make_composite
1380                     <OperationT, actor<BaseT>, B>::composite_type
1381                 ret_t;
1382             
1383             return ret_t(OperationT(), _0_, as_actor<B>::convert(_1_));
1384         }
1385     };
1386 
1387     //////////////////////////////////  LHS is unknown, RHS is an actor
1388     template <typename OperationT, typename A, typename BaseT>
1389     struct make_binary2 {
1390 
1391         typedef typename make_composite
1392             <OperationT, A, actor<BaseT> >::type type;
1393 
1394         static type
1395         construct(A const& _0_, actor<BaseT> const& _1_)
1396         {
1397             typedef typename make_composite
1398                     <OperationT, A, actor<BaseT> >::composite_type
1399                 ret_t;
1400 
1401             return ret_t(OperationT(), as_actor<A>::convert(_0_), _1_);
1402         }
1403     };
1404 
1405     //////////////////////////////////  Both LHS and RHS are actors
1406     template <typename OperationT, typename BaseA, typename BaseB>
1407     struct make_binary3 {
1408 
1409         typedef typename make_composite
1410             <OperationT, actor<BaseA>, actor<BaseB> >::type type;
1411 
1412         static type
1413         construct(actor<BaseA> const& _0_, actor<BaseB> const& _1_)
1414         {
1415             typedef typename make_composite
1416                     <OperationT, actor<BaseA>, actor<BaseB> >::composite_type
1417                 ret_t;
1418 
1419             return ret_t(OperationT(), _0_, _1_);
1420         }
1421     };
1422 
1423 }   // namespace impl
1424 
1425 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
1426 #pragma warning(pop)
1427 #endif
1428 
1429 }   //  namespace phoenix
1430 
1431 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!