1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/ossrv_pub/boost_apis/boost/spirit/phoenix/composite.hpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1423 @@
1.4 +/*=============================================================================
1.5 + Phoenix V1.2.1
1.6 + Copyright (c) 2001-2002 Joel de Guzman
1.7 +
1.8 + Use, modification and distribution is subject to the Boost Software
1.9 + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
1.10 + http://www.boost.org/LICENSE_1_0.txt)
1.11 +==============================================================================*/
1.12 +#ifndef PHOENIX_COMPOSITE_HPP
1.13 +#define PHOENIX_COMPOSITE_HPP
1.14 +
1.15 +///////////////////////////////////////////////////////////////////////////////
1.16 +#include <boost/spirit/phoenix/actor.hpp>
1.17 +
1.18 +///////////////////////////////////////////////////////////////////////////////
1.19 +namespace phoenix {
1.20 +
1.21 +///////////////////////////////////////////////////////////////////////////////
1.22 +//
1.23 +// composite class
1.24 +//
1.25 +// A composite is an actor base class composed of zero or more
1.26 +// actors (see actor.hpp) and an operation. A composite is itself
1.27 +// an actor superclass and conforms to its conceptual interface.
1.28 +// Its eval member function un-funnels the tupled actual arguments
1.29 +// from the tuple by invoking each of the actors' eval member
1.30 +// function. The results of each are then passed on as arguments to
1.31 +// the operation. Specializations are provided to handle different
1.32 +// numbers of actors.
1.33 +//
1.34 +// Schematically:
1.35 +//
1.36 +// actor0.eval(tupled_args) --> arg0 --> |
1.37 +// actor1.eval(tupled_args) --> arg1 --> |
1.38 +// actor2.eval(tupled_args) --> arg3 --> | --> operation(arg0...argN)
1.39 +// ... |
1.40 +// actorN.eval(tupled_args) --> argN --> |
1.41 +//
1.42 +// The operation can be any suitable functor that can accept the
1.43 +// arguments passed in by the composite. The operation is expected
1.44 +// to have a member operator() that carries out the actual
1.45 +// operation. There should be a one to one correspondence between
1.46 +// actors of the composite and the arguments of the operation's
1.47 +// member operator().
1.48 +//
1.49 +// The operation is also expected to have a nested template class
1.50 +// result<T0...TN>. The nested template class result should have a
1.51 +// typedef 'type' that reflects the return type of its member
1.52 +// operator(). This is essentially a type computer that answers the
1.53 +// metaprogramming question "Given arguments of type T0...TN, what
1.54 +// will be its operator()'s return type?".
1.55 +//
1.56 +// There is a special case for operations that accept no arguments.
1.57 +// Such nullary operations are only required to define a typedef
1.58 +// result_type that reflects the return type of its operator().
1.59 +//
1.60 +// Here's an example of a simple operation that squares a number:
1.61 +//
1.62 +// struct square {
1.63 +//
1.64 +// template <typename ArgT>
1.65 +// struct result { typedef ArgT type; };
1.66 +//
1.67 +// template <typename ArgT>
1.68 +// ArgT operator()(ArgT n) const { return n * n; }
1.69 +// };
1.70 +//
1.71 +// As can be seen, operations can be polymorphic. Its arguments and
1.72 +// return type are not fixed to a particular type. The example
1.73 +// above for example, can handle any ArgT type as long as it has a
1.74 +// multiplication operator.
1.75 +//
1.76 +// Composites are not created directly. Instead, there are meta-
1.77 +// programs provided that indirectly create composites. See
1.78 +// operators.hpp, binders.hpp and functions.hpp for examples.
1.79 +//
1.80 +///////////////////////////////////////////////////////////////////////////////
1.81 +template <
1.82 + typename OperationT
1.83 + , typename A = nil_t
1.84 + , typename B = nil_t
1.85 + , typename C = nil_t
1.86 +
1.87 +#if PHOENIX_LIMIT > 3
1.88 + , typename D = nil_t
1.89 + , typename E = nil_t
1.90 + , typename F = nil_t
1.91 +
1.92 +#if PHOENIX_LIMIT > 6
1.93 + , typename G = nil_t
1.94 + , typename H = nil_t
1.95 + , typename I = nil_t
1.96 +
1.97 +#if PHOENIX_LIMIT > 9
1.98 + , typename J = nil_t
1.99 + , typename K = nil_t
1.100 + , typename L = nil_t
1.101 +
1.102 +#if PHOENIX_LIMIT > 12
1.103 + , typename M = nil_t
1.104 + , typename N = nil_t
1.105 + , typename O = nil_t
1.106 +
1.107 +#endif
1.108 +#endif
1.109 +#endif
1.110 +#endif
1.111 +
1.112 + , typename NU = nil_t // Not used
1.113 +>
1.114 +struct composite;
1.115 +
1.116 +///////////////////////////////////////////////////////////////////////////////
1.117 +//
1.118 +// composite <0 actor> class
1.119 +//
1.120 +///////////////////////////////////////////////////////////////////////////////
1.121 +template <typename OperationT, typename TupleT>
1.122 +struct composite0_result {
1.123 +
1.124 + typedef typename OperationT::result_type type;
1.125 +};
1.126 +
1.127 +//////////////////////////////////
1.128 +template <typename OperationT>
1.129 +struct composite<OperationT,
1.130 + nil_t, nil_t, nil_t,
1.131 +#if PHOENIX_LIMIT > 3
1.132 + nil_t, nil_t, nil_t,
1.133 +#if PHOENIX_LIMIT > 6
1.134 + nil_t, nil_t, nil_t,
1.135 +#if PHOENIX_LIMIT > 9
1.136 + nil_t, nil_t, nil_t,
1.137 +#if PHOENIX_LIMIT > 12
1.138 + nil_t, nil_t, nil_t,
1.139 +#endif
1.140 +#endif
1.141 +#endif
1.142 +#endif
1.143 + nil_t // Unused
1.144 +> {
1.145 +
1.146 + typedef composite<OperationT> self_t;
1.147 +
1.148 + template <typename TupleT>
1.149 + struct result {
1.150 +
1.151 + typedef typename composite0_result<
1.152 + OperationT, TupleT
1.153 + >::type type;
1.154 + };
1.155 +
1.156 + composite(OperationT const& op_)
1.157 + : op(op_) {}
1.158 +
1.159 + template <typename TupleT>
1.160 + typename OperationT::result_type
1.161 + eval(TupleT const& /*args*/) const
1.162 + {
1.163 + return op();
1.164 + }
1.165 +
1.166 + mutable OperationT op; // operation
1.167 +};
1.168 +
1.169 +///////////////////////////////////////////////////////////////////////////////
1.170 +//
1.171 +// composite <1 actor> class
1.172 +//
1.173 +///////////////////////////////////////////////////////////////////////////////
1.174 +template <typename OperationT, typename TupleT,
1.175 + typename A>
1.176 +struct composite1_result {
1.177 +
1.178 + typedef typename OperationT::template result<
1.179 + typename actor_result<A, TupleT>::plain_type
1.180 + >::type type;
1.181 +};
1.182 +
1.183 +//////////////////////////////////
1.184 +template <typename OperationT,
1.185 + typename A>
1.186 +struct composite<OperationT,
1.187 + A, nil_t, nil_t,
1.188 +#if PHOENIX_LIMIT > 3
1.189 + nil_t, nil_t, nil_t,
1.190 +#if PHOENIX_LIMIT > 6
1.191 + nil_t, nil_t, nil_t,
1.192 +#if PHOENIX_LIMIT > 9
1.193 + nil_t, nil_t, nil_t,
1.194 +#if PHOENIX_LIMIT > 12
1.195 + nil_t, nil_t, nil_t,
1.196 +#endif
1.197 +#endif
1.198 +#endif
1.199 +#endif
1.200 + nil_t // Unused
1.201 +> {
1.202 +
1.203 + typedef composite<OperationT, A> self_t;
1.204 +
1.205 + template <typename TupleT>
1.206 + struct result {
1.207 +
1.208 + typedef typename composite1_result<
1.209 + OperationT, TupleT, A
1.210 + >::type type;
1.211 + };
1.212 +
1.213 + composite(OperationT const& op_,
1.214 + A const& a_)
1.215 + : op(op_), a(a_) {}
1.216 +
1.217 + template <typename TupleT>
1.218 + typename actor_result<self_t, TupleT>::type
1.219 + eval(TupleT const& args) const
1.220 + {
1.221 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.222 + return op(ra);
1.223 + }
1.224 +
1.225 + mutable OperationT op; // operation
1.226 + A a; // actors
1.227 +};
1.228 +
1.229 +///////////////////////////////////////////////////////////////////////////////
1.230 +//
1.231 +// composite <2 actors> class
1.232 +//
1.233 +///////////////////////////////////////////////////////////////////////////////
1.234 +template <typename OperationT, typename TupleT,
1.235 + typename A, typename B>
1.236 +struct composite2_result {
1.237 +
1.238 + typedef typename OperationT::template result<
1.239 + typename actor_result<A, TupleT>::plain_type,
1.240 + typename actor_result<B, TupleT>::plain_type
1.241 + >::type type;
1.242 +};
1.243 +
1.244 +//////////////////////////////////
1.245 +template <typename OperationT,
1.246 + typename A, typename B>
1.247 +struct composite<OperationT,
1.248 + A, B, nil_t,
1.249 +#if PHOENIX_LIMIT > 3
1.250 + nil_t, nil_t, nil_t,
1.251 +#if PHOENIX_LIMIT > 6
1.252 + nil_t, nil_t, nil_t,
1.253 +#if PHOENIX_LIMIT > 9
1.254 + nil_t, nil_t, nil_t,
1.255 +#if PHOENIX_LIMIT > 12
1.256 + nil_t, nil_t, nil_t,
1.257 +#endif
1.258 +#endif
1.259 +#endif
1.260 +#endif
1.261 + nil_t // Unused
1.262 +> {
1.263 +
1.264 + typedef composite<OperationT, A, B> self_t;
1.265 +
1.266 + template <typename TupleT>
1.267 + struct result {
1.268 +
1.269 + typedef typename composite2_result<
1.270 + OperationT, TupleT, A, B
1.271 + >::type type;
1.272 + };
1.273 +
1.274 + composite(OperationT const& op_,
1.275 + A const& a_, B const& b_)
1.276 + : op(op_), a(a_), b(b_) {}
1.277 +
1.278 + template <typename TupleT>
1.279 + typename actor_result<self_t, TupleT>::type
1.280 + eval(TupleT const& args) const
1.281 + {
1.282 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.283 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.284 + return op(ra, rb);
1.285 + }
1.286 +
1.287 + mutable OperationT op; // operation
1.288 + A a; B b; // actors
1.289 +};
1.290 +
1.291 +///////////////////////////////////////////////////////////////////////////////
1.292 +//
1.293 +// composite <3 actors> class
1.294 +//
1.295 +///////////////////////////////////////////////////////////////////////////////
1.296 +template <typename OperationT, typename TupleT,
1.297 + typename A, typename B, typename C>
1.298 +struct composite3_result {
1.299 +
1.300 + typedef typename OperationT::template result<
1.301 + typename actor_result<A, TupleT>::plain_type,
1.302 + typename actor_result<B, TupleT>::plain_type,
1.303 + typename actor_result<C, TupleT>::plain_type
1.304 + >::type type;
1.305 +};
1.306 +
1.307 +//////////////////////////////////
1.308 +template <typename OperationT,
1.309 + typename A, typename B, typename C>
1.310 +struct composite<OperationT,
1.311 + A, B, C,
1.312 +#if PHOENIX_LIMIT > 3
1.313 + nil_t, nil_t, nil_t,
1.314 +#if PHOENIX_LIMIT > 6
1.315 + nil_t, nil_t, nil_t,
1.316 +#if PHOENIX_LIMIT > 9
1.317 + nil_t, nil_t, nil_t,
1.318 +#if PHOENIX_LIMIT > 12
1.319 + nil_t, nil_t, nil_t,
1.320 +#endif
1.321 +#endif
1.322 +#endif
1.323 +#endif
1.324 + nil_t // Unused
1.325 +> {
1.326 +
1.327 + typedef composite<OperationT, A, B, C> self_t;
1.328 +
1.329 + template <typename TupleT>
1.330 + struct result {
1.331 +
1.332 + typedef typename composite3_result<
1.333 + OperationT, TupleT, A, B, C
1.334 + >::type type;
1.335 + };
1.336 +
1.337 + composite(OperationT const& op_,
1.338 + A const& a_, B const& b_, C const& c_)
1.339 + : op(op_), a(a_), b(b_), c(c_) {}
1.340 +
1.341 + template <typename TupleT>
1.342 + typename actor_result<self_t, TupleT>::type
1.343 + eval(TupleT const& args) const
1.344 + {
1.345 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.346 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.347 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.348 + return op(ra, rb, rc);
1.349 + }
1.350 +
1.351 + mutable OperationT op; // operation
1.352 + A a; B b; C c; // actors
1.353 +};
1.354 +
1.355 +#if PHOENIX_LIMIT > 3
1.356 +///////////////////////////////////////////////////////////////////////////////
1.357 +//
1.358 +// composite <4 actors> class
1.359 +//
1.360 +///////////////////////////////////////////////////////////////////////////////
1.361 +template <typename OperationT, typename TupleT,
1.362 + typename A, typename B, typename C, typename D>
1.363 +struct composite4_result {
1.364 +
1.365 + typedef typename OperationT::template result<
1.366 + typename actor_result<A, TupleT>::plain_type,
1.367 + typename actor_result<B, TupleT>::plain_type,
1.368 + typename actor_result<C, TupleT>::plain_type,
1.369 + typename actor_result<D, TupleT>::plain_type
1.370 + >::type type;
1.371 +};
1.372 +
1.373 +//////////////////////////////////
1.374 +template <typename OperationT,
1.375 + typename A, typename B, typename C, typename D>
1.376 +struct composite<OperationT,
1.377 + A, B, C, D, nil_t, nil_t,
1.378 +#if PHOENIX_LIMIT > 6
1.379 + nil_t, nil_t, nil_t,
1.380 +#if PHOENIX_LIMIT > 9
1.381 + nil_t, nil_t, nil_t,
1.382 +#if PHOENIX_LIMIT > 12
1.383 + nil_t, nil_t, nil_t,
1.384 +#endif
1.385 +#endif
1.386 +#endif
1.387 + nil_t // Unused
1.388 +> {
1.389 +
1.390 + typedef composite<OperationT, A, B, C, D> self_t;
1.391 +
1.392 + template <typename TupleT>
1.393 + struct result {
1.394 +
1.395 + typedef typename composite4_result<
1.396 + OperationT, TupleT, A, B, C, D
1.397 + >::type type;
1.398 + };
1.399 +
1.400 + composite(OperationT const& op_,
1.401 + A const& a_, B const& b_, C const& c_, D const& d_)
1.402 + : op(op_), a(a_), b(b_), c(c_), d(d_) {}
1.403 +
1.404 + template <typename TupleT>
1.405 + typename actor_result<self_t, TupleT>::type
1.406 + eval(TupleT const& args) const
1.407 + {
1.408 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.409 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.410 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.411 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.412 + return op(ra, rb, rc, rd);
1.413 + }
1.414 +
1.415 + mutable OperationT op; // operation
1.416 + A a; B b; C c; D d; // actors
1.417 +};
1.418 +
1.419 +///////////////////////////////////////////////////////////////////////////////
1.420 +//
1.421 +// composite <5 actors> class
1.422 +//
1.423 +///////////////////////////////////////////////////////////////////////////////
1.424 +template <typename OperationT, typename TupleT,
1.425 + typename A, typename B, typename C, typename D, typename E>
1.426 +struct composite5_result {
1.427 +
1.428 + typedef typename OperationT::template result<
1.429 + typename actor_result<A, TupleT>::plain_type,
1.430 + typename actor_result<B, TupleT>::plain_type,
1.431 + typename actor_result<C, TupleT>::plain_type,
1.432 + typename actor_result<D, TupleT>::plain_type,
1.433 + typename actor_result<E, TupleT>::plain_type
1.434 + >::type type;
1.435 +};
1.436 +
1.437 +//////////////////////////////////
1.438 +template <typename OperationT,
1.439 + typename A, typename B, typename C, typename D, typename E>
1.440 +struct composite<OperationT,
1.441 + A, B, C, D, E, nil_t,
1.442 +#if PHOENIX_LIMIT > 6
1.443 + nil_t, nil_t, nil_t,
1.444 +#if PHOENIX_LIMIT > 9
1.445 + nil_t, nil_t, nil_t,
1.446 +#if PHOENIX_LIMIT > 12
1.447 + nil_t, nil_t, nil_t,
1.448 +#endif
1.449 +#endif
1.450 +#endif
1.451 + nil_t // Unused
1.452 +> {
1.453 +
1.454 + typedef composite<OperationT, A, B, C, D, E> self_t;
1.455 +
1.456 + template <typename TupleT>
1.457 + struct result {
1.458 +
1.459 + typedef typename composite5_result<
1.460 + OperationT, TupleT, A, B, C, D, E
1.461 + >::type type;
1.462 + };
1.463 +
1.464 + composite(OperationT const& op_,
1.465 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_)
1.466 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_) {}
1.467 +
1.468 + template <typename TupleT>
1.469 + typename actor_result<self_t, TupleT>::type
1.470 + eval(TupleT const& args) const
1.471 + {
1.472 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.473 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.474 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.475 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.476 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.477 + return op(ra, rb, rc, rd, re);
1.478 + }
1.479 +
1.480 + mutable OperationT op; // operation
1.481 + A a; B b; C c; D d; E e; // actors
1.482 +};
1.483 +
1.484 +///////////////////////////////////////////////////////////////////////////////
1.485 +//
1.486 +// composite <6 actors> class
1.487 +//
1.488 +///////////////////////////////////////////////////////////////////////////////
1.489 +template <typename OperationT, typename TupleT,
1.490 + typename A, typename B, typename C, typename D, typename E,
1.491 + typename F>
1.492 +struct composite6_result {
1.493 +
1.494 + typedef typename OperationT::template result<
1.495 + typename actor_result<A, TupleT>::plain_type,
1.496 + typename actor_result<B, TupleT>::plain_type,
1.497 + typename actor_result<C, TupleT>::plain_type,
1.498 + typename actor_result<D, TupleT>::plain_type,
1.499 + typename actor_result<E, TupleT>::plain_type,
1.500 + typename actor_result<F, TupleT>::plain_type
1.501 + >::type type;
1.502 +};
1.503 +
1.504 +//////////////////////////////////
1.505 +template <typename OperationT,
1.506 + typename A, typename B, typename C, typename D, typename E,
1.507 + typename F>
1.508 +struct composite<OperationT,
1.509 + A, B, C, D, E, F,
1.510 +#if PHOENIX_LIMIT > 6
1.511 + nil_t, nil_t, nil_t,
1.512 +#if PHOENIX_LIMIT > 9
1.513 + nil_t, nil_t, nil_t,
1.514 +#if PHOENIX_LIMIT > 12
1.515 + nil_t, nil_t, nil_t,
1.516 +#endif
1.517 +#endif
1.518 +#endif
1.519 + nil_t // Unused
1.520 +> {
1.521 +
1.522 + typedef composite<OperationT, A, B, C, D, E, F> self_t;
1.523 +
1.524 + template <typename TupleT>
1.525 + struct result {
1.526 +
1.527 + typedef typename composite6_result<
1.528 + OperationT, TupleT, A, B, C, D, E, F
1.529 + >::type type;
1.530 + };
1.531 +
1.532 + composite(OperationT const& op_,
1.533 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.534 + F const& f_)
1.535 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.536 + f(f_) {}
1.537 +
1.538 + template <typename TupleT>
1.539 + typename actor_result<self_t, TupleT>::type
1.540 + eval(TupleT const& args) const
1.541 + {
1.542 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.543 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.544 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.545 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.546 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.547 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.548 + return op(ra, rb, rc, rd, re, rf);
1.549 + }
1.550 +
1.551 + mutable OperationT op; // operation
1.552 + A a; B b; C c; D d; E e; F f; // actors
1.553 +};
1.554 +
1.555 +#if PHOENIX_LIMIT > 6
1.556 +///////////////////////////////////////////////////////////////////////////////
1.557 +//
1.558 +// composite <7 actors> class
1.559 +//
1.560 +///////////////////////////////////////////////////////////////////////////////
1.561 +template <typename OperationT, typename TupleT,
1.562 + typename A, typename B, typename C, typename D, typename E,
1.563 + typename F, typename G>
1.564 +struct composite7_result {
1.565 +
1.566 + typedef typename OperationT::template result<
1.567 + typename actor_result<A, TupleT>::plain_type,
1.568 + typename actor_result<B, TupleT>::plain_type,
1.569 + typename actor_result<C, TupleT>::plain_type,
1.570 + typename actor_result<D, TupleT>::plain_type,
1.571 + typename actor_result<E, TupleT>::plain_type,
1.572 + typename actor_result<F, TupleT>::plain_type,
1.573 + typename actor_result<G, TupleT>::plain_type
1.574 + >::type type;
1.575 +};
1.576 +
1.577 +//////////////////////////////////
1.578 +template <typename OperationT,
1.579 + typename A, typename B, typename C, typename D, typename E,
1.580 + typename F, typename G>
1.581 +struct composite<OperationT,
1.582 + A, B, C, D, E, F, G, nil_t, nil_t,
1.583 +#if PHOENIX_LIMIT > 9
1.584 + nil_t, nil_t, nil_t,
1.585 +#if PHOENIX_LIMIT > 12
1.586 + nil_t, nil_t, nil_t,
1.587 +#endif
1.588 +#endif
1.589 + nil_t // Unused
1.590 +> {
1.591 +
1.592 + typedef composite<OperationT, A, B, C, D, E, F, G> self_t;
1.593 +
1.594 + template <typename TupleT>
1.595 + struct result {
1.596 +
1.597 + typedef typename composite7_result<
1.598 + OperationT, TupleT, A, B, C, D, E, F, G
1.599 + >::type type;
1.600 + };
1.601 +
1.602 + composite(OperationT const& op_,
1.603 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.604 + F const& f_, G const& g_)
1.605 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.606 + f(f_), g(g_) {}
1.607 +
1.608 + template <typename TupleT>
1.609 + typename actor_result<self_t, TupleT>::type
1.610 + eval(TupleT const& args) const
1.611 + {
1.612 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.613 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.614 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.615 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.616 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.617 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.618 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.619 + return op(ra, rb, rc, rd, re, rf, rg);
1.620 + }
1.621 +
1.622 + mutable OperationT op; // operation
1.623 + A a; B b; C c; D d; E e; F f; G g; // actors
1.624 +};
1.625 +
1.626 +///////////////////////////////////////////////////////////////////////////////
1.627 +//
1.628 +// composite <8 actors> class
1.629 +//
1.630 +///////////////////////////////////////////////////////////////////////////////
1.631 +template <typename OperationT, typename TupleT,
1.632 + typename A, typename B, typename C, typename D, typename E,
1.633 + typename F, typename G, typename H>
1.634 +struct composite8_result {
1.635 +
1.636 + typedef typename OperationT::template result<
1.637 + typename actor_result<A, TupleT>::plain_type,
1.638 + typename actor_result<B, TupleT>::plain_type,
1.639 + typename actor_result<C, TupleT>::plain_type,
1.640 + typename actor_result<D, TupleT>::plain_type,
1.641 + typename actor_result<E, TupleT>::plain_type,
1.642 + typename actor_result<F, TupleT>::plain_type,
1.643 + typename actor_result<G, TupleT>::plain_type,
1.644 + typename actor_result<H, TupleT>::plain_type
1.645 + >::type type;
1.646 +};
1.647 +
1.648 +//////////////////////////////////
1.649 +template <typename OperationT,
1.650 + typename A, typename B, typename C, typename D, typename E,
1.651 + typename F, typename G, typename H>
1.652 +struct composite<OperationT,
1.653 + A, B, C, D, E, F, G, H, nil_t,
1.654 +#if PHOENIX_LIMIT > 9
1.655 + nil_t, nil_t, nil_t,
1.656 +#if PHOENIX_LIMIT > 12
1.657 + nil_t, nil_t, nil_t,
1.658 +#endif
1.659 +#endif
1.660 + nil_t // Unused
1.661 +> {
1.662 +
1.663 + typedef composite<OperationT, A, B, C, D, E, F, G, H> self_t;
1.664 +
1.665 + template <typename TupleT>
1.666 + struct result {
1.667 +
1.668 + typedef typename composite8_result<
1.669 + OperationT, TupleT, A, B, C, D, E, F, G, H
1.670 + >::type type;
1.671 + };
1.672 +
1.673 + composite(OperationT const& op_,
1.674 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.675 + F const& f_, G const& g_, H const& h_)
1.676 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.677 + f(f_), g(g_), h(h_) {}
1.678 +
1.679 + template <typename TupleT>
1.680 + typename actor_result<self_t, TupleT>::type
1.681 + eval(TupleT const& args) const
1.682 + {
1.683 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.684 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.685 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.686 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.687 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.688 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.689 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.690 + typename actor_result<H, TupleT>::type rh = h.eval(args);
1.691 + return op(ra, rb, rc, rd, re, rf, rg, rh);
1.692 + }
1.693 +
1.694 + mutable OperationT op; // operation
1.695 + A a; B b; C c; D d; E e; F f; G g; H h; // actors
1.696 +};
1.697 +
1.698 +///////////////////////////////////////////////////////////////////////////////
1.699 +//
1.700 +// composite <9 actors> class
1.701 +//
1.702 +///////////////////////////////////////////////////////////////////////////////
1.703 +template <typename OperationT, typename TupleT,
1.704 + typename A, typename B, typename C, typename D, typename E,
1.705 + typename F, typename G, typename H, typename I>
1.706 +struct composite9_result {
1.707 +
1.708 + typedef typename OperationT::template result<
1.709 + typename actor_result<A, TupleT>::plain_type,
1.710 + typename actor_result<B, TupleT>::plain_type,
1.711 + typename actor_result<C, TupleT>::plain_type,
1.712 + typename actor_result<D, TupleT>::plain_type,
1.713 + typename actor_result<E, TupleT>::plain_type,
1.714 + typename actor_result<F, TupleT>::plain_type,
1.715 + typename actor_result<G, TupleT>::plain_type,
1.716 + typename actor_result<H, TupleT>::plain_type,
1.717 + typename actor_result<I, TupleT>::plain_type
1.718 + >::type type;
1.719 +};
1.720 +
1.721 +//////////////////////////////////
1.722 +template <typename OperationT,
1.723 + typename A, typename B, typename C, typename D, typename E,
1.724 + typename F, typename G, typename H, typename I>
1.725 +struct composite<OperationT,
1.726 + A, B, C, D, E, F, G, H, I,
1.727 +#if PHOENIX_LIMIT > 9
1.728 + nil_t, nil_t, nil_t,
1.729 +#if PHOENIX_LIMIT > 12
1.730 + nil_t, nil_t, nil_t,
1.731 +#endif
1.732 +#endif
1.733 + nil_t // Unused
1.734 +> {
1.735 +
1.736 + typedef composite<OperationT, A, B, C, D, E, F, G, H, I> self_t;
1.737 +
1.738 + template <typename TupleT>
1.739 + struct result {
1.740 +
1.741 + typedef typename composite9_result<
1.742 + OperationT, TupleT, A, B, C, D, E, F, G, H, I
1.743 + >::type type;
1.744 + };
1.745 +
1.746 + composite(OperationT const& op_,
1.747 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.748 + F const& f_, G const& g_, H const& h_, I const& i_)
1.749 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.750 + f(f_), g(g_), h(h_), i(i_) {}
1.751 +
1.752 + template <typename TupleT>
1.753 + typename actor_result<self_t, TupleT>::type
1.754 + eval(TupleT const& args) const
1.755 + {
1.756 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.757 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.758 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.759 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.760 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.761 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.762 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.763 + typename actor_result<H, TupleT>::type rh = h.eval(args);
1.764 + typename actor_result<I, TupleT>::type ri = i.eval(args);
1.765 + return op(ra, rb, rc, rd, re, rf, rg, rh, ri);
1.766 + }
1.767 +
1.768 + mutable OperationT op; // operation
1.769 + A a; B b; C c; D d; E e; F f; G g; H h; I i; // actors
1.770 +};
1.771 +
1.772 +#if PHOENIX_LIMIT > 9
1.773 +///////////////////////////////////////////////////////////////////////////////
1.774 +//
1.775 +// composite <10 actors> class
1.776 +//
1.777 +///////////////////////////////////////////////////////////////////////////////
1.778 +template <typename OperationT, typename TupleT,
1.779 + typename A, typename B, typename C, typename D, typename E,
1.780 + typename F, typename G, typename H, typename I, typename J>
1.781 +struct composite10_result {
1.782 +
1.783 + typedef typename OperationT::template result<
1.784 + typename actor_result<A, TupleT>::plain_type,
1.785 + typename actor_result<B, TupleT>::plain_type,
1.786 + typename actor_result<C, TupleT>::plain_type,
1.787 + typename actor_result<D, TupleT>::plain_type,
1.788 + typename actor_result<E, TupleT>::plain_type,
1.789 + typename actor_result<F, TupleT>::plain_type,
1.790 + typename actor_result<G, TupleT>::plain_type,
1.791 + typename actor_result<H, TupleT>::plain_type,
1.792 + typename actor_result<I, TupleT>::plain_type,
1.793 + typename actor_result<J, TupleT>::plain_type
1.794 + >::type type;
1.795 +};
1.796 +
1.797 +//////////////////////////////////
1.798 +template <typename OperationT,
1.799 + typename A, typename B, typename C, typename D, typename E,
1.800 + typename F, typename G, typename H, typename I, typename J>
1.801 +struct composite<OperationT,
1.802 + A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
1.803 +#if PHOENIX_LIMIT > 12
1.804 + nil_t, nil_t, nil_t,
1.805 +#endif
1.806 + nil_t // Unused
1.807 +> {
1.808 +
1.809 + typedef composite<OperationT, A, B, C, D, E, F, G, H, I, J> self_t;
1.810 +
1.811 + template <typename TupleT>
1.812 + struct result {
1.813 +
1.814 + typedef typename composite10_result<
1.815 + OperationT, TupleT, A, B, C, D, E, F, G, H, I, J
1.816 + >::type type;
1.817 + };
1.818 +
1.819 + composite(OperationT const& op_,
1.820 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.821 + F const& f_, G const& g_, H const& h_, I const& i_, J const& j_)
1.822 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.823 + f(f_), g(g_), h(h_), i(i_), j(j_) {}
1.824 +
1.825 + template <typename TupleT>
1.826 + typename actor_result<self_t, TupleT>::type
1.827 + eval(TupleT const& args) const
1.828 + {
1.829 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.830 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.831 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.832 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.833 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.834 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.835 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.836 + typename actor_result<H, TupleT>::type rh = h.eval(args);
1.837 + typename actor_result<I, TupleT>::type ri = i.eval(args);
1.838 + typename actor_result<J, TupleT>::type rj = j.eval(args);
1.839 + return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj);
1.840 + }
1.841 +
1.842 + mutable OperationT op; // operation
1.843 + A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; // actors
1.844 +};
1.845 +
1.846 +///////////////////////////////////////////////////////////////////////////////
1.847 +//
1.848 +// composite <11 actors> class
1.849 +//
1.850 +///////////////////////////////////////////////////////////////////////////////
1.851 +template <typename OperationT, typename TupleT,
1.852 + typename A, typename B, typename C, typename D, typename E,
1.853 + typename F, typename G, typename H, typename I, typename J,
1.854 + typename K>
1.855 +struct composite11_result {
1.856 +
1.857 + typedef typename OperationT::template result<
1.858 + typename actor_result<A, TupleT>::plain_type,
1.859 + typename actor_result<B, TupleT>::plain_type,
1.860 + typename actor_result<C, TupleT>::plain_type,
1.861 + typename actor_result<D, TupleT>::plain_type,
1.862 + typename actor_result<E, TupleT>::plain_type,
1.863 + typename actor_result<F, TupleT>::plain_type,
1.864 + typename actor_result<G, TupleT>::plain_type,
1.865 + typename actor_result<H, TupleT>::plain_type,
1.866 + typename actor_result<I, TupleT>::plain_type,
1.867 + typename actor_result<J, TupleT>::plain_type,
1.868 + typename actor_result<K, TupleT>::plain_type
1.869 + >::type type;
1.870 +};
1.871 +
1.872 +//////////////////////////////////
1.873 +template <typename OperationT,
1.874 + typename A, typename B, typename C, typename D, typename E,
1.875 + typename F, typename G, typename H, typename I, typename J,
1.876 + typename K>
1.877 +struct composite<OperationT,
1.878 + A, B, C, D, E, F, G, H, I, J, K, nil_t,
1.879 +#if PHOENIX_LIMIT > 12
1.880 + nil_t, nil_t, nil_t,
1.881 +#endif
1.882 + nil_t // Unused
1.883 +> {
1.884 +
1.885 + typedef composite<OperationT,
1.886 + A, B, C, D, E, F, G, H, I, J, K> self_t;
1.887 +
1.888 + template <typename TupleT>
1.889 + struct result {
1.890 +
1.891 + typedef typename composite11_result<
1.892 + OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K
1.893 + >::type type;
1.894 + };
1.895 +
1.896 + composite(OperationT const& op_,
1.897 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.898 + F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
1.899 + K const& k_)
1.900 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.901 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.902 + k(k_) {}
1.903 +
1.904 + template <typename TupleT>
1.905 + typename actor_result<self_t, TupleT>::type
1.906 + eval(TupleT const& args) const
1.907 + {
1.908 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.909 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.910 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.911 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.912 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.913 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.914 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.915 + typename actor_result<H, TupleT>::type rh = h.eval(args);
1.916 + typename actor_result<I, TupleT>::type ri = i.eval(args);
1.917 + typename actor_result<J, TupleT>::type rj = j.eval(args);
1.918 + typename actor_result<K, TupleT>::type rk = k.eval(args);
1.919 + return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk);
1.920 + }
1.921 +
1.922 + mutable OperationT op; // operation
1.923 + A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1.924 + K k;// actors
1.925 +};
1.926 +
1.927 +///////////////////////////////////////////////////////////////////////////////
1.928 +//
1.929 +// composite <12 actors> class
1.930 +//
1.931 +///////////////////////////////////////////////////////////////////////////////
1.932 +template <typename OperationT, typename TupleT,
1.933 + typename A, typename B, typename C, typename D, typename E,
1.934 + typename F, typename G, typename H, typename I, typename J,
1.935 + typename K, typename L>
1.936 +struct composite12_result {
1.937 +
1.938 + typedef typename OperationT::template result<
1.939 + typename actor_result<A, TupleT>::plain_type,
1.940 + typename actor_result<B, TupleT>::plain_type,
1.941 + typename actor_result<C, TupleT>::plain_type,
1.942 + typename actor_result<D, TupleT>::plain_type,
1.943 + typename actor_result<E, TupleT>::plain_type,
1.944 + typename actor_result<F, TupleT>::plain_type,
1.945 + typename actor_result<G, TupleT>::plain_type,
1.946 + typename actor_result<H, TupleT>::plain_type,
1.947 + typename actor_result<I, TupleT>::plain_type,
1.948 + typename actor_result<J, TupleT>::plain_type,
1.949 + typename actor_result<K, TupleT>::plain_type,
1.950 + typename actor_result<L, TupleT>::plain_type
1.951 + >::type type;
1.952 +};
1.953 +
1.954 +//////////////////////////////////
1.955 +template <typename OperationT,
1.956 + typename A, typename B, typename C, typename D, typename E,
1.957 + typename F, typename G, typename H, typename I, typename J,
1.958 + typename K, typename L>
1.959 +struct composite<OperationT,
1.960 + A, B, C, D, E, F, G, H, I, J, K, L,
1.961 +#if PHOENIX_LIMIT > 12
1.962 + nil_t, nil_t, nil_t,
1.963 +#endif
1.964 + nil_t // Unused
1.965 +> {
1.966 +
1.967 + typedef composite<OperationT,
1.968 + A, B, C, D, E, F, G, H, I, J, K, L> self_t;
1.969 +
1.970 + template <typename TupleT>
1.971 + struct result {
1.972 +
1.973 + typedef typename composite12_result<
1.974 + OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L
1.975 + >::type type;
1.976 + };
1.977 +
1.978 + composite(OperationT const& op_,
1.979 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.980 + F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
1.981 + K const& k_, L const& l_)
1.982 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.983 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.984 + k(k_), l(l_) {}
1.985 +
1.986 + template <typename TupleT>
1.987 + typename actor_result<self_t, TupleT>::type
1.988 + eval(TupleT const& args) const
1.989 + {
1.990 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.991 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.992 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.993 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.994 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.995 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.996 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.997 + typename actor_result<H, TupleT>::type rh = h.eval(args);
1.998 + typename actor_result<I, TupleT>::type ri = i.eval(args);
1.999 + typename actor_result<J, TupleT>::type rj = j.eval(args);
1.1000 + typename actor_result<K, TupleT>::type rk = k.eval(args);
1.1001 + typename actor_result<L, TupleT>::type rl = l.eval(args);
1.1002 + return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl);
1.1003 + }
1.1004 +
1.1005 + mutable OperationT op; // operation
1.1006 + A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1.1007 + K k; L l;// actors
1.1008 +};
1.1009 +
1.1010 +#if PHOENIX_LIMIT > 12
1.1011 +///////////////////////////////////////////////////////////////////////////////
1.1012 +//
1.1013 +// composite <13 actors> class
1.1014 +//
1.1015 +///////////////////////////////////////////////////////////////////////////////
1.1016 +template <typename OperationT, typename TupleT,
1.1017 + typename A, typename B, typename C, typename D, typename E,
1.1018 + typename F, typename G, typename H, typename I, typename J,
1.1019 + typename K, typename L, typename M>
1.1020 +struct composite13_result {
1.1021 +
1.1022 + typedef typename OperationT::template result<
1.1023 + typename actor_result<A, TupleT>::plain_type,
1.1024 + typename actor_result<B, TupleT>::plain_type,
1.1025 + typename actor_result<C, TupleT>::plain_type,
1.1026 + typename actor_result<D, TupleT>::plain_type,
1.1027 + typename actor_result<E, TupleT>::plain_type,
1.1028 + typename actor_result<F, TupleT>::plain_type,
1.1029 + typename actor_result<G, TupleT>::plain_type,
1.1030 + typename actor_result<H, TupleT>::plain_type,
1.1031 + typename actor_result<I, TupleT>::plain_type,
1.1032 + typename actor_result<J, TupleT>::plain_type,
1.1033 + typename actor_result<K, TupleT>::plain_type,
1.1034 + typename actor_result<L, TupleT>::plain_type,
1.1035 + typename actor_result<M, TupleT>::plain_type
1.1036 + >::type type;
1.1037 +};
1.1038 +
1.1039 +//////////////////////////////////
1.1040 +template <typename OperationT,
1.1041 + typename A, typename B, typename C, typename D, typename E,
1.1042 + typename F, typename G, typename H, typename I, typename J,
1.1043 + typename K, typename L, typename M>
1.1044 +struct composite<OperationT,
1.1045 + A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t
1.1046 +> {
1.1047 +
1.1048 + typedef composite<OperationT,
1.1049 + A, B, C, D, E, F, G, H, I, J, K, L, M> self_t;
1.1050 +
1.1051 + template <typename TupleT>
1.1052 + struct result {
1.1053 +
1.1054 + typedef typename composite13_result<
1.1055 + OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M
1.1056 + >::type type;
1.1057 + };
1.1058 +
1.1059 + composite(OperationT const& op_,
1.1060 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.1061 + F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
1.1062 + K const& k_, L const& l_, M const& m_)
1.1063 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.1064 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.1065 + k(k_), l(l_), m(m_) {}
1.1066 +
1.1067 + template <typename TupleT>
1.1068 + typename actor_result<self_t, TupleT>::type
1.1069 + eval(TupleT const& args) const
1.1070 + {
1.1071 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.1072 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.1073 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.1074 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.1075 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.1076 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.1077 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.1078 + typename actor_result<H, TupleT>::type rh = h.eval(args);
1.1079 + typename actor_result<I, TupleT>::type ri = i.eval(args);
1.1080 + typename actor_result<J, TupleT>::type rj = j.eval(args);
1.1081 + typename actor_result<K, TupleT>::type rk = k.eval(args);
1.1082 + typename actor_result<L, TupleT>::type rl = l.eval(args);
1.1083 + typename actor_result<M, TupleT>::type rm = m.eval(args);
1.1084 + return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm);
1.1085 + }
1.1086 +
1.1087 + mutable OperationT op; // operation
1.1088 + A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1.1089 + K k; L l; M m; // actors
1.1090 +};
1.1091 +
1.1092 +///////////////////////////////////////////////////////////////////////////////
1.1093 +//
1.1094 +// composite <14 actors> class
1.1095 +//
1.1096 +///////////////////////////////////////////////////////////////////////////////
1.1097 +template <typename OperationT, typename TupleT,
1.1098 + typename A, typename B, typename C, typename D, typename E,
1.1099 + typename F, typename G, typename H, typename I, typename J,
1.1100 + typename K, typename L, typename M, typename N>
1.1101 +struct composite14_result {
1.1102 +
1.1103 + typedef typename OperationT::template result<
1.1104 + typename actor_result<A, TupleT>::plain_type,
1.1105 + typename actor_result<B, TupleT>::plain_type,
1.1106 + typename actor_result<C, TupleT>::plain_type,
1.1107 + typename actor_result<D, TupleT>::plain_type,
1.1108 + typename actor_result<E, TupleT>::plain_type,
1.1109 + typename actor_result<F, TupleT>::plain_type,
1.1110 + typename actor_result<G, TupleT>::plain_type,
1.1111 + typename actor_result<H, TupleT>::plain_type,
1.1112 + typename actor_result<I, TupleT>::plain_type,
1.1113 + typename actor_result<J, TupleT>::plain_type,
1.1114 + typename actor_result<K, TupleT>::plain_type,
1.1115 + typename actor_result<L, TupleT>::plain_type,
1.1116 + typename actor_result<M, TupleT>::plain_type,
1.1117 + typename actor_result<N, TupleT>::plain_type
1.1118 + >::type type;
1.1119 +};
1.1120 +
1.1121 +//////////////////////////////////
1.1122 +template <typename OperationT,
1.1123 + typename A, typename B, typename C, typename D, typename E,
1.1124 + typename F, typename G, typename H, typename I, typename J,
1.1125 + typename K, typename L, typename M, typename N>
1.1126 +struct composite<OperationT,
1.1127 + A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t
1.1128 +> {
1.1129 +
1.1130 + typedef composite<OperationT,
1.1131 + A, B, C, D, E, F, G, H, I, J, K, L, M, N> self_t;
1.1132 +
1.1133 + template <typename TupleT>
1.1134 + struct result {
1.1135 +
1.1136 + typedef typename composite14_result<
1.1137 + OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
1.1138 + >::type type;
1.1139 + };
1.1140 +
1.1141 + composite(OperationT const& op_,
1.1142 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.1143 + F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
1.1144 + K const& k_, L const& l_, M const& m_, N const& n_)
1.1145 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.1146 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.1147 + k(k_), l(l_), m(m_), n(n_) {}
1.1148 +
1.1149 + template <typename TupleT>
1.1150 + typename actor_result<self_t, TupleT>::type
1.1151 + eval(TupleT const& args) const
1.1152 + {
1.1153 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.1154 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.1155 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.1156 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.1157 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.1158 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.1159 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.1160 + typename actor_result<H, TupleT>::type rh = h.eval(args);
1.1161 + typename actor_result<I, TupleT>::type ri = i.eval(args);
1.1162 + typename actor_result<J, TupleT>::type rj = j.eval(args);
1.1163 + typename actor_result<K, TupleT>::type rk = k.eval(args);
1.1164 + typename actor_result<L, TupleT>::type rl = l.eval(args);
1.1165 + typename actor_result<M, TupleT>::type rm = m.eval(args);
1.1166 + typename actor_result<N, TupleT>::type rn = n.eval(args);
1.1167 + return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn);
1.1168 + }
1.1169 +
1.1170 + mutable OperationT op; // operation
1.1171 + A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1.1172 + K k; L l; M m; N n; // actors
1.1173 +};
1.1174 +
1.1175 +///////////////////////////////////////////////////////////////////////////////
1.1176 +//
1.1177 +// composite <15 actors> class
1.1178 +//
1.1179 +///////////////////////////////////////////////////////////////////////////////
1.1180 +template <typename OperationT, typename TupleT,
1.1181 + typename A, typename B, typename C, typename D, typename E,
1.1182 + typename F, typename G, typename H, typename I, typename J,
1.1183 + typename K, typename L, typename M, typename N, typename O>
1.1184 +struct composite15_result {
1.1185 +
1.1186 + typedef typename OperationT::template result<
1.1187 + typename actor_result<A, TupleT>::plain_type,
1.1188 + typename actor_result<B, TupleT>::plain_type,
1.1189 + typename actor_result<C, TupleT>::plain_type,
1.1190 + typename actor_result<D, TupleT>::plain_type,
1.1191 + typename actor_result<E, TupleT>::plain_type,
1.1192 + typename actor_result<F, TupleT>::plain_type,
1.1193 + typename actor_result<G, TupleT>::plain_type,
1.1194 + typename actor_result<H, TupleT>::plain_type,
1.1195 + typename actor_result<I, TupleT>::plain_type,
1.1196 + typename actor_result<J, TupleT>::plain_type,
1.1197 + typename actor_result<K, TupleT>::plain_type,
1.1198 + typename actor_result<L, TupleT>::plain_type,
1.1199 + typename actor_result<M, TupleT>::plain_type,
1.1200 + typename actor_result<N, TupleT>::plain_type,
1.1201 + typename actor_result<O, TupleT>::plain_type
1.1202 + >::type type;
1.1203 +};
1.1204 +
1.1205 +//////////////////////////////////
1.1206 +template <typename OperationT,
1.1207 + typename A, typename B, typename C, typename D, typename E,
1.1208 + typename F, typename G, typename H, typename I, typename J,
1.1209 + typename K, typename L, typename M, typename N, typename O>
1.1210 +struct composite<OperationT,
1.1211 + A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t
1.1212 +> {
1.1213 +
1.1214 + typedef composite<OperationT,
1.1215 + A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> self_t;
1.1216 +
1.1217 + template <typename TupleT>
1.1218 + struct result {
1.1219 +
1.1220 + typedef typename composite15_result<
1.1221 + OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
1.1222 + >::type type;
1.1223 + };
1.1224 +
1.1225 + composite(OperationT const& op_,
1.1226 + A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
1.1227 + F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
1.1228 + K const& k_, L const& l_, M const& m_, N const& n_, O const& o_)
1.1229 + : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
1.1230 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.1231 + k(k_), l(l_), m(m_), n(n_), o(o_) {}
1.1232 +
1.1233 + template <typename TupleT>
1.1234 + typename actor_result<self_t, TupleT>::type
1.1235 + eval(TupleT const& args) const
1.1236 + {
1.1237 + typename actor_result<A, TupleT>::type ra = a.eval(args);
1.1238 + typename actor_result<B, TupleT>::type rb = b.eval(args);
1.1239 + typename actor_result<C, TupleT>::type rc = c.eval(args);
1.1240 + typename actor_result<D, TupleT>::type rd = d.eval(args);
1.1241 + typename actor_result<E, TupleT>::type re = e.eval(args);
1.1242 + typename actor_result<F, TupleT>::type rf = f.eval(args);
1.1243 + typename actor_result<G, TupleT>::type rg = g.eval(args);
1.1244 + typename actor_result<H, TupleT>::type rh = h.eval(args);
1.1245 + typename actor_result<I, TupleT>::type ri = i.eval(args);
1.1246 + typename actor_result<J, TupleT>::type rj = j.eval(args);
1.1247 + typename actor_result<K, TupleT>::type rk = k.eval(args);
1.1248 + typename actor_result<L, TupleT>::type rl = l.eval(args);
1.1249 + typename actor_result<M, TupleT>::type rm = m.eval(args);
1.1250 + typename actor_result<N, TupleT>::type rn = n.eval(args);
1.1251 + typename actor_result<O, TupleT>::type ro = o.eval(args);
1.1252 + return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn, ro);
1.1253 + }
1.1254 +
1.1255 + mutable OperationT op; // operation
1.1256 + A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
1.1257 + K k; L l; M m; N n; O o; // actors
1.1258 +};
1.1259 +
1.1260 +#endif
1.1261 +#endif
1.1262 +#endif
1.1263 +#endif
1.1264 +
1.1265 +namespace impl {
1.1266 +
1.1267 + ///////////////////////////////////////////////////////////////////////////
1.1268 + //
1.1269 + // make_composite is basically a type computer that answers the
1.1270 + // question "Given types T0..TN, what composite type should I
1.1271 + // create <composite_type> and if I were to generate an actual
1.1272 + // composite, what type <type> should I return?"
1.1273 + //
1.1274 + ///////////////////////////////////////////////////////////////////////////
1.1275 + template <
1.1276 + typename OperationT
1.1277 + , typename A = nil_t
1.1278 + , typename B = nil_t
1.1279 + , typename C = nil_t
1.1280 +
1.1281 +#if PHOENIX_LIMIT > 3
1.1282 + , typename D = nil_t
1.1283 + , typename E = nil_t
1.1284 + , typename F = nil_t
1.1285 +
1.1286 +#if PHOENIX_LIMIT > 6
1.1287 + , typename G = nil_t
1.1288 + , typename H = nil_t
1.1289 + , typename I = nil_t
1.1290 +
1.1291 +#if PHOENIX_LIMIT > 9
1.1292 + , typename J = nil_t
1.1293 + , typename K = nil_t
1.1294 + , typename L = nil_t
1.1295 +
1.1296 +#if PHOENIX_LIMIT > 12
1.1297 + , typename M = nil_t
1.1298 + , typename N = nil_t
1.1299 + , typename O = nil_t
1.1300 +
1.1301 +#endif
1.1302 +#endif
1.1303 +#endif
1.1304 +#endif
1.1305 + >
1.1306 + struct make_composite {
1.1307 +
1.1308 + typedef composite<OperationT
1.1309 + , typename as_actor<A>::type
1.1310 + , typename as_actor<B>::type
1.1311 + , typename as_actor<C>::type
1.1312 +
1.1313 +#if PHOENIX_LIMIT > 3
1.1314 + , typename as_actor<D>::type
1.1315 + , typename as_actor<E>::type
1.1316 + , typename as_actor<F>::type
1.1317 +
1.1318 +#if PHOENIX_LIMIT > 6
1.1319 + , typename as_actor<G>::type
1.1320 + , typename as_actor<H>::type
1.1321 + , typename as_actor<I>::type
1.1322 +
1.1323 +#if PHOENIX_LIMIT > 9
1.1324 + , typename as_actor<J>::type
1.1325 + , typename as_actor<K>::type
1.1326 + , typename as_actor<L>::type
1.1327 +
1.1328 +#if PHOENIX_LIMIT > 12
1.1329 + , typename as_actor<M>::type
1.1330 + , typename as_actor<N>::type
1.1331 + , typename as_actor<O>::type
1.1332 +
1.1333 +#endif
1.1334 +#endif
1.1335 +#endif
1.1336 +#endif
1.1337 + > composite_type;
1.1338 +
1.1339 + typedef actor<composite_type> type;
1.1340 + };
1.1341 +
1.1342 + ///////////////////////////////////////////////////////////////////////////
1.1343 + //
1.1344 + // make_unary, make_binary, make_binary1, make_binary2 and
1.1345 + // make_binary3 utilities are provided here for easy creation of
1.1346 + // unary and binary composites.
1.1347 + //
1.1348 + ///////////////////////////////////////////////////////////////////////////
1.1349 +
1.1350 + ////////////////////////////////// input is an actor
1.1351 + template <typename OperationT, typename BaseT>
1.1352 + struct make_unary {
1.1353 +
1.1354 + typedef typename make_composite
1.1355 + <OperationT, actor<BaseT> >::type type;
1.1356 +
1.1357 + static type
1.1358 + construct(actor<BaseT> const& _0)
1.1359 + {
1.1360 + typedef typename make_composite
1.1361 + <OperationT, actor<BaseT> >::composite_type
1.1362 + ret_t;
1.1363 +
1.1364 + return ret_t(OperationT(), _0);
1.1365 + }
1.1366 + };
1.1367 +
1.1368 + ////////////////////////////////// LHS is an actor, RHS is unknown
1.1369 + template <typename OperationT, typename BaseT, typename B>
1.1370 + struct make_binary1 {
1.1371 +
1.1372 + typedef typename make_composite
1.1373 + <OperationT, actor<BaseT>, B>::type type;
1.1374 +
1.1375 + static type
1.1376 + construct(actor<BaseT> const& _0, B const& _1)
1.1377 + {
1.1378 + typedef typename make_composite
1.1379 + <OperationT, actor<BaseT>, B>::composite_type
1.1380 + ret_t;
1.1381 +
1.1382 + return ret_t(OperationT(), _0, as_actor<B>::convert(_1));
1.1383 + }
1.1384 + };
1.1385 +
1.1386 + ////////////////////////////////// LHS is unknown, RHS is an actor
1.1387 + template <typename OperationT, typename A, typename BaseT>
1.1388 + struct make_binary2 {
1.1389 +
1.1390 + typedef typename make_composite
1.1391 + <OperationT, A, actor<BaseT> >::type type;
1.1392 +
1.1393 + static type
1.1394 + construct(A const& _0, actor<BaseT> const& _1)
1.1395 + {
1.1396 + typedef typename make_composite
1.1397 + <OperationT, A, actor<BaseT> >::composite_type
1.1398 + ret_t;
1.1399 +
1.1400 + return ret_t(OperationT(), as_actor<A>::convert(_0), _1);
1.1401 + }
1.1402 + };
1.1403 +
1.1404 + ////////////////////////////////// Both LHS and RHS are actors
1.1405 + template <typename OperationT, typename BaseA, typename BaseB>
1.1406 + struct make_binary3 {
1.1407 +
1.1408 + typedef typename make_composite
1.1409 + <OperationT, actor<BaseA>, actor<BaseB> >::type type;
1.1410 +
1.1411 + static type
1.1412 + construct(actor<BaseA> const& _0, actor<BaseB> const& _1)
1.1413 + {
1.1414 + typedef typename make_composite
1.1415 + <OperationT, actor<BaseA>, actor<BaseB> >::composite_type
1.1416 + ret_t;
1.1417 +
1.1418 + return ret_t(OperationT(), _0, _1);
1.1419 + }
1.1420 + };
1.1421 +
1.1422 +} // namespace impl
1.1423 +
1.1424 +} // namespace phoenix
1.1425 +
1.1426 +#endif