Mercurial > hg > vamp-build-and-test

annotate DEPENDENCIES/generic/include/boost/spirit/home/classic/phoenix/composite.hpp @ 133:4acb5d8d80b6 tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Don't fail environmental check if README.md exists (but .txt and no-suffix don't)
author Chris Cannam
date Tue, 30 Jul 2019 12:25:44 +0100
parents 2665513ce2d3
children
rev   line source
Chris@16 1 /*=============================================================================
Chris@16 2 Phoenix V1.2.1
Chris@16 3 Copyright (c) 2001-2002 Joel de Guzman
Chris@16 4
Chris@16 5 Distributed under the Boost Software License, Version 1.0. (See accompanying
Chris@16 6 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16 7 ==============================================================================*/
Chris@16 8 #ifndef PHOENIX_COMPOSITE_HPP
Chris@16 9 #define PHOENIX_COMPOSITE_HPP
Chris@16 10
Chris@16 11 ///////////////////////////////////////////////////////////////////////////////
Chris@16 12 #include <boost/spirit/home/classic/phoenix/actor.hpp>
Chris@16 13
Chris@16 14 ///////////////////////////////////////////////////////////////////////////////
Chris@16 15 namespace phoenix {
Chris@16 16
Chris@16 17 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
Chris@16 18 #pragma warning(push)
Chris@16 19 #pragma warning(disable:4512) //assignment operator could not be generated
Chris@16 20 #endif
Chris@16 21
Chris@16 22 ///////////////////////////////////////////////////////////////////////////////
Chris@16 23 //
Chris@16 24 // composite class
Chris@16 25 //
Chris@16 26 // A composite is an actor base class composed of zero or more
Chris@16 27 // actors (see actor.hpp) and an operation. A composite is itself
Chris@16 28 // an actor superclass and conforms to its conceptual interface.
Chris@16 29 // Its eval member function un-funnels the tupled actual arguments
Chris@16 30 // from the tuple by invoking each of the actors' eval member
Chris@16 31 // function. The results of each are then passed on as arguments to
Chris@16 32 // the operation. Specializations are provided to handle different
Chris@16 33 // numbers of actors.
Chris@16 34 //
Chris@16 35 // Schematically:
Chris@16 36 //
Chris@16 37 // actor0.eval(tupled_args) --> arg0 --> |
Chris@16 38 // actor1.eval(tupled_args) --> arg1 --> |
Chris@16 39 // actor2.eval(tupled_args) --> arg3 --> | --> operation(arg0...argN)
Chris@16 40 // ... |
Chris@16 41 // actorN.eval(tupled_args) --> argN --> |
Chris@16 42 //
Chris@16 43 // The operation can be any suitable functor that can accept the
Chris@16 44 // arguments passed in by the composite. The operation is expected
Chris@16 45 // to have a member operator() that carries out the actual
Chris@16 46 // operation. There should be a one to one correspondence between
Chris@16 47 // actors of the composite and the arguments of the operation's
Chris@16 48 // member operator().
Chris@16 49 //
Chris@16 50 // The operation is also expected to have a nested template class
Chris@16 51 // result<T0...TN>. The nested template class result should have a
Chris@16 52 // typedef 'type' that reflects the return type of its member
Chris@16 53 // operator(). This is essentially a type computer that answers the
Chris@16 54 // metaprogramming question "Given arguments of type T0...TN, what
Chris@16 55 // will be its operator()'s return type?".
Chris@16 56 //
Chris@16 57 // There is a special case for operations that accept no arguments.
Chris@16 58 // Such nullary operations are only required to define a typedef
Chris@16 59 // result_type that reflects the return type of its operator().
Chris@16 60 //
Chris@16 61 // Here's an example of a simple operation that squares a number:
Chris@16 62 //
Chris@16 63 // struct square {
Chris@16 64 //
Chris@16 65 // template <typename ArgT>
Chris@16 66 // struct result { typedef ArgT type; };
Chris@16 67 //
Chris@16 68 // template <typename ArgT>
Chris@16 69 // ArgT operator()(ArgT n) const { return n * n; }
Chris@16 70 // };
Chris@16 71 //
Chris@16 72 // As can be seen, operations can be polymorphic. Its arguments and
Chris@16 73 // return type are not fixed to a particular type. The example
Chris@16 74 // above for example, can handle any ArgT type as long as it has a
Chris@16 75 // multiplication operator.
Chris@16 76 //
Chris@16 77 // Composites are not created directly. Instead, there are meta-
Chris@16 78 // programs provided that indirectly create composites. See
Chris@16 79 // operators.hpp, binders.hpp and functions.hpp for examples.
Chris@16 80 //
Chris@16 81 ///////////////////////////////////////////////////////////////////////////////
Chris@16 82 template <
Chris@16 83 typename OperationT
Chris@16 84 , typename A = nil_t
Chris@16 85 , typename B = nil_t
Chris@16 86 , typename C = nil_t
Chris@16 87
Chris@16 88 #if PHOENIX_LIMIT > 3
Chris@16 89 , typename D = nil_t
Chris@16 90 , typename E = nil_t
Chris@16 91 , typename F = nil_t
Chris@16 92
Chris@16 93 #if PHOENIX_LIMIT > 6
Chris@16 94 , typename G = nil_t
Chris@16 95 , typename H = nil_t
Chris@16 96 , typename I = nil_t
Chris@16 97
Chris@16 98 #if PHOENIX_LIMIT > 9
Chris@16 99 , typename J = nil_t
Chris@16 100 , typename K = nil_t
Chris@16 101 , typename L = nil_t
Chris@16 102
Chris@16 103 #if PHOENIX_LIMIT > 12
Chris@16 104 , typename M = nil_t
Chris@16 105 , typename N = nil_t
Chris@16 106 , typename O = nil_t
Chris@16 107
Chris@16 108 #endif
Chris@16 109 #endif
Chris@16 110 #endif
Chris@16 111 #endif
Chris@16 112
Chris@16 113 , typename NU = nil_t // Not used
Chris@16 114 >
Chris@16 115 struct composite;
Chris@16 116
Chris@16 117 ///////////////////////////////////////////////////////////////////////////////
Chris@16 118 //
Chris@16 119 // composite <0 actor> class
Chris@16 120 //
Chris@16 121 ///////////////////////////////////////////////////////////////////////////////
Chris@16 122 template <typename OperationT, typename TupleT>
Chris@16 123 struct composite0_result {
Chris@16 124
Chris@16 125 typedef typename OperationT::result_type type;
Chris@16 126 };
Chris@16 127
Chris@16 128 //////////////////////////////////
Chris@16 129 template <typename OperationT>
Chris@16 130 struct composite<OperationT,
Chris@16 131 nil_t, nil_t, nil_t,
Chris@16 132 #if PHOENIX_LIMIT > 3
Chris@16 133 nil_t, nil_t, nil_t,
Chris@16 134 #if PHOENIX_LIMIT > 6
Chris@16 135 nil_t, nil_t, nil_t,
Chris@16 136 #if PHOENIX_LIMIT > 9
Chris@16 137 nil_t, nil_t, nil_t,
Chris@16 138 #if PHOENIX_LIMIT > 12
Chris@16 139 nil_t, nil_t, nil_t,
Chris@16 140 #endif
Chris@16 141 #endif
Chris@16 142 #endif
Chris@16 143 #endif
Chris@16 144 nil_t // Unused
Chris@16 145 > {
Chris@16 146
Chris@16 147 typedef composite<OperationT> self_t;
Chris@16 148
Chris@16 149 template <typename TupleT>
Chris@16 150 struct result {
Chris@16 151
Chris@16 152 typedef typename composite0_result<
Chris@16 153 OperationT, TupleT
Chris@16 154 >::type type;
Chris@16 155 };
Chris@16 156
Chris@16 157 composite(OperationT const& op_)
Chris@16 158 : op(op_) {}
Chris@16 159
Chris@16 160 template <typename TupleT>
Chris@16 161 typename OperationT::result_type
Chris@16 162 eval(TupleT const& /*args*/) const
Chris@16 163 {
Chris@16 164 return op();
Chris@16 165 }
Chris@16 166
Chris@16 167 mutable OperationT op; // operation
Chris@16 168 };
Chris@16 169
Chris@16 170 ///////////////////////////////////////////////////////////////////////////////
Chris@16 171 //
Chris@16 172 // composite <1 actor> class
Chris@16 173 //
Chris@16 174 ///////////////////////////////////////////////////////////////////////////////
Chris@16 175 template <typename OperationT, typename TupleT,
Chris@16 176 typename A>
Chris@16 177 struct composite1_result {
Chris@16 178
Chris@16 179 typedef typename OperationT::template result<
Chris@16 180 typename actor_result<A, TupleT>::plain_type
Chris@16 181 >::type type;
Chris@16 182 };
Chris@16 183
Chris@16 184 //////////////////////////////////
Chris@16 185 template <typename OperationT,
Chris@16 186 typename A>
Chris@16 187 struct composite<OperationT,
Chris@16 188 A, nil_t, nil_t,
Chris@16 189 #if PHOENIX_LIMIT > 3
Chris@16 190 nil_t, nil_t, nil_t,
Chris@16 191 #if PHOENIX_LIMIT > 6
Chris@16 192 nil_t, nil_t, nil_t,
Chris@16 193 #if PHOENIX_LIMIT > 9
Chris@16 194 nil_t, nil_t, nil_t,
Chris@16 195 #if PHOENIX_LIMIT > 12
Chris@16 196 nil_t, nil_t, nil_t,
Chris@16 197 #endif
Chris@16 198 #endif
Chris@16 199 #endif
Chris@16 200 #endif
Chris@16 201 nil_t // Unused
Chris@16 202 > {
Chris@16 203
Chris@16 204 typedef composite<OperationT, A> self_t;
Chris@16 205
Chris@16 206 template <typename TupleT>
Chris@16 207 struct result {
Chris@16 208
Chris@16 209 typedef typename composite1_result<
Chris@16 210 OperationT, TupleT, A
Chris@16 211 >::type type;
Chris@16 212 };
Chris@16 213
Chris@16 214 composite(OperationT const& op_,
Chris@16 215 A const& a_)
Chris@16 216 : op(op_), a(a_) {}
Chris@16 217
Chris@16 218 template <typename TupleT>
Chris@16 219 typename actor_result<self_t, TupleT>::type
Chris@16 220 eval(TupleT const& args) const
Chris@16 221 {
Chris@16 222 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 223 return op(ra);
Chris@16 224 }
Chris@16 225
Chris@16 226 mutable OperationT op; // operation
Chris@16 227 A a; // actors
Chris@16 228 };
Chris@16 229
Chris@16 230 ///////////////////////////////////////////////////////////////////////////////
Chris@16 231 //
Chris@16 232 // composite <2 actors> class
Chris@16 233 //
Chris@16 234 ///////////////////////////////////////////////////////////////////////////////
Chris@16 235 template <typename OperationT, typename TupleT,
Chris@16 236 typename A, typename B>
Chris@16 237 struct composite2_result {
Chris@16 238
Chris@16 239 typedef typename OperationT::template result<
Chris@16 240 typename actor_result<A, TupleT>::plain_type,
Chris@16 241 typename actor_result<B, TupleT>::plain_type
Chris@16 242 >::type type;
Chris@16 243 };
Chris@16 244
Chris@16 245 //////////////////////////////////
Chris@16 246 template <typename OperationT,
Chris@16 247 typename A, typename B>
Chris@16 248 struct composite<OperationT,
Chris@16 249 A, B, nil_t,
Chris@16 250 #if PHOENIX_LIMIT > 3
Chris@16 251 nil_t, nil_t, nil_t,
Chris@16 252 #if PHOENIX_LIMIT > 6
Chris@16 253 nil_t, nil_t, nil_t,
Chris@16 254 #if PHOENIX_LIMIT > 9
Chris@16 255 nil_t, nil_t, nil_t,
Chris@16 256 #if PHOENIX_LIMIT > 12
Chris@16 257 nil_t, nil_t, nil_t,
Chris@16 258 #endif
Chris@16 259 #endif
Chris@16 260 #endif
Chris@16 261 #endif
Chris@16 262 nil_t // Unused
Chris@16 263 > {
Chris@16 264
Chris@16 265 typedef composite<OperationT, A, B> self_t;
Chris@16 266
Chris@16 267 template <typename TupleT>
Chris@16 268 struct result {
Chris@16 269
Chris@16 270 typedef typename composite2_result<
Chris@16 271 OperationT, TupleT, A, B
Chris@16 272 >::type type;
Chris@16 273 };
Chris@16 274
Chris@16 275 composite(OperationT const& op_,
Chris@16 276 A const& a_, B const& b_)
Chris@16 277 : op(op_), a(a_), b(b_) {}
Chris@16 278
Chris@16 279 template <typename TupleT>
Chris@16 280 typename actor_result<self_t, TupleT>::type
Chris@16 281 eval(TupleT const& args) const
Chris@16 282 {
Chris@16 283 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 284 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 285 return op(ra, rb);
Chris@16 286 }
Chris@16 287
Chris@16 288 mutable OperationT op; // operation
Chris@16 289 A a; B b; // actors
Chris@16 290 };
Chris@16 291
Chris@16 292 ///////////////////////////////////////////////////////////////////////////////
Chris@16 293 //
Chris@16 294 // composite <3 actors> class
Chris@16 295 //
Chris@16 296 ///////////////////////////////////////////////////////////////////////////////
Chris@16 297 template <typename OperationT, typename TupleT,
Chris@16 298 typename A, typename B, typename C>
Chris@16 299 struct composite3_result {
Chris@16 300
Chris@16 301 typedef typename OperationT::template result<
Chris@16 302 typename actor_result<A, TupleT>::plain_type,
Chris@16 303 typename actor_result<B, TupleT>::plain_type,
Chris@16 304 typename actor_result<C, TupleT>::plain_type
Chris@16 305 >::type type;
Chris@16 306 };
Chris@16 307
Chris@16 308 //////////////////////////////////
Chris@16 309 template <typename OperationT,
Chris@16 310 typename A, typename B, typename C>
Chris@16 311 struct composite<OperationT,
Chris@16 312 A, B, C,
Chris@16 313 #if PHOENIX_LIMIT > 3
Chris@16 314 nil_t, nil_t, nil_t,
Chris@16 315 #if PHOENIX_LIMIT > 6
Chris@16 316 nil_t, nil_t, nil_t,
Chris@16 317 #if PHOENIX_LIMIT > 9
Chris@16 318 nil_t, nil_t, nil_t,
Chris@16 319 #if PHOENIX_LIMIT > 12
Chris@16 320 nil_t, nil_t, nil_t,
Chris@16 321 #endif
Chris@16 322 #endif
Chris@16 323 #endif
Chris@16 324 #endif
Chris@16 325 nil_t // Unused
Chris@16 326 > {
Chris@16 327
Chris@16 328 typedef composite<OperationT, A, B, C> self_t;
Chris@16 329
Chris@16 330 template <typename TupleT>
Chris@16 331 struct result {
Chris@16 332
Chris@16 333 typedef typename composite3_result<
Chris@16 334 OperationT, TupleT, A, B, C
Chris@16 335 >::type type;
Chris@16 336 };
Chris@16 337
Chris@16 338 composite(OperationT const& op_,
Chris@16 339 A const& a_, B const& b_, C const& c_)
Chris@16 340 : op(op_), a(a_), b(b_), c(c_) {}
Chris@16 341
Chris@16 342 template <typename TupleT>
Chris@16 343 typename actor_result<self_t, TupleT>::type
Chris@16 344 eval(TupleT const& args) const
Chris@16 345 {
Chris@16 346 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 347 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 348 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 349 return op(ra, rb, rc);
Chris@16 350 }
Chris@16 351
Chris@16 352 mutable OperationT op; // operation
Chris@16 353 A a; B b; C c; // actors
Chris@16 354 };
Chris@16 355
Chris@16 356 #if PHOENIX_LIMIT > 3
Chris@16 357 ///////////////////////////////////////////////////////////////////////////////
Chris@16 358 //
Chris@16 359 // composite <4 actors> class
Chris@16 360 //
Chris@16 361 ///////////////////////////////////////////////////////////////////////////////
Chris@16 362 template <typename OperationT, typename TupleT,
Chris@16 363 typename A, typename B, typename C, typename D>
Chris@16 364 struct composite4_result {
Chris@16 365
Chris@16 366 typedef typename OperationT::template result<
Chris@16 367 typename actor_result<A, TupleT>::plain_type,
Chris@16 368 typename actor_result<B, TupleT>::plain_type,
Chris@16 369 typename actor_result<C, TupleT>::plain_type,
Chris@16 370 typename actor_result<D, TupleT>::plain_type
Chris@16 371 >::type type;
Chris@16 372 };
Chris@16 373
Chris@16 374 //////////////////////////////////
Chris@16 375 template <typename OperationT,
Chris@16 376 typename A, typename B, typename C, typename D>
Chris@16 377 struct composite<OperationT,
Chris@16 378 A, B, C, D, nil_t, nil_t,
Chris@16 379 #if PHOENIX_LIMIT > 6
Chris@16 380 nil_t, nil_t, nil_t,
Chris@16 381 #if PHOENIX_LIMIT > 9
Chris@16 382 nil_t, nil_t, nil_t,
Chris@16 383 #if PHOENIX_LIMIT > 12
Chris@16 384 nil_t, nil_t, nil_t,
Chris@16 385 #endif
Chris@16 386 #endif
Chris@16 387 #endif
Chris@16 388 nil_t // Unused
Chris@16 389 > {
Chris@16 390
Chris@16 391 typedef composite<OperationT, A, B, C, D> self_t;
Chris@16 392
Chris@16 393 template <typename TupleT>
Chris@16 394 struct result {
Chris@16 395
Chris@16 396 typedef typename composite4_result<
Chris@16 397 OperationT, TupleT, A, B, C, D
Chris@16 398 >::type type;
Chris@16 399 };
Chris@16 400
Chris@16 401 composite(OperationT const& op_,
Chris@16 402 A const& a_, B const& b_, C const& c_, D const& d_)
Chris@16 403 : op(op_), a(a_), b(b_), c(c_), d(d_) {}
Chris@16 404
Chris@16 405 template <typename TupleT>
Chris@16 406 typename actor_result<self_t, TupleT>::type
Chris@16 407 eval(TupleT const& args) const
Chris@16 408 {
Chris@16 409 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 410 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 411 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 412 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 413 return op(ra, rb, rc, rd);
Chris@16 414 }
Chris@16 415
Chris@16 416 mutable OperationT op; // operation
Chris@16 417 A a; B b; C c; D d; // actors
Chris@16 418 };
Chris@16 419
Chris@16 420 ///////////////////////////////////////////////////////////////////////////////
Chris@16 421 //
Chris@16 422 // composite <5 actors> class
Chris@16 423 //
Chris@16 424 ///////////////////////////////////////////////////////////////////////////////
Chris@16 425 template <typename OperationT, typename TupleT,
Chris@16 426 typename A, typename B, typename C, typename D, typename E>
Chris@16 427 struct composite5_result {
Chris@16 428
Chris@16 429 typedef typename OperationT::template result<
Chris@16 430 typename actor_result<A, TupleT>::plain_type,
Chris@16 431 typename actor_result<B, TupleT>::plain_type,
Chris@16 432 typename actor_result<C, TupleT>::plain_type,
Chris@16 433 typename actor_result<D, TupleT>::plain_type,
Chris@16 434 typename actor_result<E, TupleT>::plain_type
Chris@16 435 >::type type;
Chris@16 436 };
Chris@16 437
Chris@16 438 //////////////////////////////////
Chris@16 439 template <typename OperationT,
Chris@16 440 typename A, typename B, typename C, typename D, typename E>
Chris@16 441 struct composite<OperationT,
Chris@16 442 A, B, C, D, E, nil_t,
Chris@16 443 #if PHOENIX_LIMIT > 6
Chris@16 444 nil_t, nil_t, nil_t,
Chris@16 445 #if PHOENIX_LIMIT > 9
Chris@16 446 nil_t, nil_t, nil_t,
Chris@16 447 #if PHOENIX_LIMIT > 12
Chris@16 448 nil_t, nil_t, nil_t,
Chris@16 449 #endif
Chris@16 450 #endif
Chris@16 451 #endif
Chris@16 452 nil_t // Unused
Chris@16 453 > {
Chris@16 454
Chris@16 455 typedef composite<OperationT, A, B, C, D, E> self_t;
Chris@16 456
Chris@16 457 template <typename TupleT>
Chris@16 458 struct result {
Chris@16 459
Chris@16 460 typedef typename composite5_result<
Chris@16 461 OperationT, TupleT, A, B, C, D, E
Chris@16 462 >::type type;
Chris@16 463 };
Chris@16 464
Chris@16 465 composite(OperationT const& op_,
Chris@16 466 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_)
Chris@16 467 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_) {}
Chris@16 468
Chris@16 469 template <typename TupleT>
Chris@16 470 typename actor_result<self_t, TupleT>::type
Chris@16 471 eval(TupleT const& args) const
Chris@16 472 {
Chris@16 473 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 474 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 475 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 476 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 477 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 478 return op(ra, rb, rc, rd, re);
Chris@16 479 }
Chris@16 480
Chris@16 481 mutable OperationT op; // operation
Chris@16 482 A a; B b; C c; D d; E e; // actors
Chris@16 483 };
Chris@16 484
Chris@16 485 ///////////////////////////////////////////////////////////////////////////////
Chris@16 486 //
Chris@16 487 // composite <6 actors> class
Chris@16 488 //
Chris@16 489 ///////////////////////////////////////////////////////////////////////////////
Chris@16 490 template <typename OperationT, typename TupleT,
Chris@16 491 typename A, typename B, typename C, typename D, typename E,
Chris@16 492 typename F>
Chris@16 493 struct composite6_result {
Chris@16 494
Chris@16 495 typedef typename OperationT::template result<
Chris@16 496 typename actor_result<A, TupleT>::plain_type,
Chris@16 497 typename actor_result<B, TupleT>::plain_type,
Chris@16 498 typename actor_result<C, TupleT>::plain_type,
Chris@16 499 typename actor_result<D, TupleT>::plain_type,
Chris@16 500 typename actor_result<E, TupleT>::plain_type,
Chris@16 501 typename actor_result<F, TupleT>::plain_type
Chris@16 502 >::type type;
Chris@16 503 };
Chris@16 504
Chris@16 505 //////////////////////////////////
Chris@16 506 template <typename OperationT,
Chris@16 507 typename A, typename B, typename C, typename D, typename E,
Chris@16 508 typename F>
Chris@16 509 struct composite<OperationT,
Chris@16 510 A, B, C, D, E, F,
Chris@16 511 #if PHOENIX_LIMIT > 6
Chris@16 512 nil_t, nil_t, nil_t,
Chris@16 513 #if PHOENIX_LIMIT > 9
Chris@16 514 nil_t, nil_t, nil_t,
Chris@16 515 #if PHOENIX_LIMIT > 12
Chris@16 516 nil_t, nil_t, nil_t,
Chris@16 517 #endif
Chris@16 518 #endif
Chris@16 519 #endif
Chris@16 520 nil_t // Unused
Chris@16 521 > {
Chris@16 522
Chris@16 523 typedef composite<OperationT, A, B, C, D, E, F> self_t;
Chris@16 524
Chris@16 525 template <typename TupleT>
Chris@16 526 struct result {
Chris@16 527
Chris@16 528 typedef typename composite6_result<
Chris@16 529 OperationT, TupleT, A, B, C, D, E, F
Chris@16 530 >::type type;
Chris@16 531 };
Chris@16 532
Chris@16 533 composite(OperationT const& op_,
Chris@16 534 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 535 F const& f_)
Chris@16 536 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 537 f(f_) {}
Chris@16 538
Chris@16 539 template <typename TupleT>
Chris@16 540 typename actor_result<self_t, TupleT>::type
Chris@16 541 eval(TupleT const& args) const
Chris@16 542 {
Chris@16 543 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 544 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 545 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 546 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 547 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 548 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 549 return op(ra, rb, rc, rd, re, rf);
Chris@16 550 }
Chris@16 551
Chris@16 552 mutable OperationT op; // operation
Chris@16 553 A a; B b; C c; D d; E e; F f; // actors
Chris@16 554 };
Chris@16 555
Chris@16 556 #if PHOENIX_LIMIT > 6
Chris@16 557 ///////////////////////////////////////////////////////////////////////////////
Chris@16 558 //
Chris@16 559 // composite <7 actors> class
Chris@16 560 //
Chris@16 561 ///////////////////////////////////////////////////////////////////////////////
Chris@16 562 template <typename OperationT, typename TupleT,
Chris@16 563 typename A, typename B, typename C, typename D, typename E,
Chris@16 564 typename F, typename G>
Chris@16 565 struct composite7_result {
Chris@16 566
Chris@16 567 typedef typename OperationT::template result<
Chris@16 568 typename actor_result<A, TupleT>::plain_type,
Chris@16 569 typename actor_result<B, TupleT>::plain_type,
Chris@16 570 typename actor_result<C, TupleT>::plain_type,
Chris@16 571 typename actor_result<D, TupleT>::plain_type,
Chris@16 572 typename actor_result<E, TupleT>::plain_type,
Chris@16 573 typename actor_result<F, TupleT>::plain_type,
Chris@16 574 typename actor_result<G, TupleT>::plain_type
Chris@16 575 >::type type;
Chris@16 576 };
Chris@16 577
Chris@16 578 //////////////////////////////////
Chris@16 579 template <typename OperationT,
Chris@16 580 typename A, typename B, typename C, typename D, typename E,
Chris@16 581 typename F, typename G>
Chris@16 582 struct composite<OperationT,
Chris@16 583 A, B, C, D, E, F, G, nil_t, nil_t,
Chris@16 584 #if PHOENIX_LIMIT > 9
Chris@16 585 nil_t, nil_t, nil_t,
Chris@16 586 #if PHOENIX_LIMIT > 12
Chris@16 587 nil_t, nil_t, nil_t,
Chris@16 588 #endif
Chris@16 589 #endif
Chris@16 590 nil_t // Unused
Chris@16 591 > {
Chris@16 592
Chris@16 593 typedef composite<OperationT, A, B, C, D, E, F, G> self_t;
Chris@16 594
Chris@16 595 template <typename TupleT>
Chris@16 596 struct result {
Chris@16 597
Chris@16 598 typedef typename composite7_result<
Chris@16 599 OperationT, TupleT, A, B, C, D, E, F, G
Chris@16 600 >::type type;
Chris@16 601 };
Chris@16 602
Chris@16 603 composite(OperationT const& op_,
Chris@16 604 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 605 F const& f_, G const& g_)
Chris@16 606 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 607 f(f_), g(g_) {}
Chris@16 608
Chris@16 609 template <typename TupleT>
Chris@16 610 typename actor_result<self_t, TupleT>::type
Chris@16 611 eval(TupleT const& args) const
Chris@16 612 {
Chris@16 613 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 614 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 615 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 616 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 617 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 618 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 619 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 620 return op(ra, rb, rc, rd, re, rf, rg);
Chris@16 621 }
Chris@16 622
Chris@16 623 mutable OperationT op; // operation
Chris@16 624 A a; B b; C c; D d; E e; F f; G g; // actors
Chris@16 625 };
Chris@16 626
Chris@16 627 ///////////////////////////////////////////////////////////////////////////////
Chris@16 628 //
Chris@16 629 // composite <8 actors> class
Chris@16 630 //
Chris@16 631 ///////////////////////////////////////////////////////////////////////////////
Chris@16 632 template <typename OperationT, typename TupleT,
Chris@16 633 typename A, typename B, typename C, typename D, typename E,
Chris@16 634 typename F, typename G, typename H>
Chris@16 635 struct composite8_result {
Chris@16 636
Chris@16 637 typedef typename OperationT::template result<
Chris@16 638 typename actor_result<A, TupleT>::plain_type,
Chris@16 639 typename actor_result<B, TupleT>::plain_type,
Chris@16 640 typename actor_result<C, TupleT>::plain_type,
Chris@16 641 typename actor_result<D, TupleT>::plain_type,
Chris@16 642 typename actor_result<E, TupleT>::plain_type,
Chris@16 643 typename actor_result<F, TupleT>::plain_type,
Chris@16 644 typename actor_result<G, TupleT>::plain_type,
Chris@16 645 typename actor_result<H, TupleT>::plain_type
Chris@16 646 >::type type;
Chris@16 647 };
Chris@16 648
Chris@16 649 //////////////////////////////////
Chris@16 650 template <typename OperationT,
Chris@16 651 typename A, typename B, typename C, typename D, typename E,
Chris@16 652 typename F, typename G, typename H>
Chris@16 653 struct composite<OperationT,
Chris@16 654 A, B, C, D, E, F, G, H, nil_t,
Chris@16 655 #if PHOENIX_LIMIT > 9
Chris@16 656 nil_t, nil_t, nil_t,
Chris@16 657 #if PHOENIX_LIMIT > 12
Chris@16 658 nil_t, nil_t, nil_t,
Chris@16 659 #endif
Chris@16 660 #endif
Chris@16 661 nil_t // Unused
Chris@16 662 > {
Chris@16 663
Chris@16 664 typedef composite<OperationT, A, B, C, D, E, F, G, H> self_t;
Chris@16 665
Chris@16 666 template <typename TupleT>
Chris@16 667 struct result {
Chris@16 668
Chris@16 669 typedef typename composite8_result<
Chris@16 670 OperationT, TupleT, A, B, C, D, E, F, G, H
Chris@16 671 >::type type;
Chris@16 672 };
Chris@16 673
Chris@16 674 composite(OperationT const& op_,
Chris@16 675 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 676 F const& f_, G const& g_, H const& h_)
Chris@16 677 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 678 f(f_), g(g_), h(h_) {}
Chris@16 679
Chris@16 680 template <typename TupleT>
Chris@16 681 typename actor_result<self_t, TupleT>::type
Chris@16 682 eval(TupleT const& args) const
Chris@16 683 {
Chris@16 684 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 685 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 686 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 687 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 688 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 689 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 690 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 691 typename actor_result<H, TupleT>::type rh = h.eval(args);
Chris@16 692 return op(ra, rb, rc, rd, re, rf, rg, rh);
Chris@16 693 }
Chris@16 694
Chris@16 695 mutable OperationT op; // operation
Chris@16 696 A a; B b; C c; D d; E e; F f; G g; H h; // actors
Chris@16 697 };
Chris@16 698
Chris@16 699 ///////////////////////////////////////////////////////////////////////////////
Chris@16 700 //
Chris@16 701 // composite <9 actors> class
Chris@16 702 //
Chris@16 703 ///////////////////////////////////////////////////////////////////////////////
Chris@16 704 template <typename OperationT, typename TupleT,
Chris@16 705 typename A, typename B, typename C, typename D, typename E,
Chris@16 706 typename F, typename G, typename H, typename I>
Chris@16 707 struct composite9_result {
Chris@16 708
Chris@16 709 typedef typename OperationT::template result<
Chris@16 710 typename actor_result<A, TupleT>::plain_type,
Chris@16 711 typename actor_result<B, TupleT>::plain_type,
Chris@16 712 typename actor_result<C, TupleT>::plain_type,
Chris@16 713 typename actor_result<D, TupleT>::plain_type,
Chris@16 714 typename actor_result<E, TupleT>::plain_type,
Chris@16 715 typename actor_result<F, TupleT>::plain_type,
Chris@16 716 typename actor_result<G, TupleT>::plain_type,
Chris@16 717 typename actor_result<H, TupleT>::plain_type,
Chris@16 718 typename actor_result<I, TupleT>::plain_type
Chris@16 719 >::type type;
Chris@16 720 };
Chris@16 721
Chris@16 722 //////////////////////////////////
Chris@16 723 template <typename OperationT,
Chris@16 724 typename A, typename B, typename C, typename D, typename E,
Chris@16 725 typename F, typename G, typename H, typename I>
Chris@16 726 struct composite<OperationT,
Chris@16 727 A, B, C, D, E, F, G, H, I,
Chris@16 728 #if PHOENIX_LIMIT > 9
Chris@16 729 nil_t, nil_t, nil_t,
Chris@16 730 #if PHOENIX_LIMIT > 12
Chris@16 731 nil_t, nil_t, nil_t,
Chris@16 732 #endif
Chris@16 733 #endif
Chris@16 734 nil_t // Unused
Chris@16 735 > {
Chris@16 736
Chris@16 737 typedef composite<OperationT, A, B, C, D, E, F, G, H, I> self_t;
Chris@16 738
Chris@16 739 template <typename TupleT>
Chris@16 740 struct result {
Chris@16 741
Chris@16 742 typedef typename composite9_result<
Chris@16 743 OperationT, TupleT, A, B, C, D, E, F, G, H, I
Chris@16 744 >::type type;
Chris@16 745 };
Chris@16 746
Chris@16 747 composite(OperationT const& op_,
Chris@16 748 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 749 F const& f_, G const& g_, H const& h_, I const& i_)
Chris@16 750 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 751 f(f_), g(g_), h(h_), i(i_) {}
Chris@16 752
Chris@16 753 template <typename TupleT>
Chris@16 754 typename actor_result<self_t, TupleT>::type
Chris@16 755 eval(TupleT const& args) const
Chris@16 756 {
Chris@16 757 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 758 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 759 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 760 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 761 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 762 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 763 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 764 typename actor_result<H, TupleT>::type rh = h.eval(args);
Chris@16 765 typename actor_result<I, TupleT>::type ri = i.eval(args);
Chris@16 766 return op(ra, rb, rc, rd, re, rf, rg, rh, ri);
Chris@16 767 }
Chris@16 768
Chris@16 769 mutable OperationT op; // operation
Chris@16 770 A a; B b; C c; D d; E e; F f; G g; H h; I i; // actors
Chris@16 771 };
Chris@16 772
Chris@16 773 #if PHOENIX_LIMIT > 9
Chris@16 774 ///////////////////////////////////////////////////////////////////////////////
Chris@16 775 //
Chris@16 776 // composite <10 actors> class
Chris@16 777 //
Chris@16 778 ///////////////////////////////////////////////////////////////////////////////
Chris@16 779 template <typename OperationT, typename TupleT,
Chris@16 780 typename A, typename B, typename C, typename D, typename E,
Chris@16 781 typename F, typename G, typename H, typename I, typename J>
Chris@16 782 struct composite10_result {
Chris@16 783
Chris@16 784 typedef typename OperationT::template result<
Chris@16 785 typename actor_result<A, TupleT>::plain_type,
Chris@16 786 typename actor_result<B, TupleT>::plain_type,
Chris@16 787 typename actor_result<C, TupleT>::plain_type,
Chris@16 788 typename actor_result<D, TupleT>::plain_type,
Chris@16 789 typename actor_result<E, TupleT>::plain_type,
Chris@16 790 typename actor_result<F, TupleT>::plain_type,
Chris@16 791 typename actor_result<G, TupleT>::plain_type,
Chris@16 792 typename actor_result<H, TupleT>::plain_type,
Chris@16 793 typename actor_result<I, TupleT>::plain_type,
Chris@16 794 typename actor_result<J, TupleT>::plain_type
Chris@16 795 >::type type;
Chris@16 796 };
Chris@16 797
Chris@16 798 //////////////////////////////////
Chris@16 799 template <typename OperationT,
Chris@16 800 typename A, typename B, typename C, typename D, typename E,
Chris@16 801 typename F, typename G, typename H, typename I, typename J>
Chris@16 802 struct composite<OperationT,
Chris@16 803 A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
Chris@16 804 #if PHOENIX_LIMIT > 12
Chris@16 805 nil_t, nil_t, nil_t,
Chris@16 806 #endif
Chris@16 807 nil_t // Unused
Chris@16 808 > {
Chris@16 809
Chris@16 810 typedef composite<OperationT, A, B, C, D, E, F, G, H, I, J> self_t;
Chris@16 811
Chris@16 812 template <typename TupleT>
Chris@16 813 struct result {
Chris@16 814
Chris@16 815 typedef typename composite10_result<
Chris@16 816 OperationT, TupleT, A, B, C, D, E, F, G, H, I, J
Chris@16 817 >::type type;
Chris@16 818 };
Chris@16 819
Chris@16 820 composite(OperationT const& op_,
Chris@16 821 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 822 F const& f_, G const& g_, H const& h_, I const& i_, J const& j_)
Chris@16 823 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 824 f(f_), g(g_), h(h_), i(i_), j(j_) {}
Chris@16 825
Chris@16 826 template <typename TupleT>
Chris@16 827 typename actor_result<self_t, TupleT>::type
Chris@16 828 eval(TupleT const& args) const
Chris@16 829 {
Chris@16 830 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 831 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 832 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 833 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 834 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 835 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 836 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 837 typename actor_result<H, TupleT>::type rh = h.eval(args);
Chris@16 838 typename actor_result<I, TupleT>::type ri = i.eval(args);
Chris@16 839 typename actor_result<J, TupleT>::type rj = j.eval(args);
Chris@16 840 return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj);
Chris@16 841 }
Chris@16 842
Chris@16 843 mutable OperationT op; // operation
Chris@16 844 A a; B b; C c; D d; E e; F f; G g; H h; I i; J j; // actors
Chris@16 845 };
Chris@16 846
Chris@16 847 ///////////////////////////////////////////////////////////////////////////////
Chris@16 848 //
Chris@16 849 // composite <11 actors> class
Chris@16 850 //
Chris@16 851 ///////////////////////////////////////////////////////////////////////////////
Chris@16 852 template <typename OperationT, typename TupleT,
Chris@16 853 typename A, typename B, typename C, typename D, typename E,
Chris@16 854 typename F, typename G, typename H, typename I, typename J,
Chris@16 855 typename K>
Chris@16 856 struct composite11_result {
Chris@16 857
Chris@16 858 typedef typename OperationT::template result<
Chris@16 859 typename actor_result<A, TupleT>::plain_type,
Chris@16 860 typename actor_result<B, TupleT>::plain_type,
Chris@16 861 typename actor_result<C, TupleT>::plain_type,
Chris@16 862 typename actor_result<D, TupleT>::plain_type,
Chris@16 863 typename actor_result<E, TupleT>::plain_type,
Chris@16 864 typename actor_result<F, TupleT>::plain_type,
Chris@16 865 typename actor_result<G, TupleT>::plain_type,
Chris@16 866 typename actor_result<H, TupleT>::plain_type,
Chris@16 867 typename actor_result<I, TupleT>::plain_type,
Chris@16 868 typename actor_result<J, TupleT>::plain_type,
Chris@16 869 typename actor_result<K, TupleT>::plain_type
Chris@16 870 >::type type;
Chris@16 871 };
Chris@16 872
Chris@16 873 //////////////////////////////////
Chris@16 874 template <typename OperationT,
Chris@16 875 typename A, typename B, typename C, typename D, typename E,
Chris@16 876 typename F, typename G, typename H, typename I, typename J,
Chris@16 877 typename K>
Chris@16 878 struct composite<OperationT,
Chris@16 879 A, B, C, D, E, F, G, H, I, J, K, nil_t,
Chris@16 880 #if PHOENIX_LIMIT > 12
Chris@16 881 nil_t, nil_t, nil_t,
Chris@16 882 #endif
Chris@16 883 nil_t // Unused
Chris@16 884 > {
Chris@16 885
Chris@16 886 typedef composite<OperationT,
Chris@16 887 A, B, C, D, E, F, G, H, I, J, K> self_t;
Chris@16 888
Chris@16 889 template <typename TupleT>
Chris@16 890 struct result {
Chris@16 891
Chris@16 892 typedef typename composite11_result<
Chris@16 893 OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K
Chris@16 894 >::type type;
Chris@16 895 };
Chris@16 896
Chris@16 897 composite(OperationT const& op_,
Chris@16 898 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 899 F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
Chris@16 900 K const& k_)
Chris@16 901 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 902 f(f_), g(g_), h(h_), i(i_), j(j_),
Chris@16 903 k(k_) {}
Chris@16 904
Chris@16 905 template <typename TupleT>
Chris@16 906 typename actor_result<self_t, TupleT>::type
Chris@16 907 eval(TupleT const& args) const
Chris@16 908 {
Chris@16 909 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 910 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 911 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 912 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 913 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 914 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 915 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 916 typename actor_result<H, TupleT>::type rh = h.eval(args);
Chris@16 917 typename actor_result<I, TupleT>::type ri = i.eval(args);
Chris@16 918 typename actor_result<J, TupleT>::type rj = j.eval(args);
Chris@16 919 typename actor_result<K, TupleT>::type rk = k.eval(args);
Chris@16 920 return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk);
Chris@16 921 }
Chris@16 922
Chris@16 923 mutable OperationT op; // operation
Chris@16 924 A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
Chris@16 925 K k;// actors
Chris@16 926 };
Chris@16 927
Chris@16 928 ///////////////////////////////////////////////////////////////////////////////
Chris@16 929 //
Chris@16 930 // composite <12 actors> class
Chris@16 931 //
Chris@16 932 ///////////////////////////////////////////////////////////////////////////////
Chris@16 933 template <typename OperationT, typename TupleT,
Chris@16 934 typename A, typename B, typename C, typename D, typename E,
Chris@16 935 typename F, typename G, typename H, typename I, typename J,
Chris@16 936 typename K, typename L>
Chris@16 937 struct composite12_result {
Chris@16 938
Chris@16 939 typedef typename OperationT::template result<
Chris@16 940 typename actor_result<A, TupleT>::plain_type,
Chris@16 941 typename actor_result<B, TupleT>::plain_type,
Chris@16 942 typename actor_result<C, TupleT>::plain_type,
Chris@16 943 typename actor_result<D, TupleT>::plain_type,
Chris@16 944 typename actor_result<E, TupleT>::plain_type,
Chris@16 945 typename actor_result<F, TupleT>::plain_type,
Chris@16 946 typename actor_result<G, TupleT>::plain_type,
Chris@16 947 typename actor_result<H, TupleT>::plain_type,
Chris@16 948 typename actor_result<I, TupleT>::plain_type,
Chris@16 949 typename actor_result<J, TupleT>::plain_type,
Chris@16 950 typename actor_result<K, TupleT>::plain_type,
Chris@16 951 typename actor_result<L, TupleT>::plain_type
Chris@16 952 >::type type;
Chris@16 953 };
Chris@16 954
Chris@16 955 //////////////////////////////////
Chris@16 956 template <typename OperationT,
Chris@16 957 typename A, typename B, typename C, typename D, typename E,
Chris@16 958 typename F, typename G, typename H, typename I, typename J,
Chris@16 959 typename K, typename L>
Chris@16 960 struct composite<OperationT,
Chris@16 961 A, B, C, D, E, F, G, H, I, J, K, L,
Chris@16 962 #if PHOENIX_LIMIT > 12
Chris@16 963 nil_t, nil_t, nil_t,
Chris@16 964 #endif
Chris@16 965 nil_t // Unused
Chris@16 966 > {
Chris@16 967
Chris@16 968 typedef composite<OperationT,
Chris@16 969 A, B, C, D, E, F, G, H, I, J, K, L> self_t;
Chris@16 970
Chris@16 971 template <typename TupleT>
Chris@16 972 struct result {
Chris@16 973
Chris@16 974 typedef typename composite12_result<
Chris@16 975 OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L
Chris@16 976 >::type type;
Chris@16 977 };
Chris@16 978
Chris@16 979 composite(OperationT const& op_,
Chris@16 980 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 981 F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
Chris@16 982 K const& k_, L const& l_)
Chris@16 983 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 984 f(f_), g(g_), h(h_), i(i_), j(j_),
Chris@16 985 k(k_), l(l_) {}
Chris@16 986
Chris@16 987 template <typename TupleT>
Chris@16 988 typename actor_result<self_t, TupleT>::type
Chris@16 989 eval(TupleT const& args) const
Chris@16 990 {
Chris@16 991 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 992 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 993 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 994 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 995 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 996 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 997 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 998 typename actor_result<H, TupleT>::type rh = h.eval(args);
Chris@16 999 typename actor_result<I, TupleT>::type ri = i.eval(args);
Chris@16 1000 typename actor_result<J, TupleT>::type rj = j.eval(args);
Chris@16 1001 typename actor_result<K, TupleT>::type rk = k.eval(args);
Chris@16 1002 typename actor_result<L, TupleT>::type rl = l.eval(args);
Chris@16 1003 return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl);
Chris@16 1004 }
Chris@16 1005
Chris@16 1006 mutable OperationT op; // operation
Chris@16 1007 A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
Chris@16 1008 K k; L l;// actors
Chris@16 1009 };
Chris@16 1010
Chris@16 1011 #if PHOENIX_LIMIT > 12
Chris@16 1012 ///////////////////////////////////////////////////////////////////////////////
Chris@16 1013 //
Chris@16 1014 // composite <13 actors> class
Chris@16 1015 //
Chris@16 1016 ///////////////////////////////////////////////////////////////////////////////
Chris@16 1017 template <typename OperationT, typename TupleT,
Chris@16 1018 typename A, typename B, typename C, typename D, typename E,
Chris@16 1019 typename F, typename G, typename H, typename I, typename J,
Chris@16 1020 typename K, typename L, typename M>
Chris@16 1021 struct composite13_result {
Chris@16 1022
Chris@16 1023 typedef typename OperationT::template result<
Chris@16 1024 typename actor_result<A, TupleT>::plain_type,
Chris@16 1025 typename actor_result<B, TupleT>::plain_type,
Chris@16 1026 typename actor_result<C, TupleT>::plain_type,
Chris@16 1027 typename actor_result<D, TupleT>::plain_type,
Chris@16 1028 typename actor_result<E, TupleT>::plain_type,
Chris@16 1029 typename actor_result<F, TupleT>::plain_type,
Chris@16 1030 typename actor_result<G, TupleT>::plain_type,
Chris@16 1031 typename actor_result<H, TupleT>::plain_type,
Chris@16 1032 typename actor_result<I, TupleT>::plain_type,
Chris@16 1033 typename actor_result<J, TupleT>::plain_type,
Chris@16 1034 typename actor_result<K, TupleT>::plain_type,
Chris@16 1035 typename actor_result<L, TupleT>::plain_type,
Chris@16 1036 typename actor_result<M, TupleT>::plain_type
Chris@16 1037 >::type type;
Chris@16 1038 };
Chris@16 1039
Chris@16 1040 //////////////////////////////////
Chris@16 1041 template <typename OperationT,
Chris@16 1042 typename A, typename B, typename C, typename D, typename E,
Chris@16 1043 typename F, typename G, typename H, typename I, typename J,
Chris@16 1044 typename K, typename L, typename M>
Chris@16 1045 struct composite<OperationT,
Chris@16 1046 A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t
Chris@16 1047 > {
Chris@16 1048
Chris@16 1049 typedef composite<OperationT,
Chris@16 1050 A, B, C, D, E, F, G, H, I, J, K, L, M> self_t;
Chris@16 1051
Chris@16 1052 template <typename TupleT>
Chris@16 1053 struct result {
Chris@16 1054
Chris@16 1055 typedef typename composite13_result<
Chris@16 1056 OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M
Chris@16 1057 >::type type;
Chris@16 1058 };
Chris@16 1059
Chris@16 1060 composite(OperationT const& op_,
Chris@16 1061 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 1062 F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
Chris@16 1063 K const& k_, L const& l_, M const& m_)
Chris@16 1064 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 1065 f(f_), g(g_), h(h_), i(i_), j(j_),
Chris@16 1066 k(k_), l(l_), m(m_) {}
Chris@16 1067
Chris@16 1068 template <typename TupleT>
Chris@16 1069 typename actor_result<self_t, TupleT>::type
Chris@16 1070 eval(TupleT const& args) const
Chris@16 1071 {
Chris@16 1072 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 1073 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 1074 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 1075 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 1076 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 1077 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 1078 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 1079 typename actor_result<H, TupleT>::type rh = h.eval(args);
Chris@16 1080 typename actor_result<I, TupleT>::type ri = i.eval(args);
Chris@16 1081 typename actor_result<J, TupleT>::type rj = j.eval(args);
Chris@16 1082 typename actor_result<K, TupleT>::type rk = k.eval(args);
Chris@16 1083 typename actor_result<L, TupleT>::type rl = l.eval(args);
Chris@16 1084 typename actor_result<M, TupleT>::type rm = m.eval(args);
Chris@16 1085 return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm);
Chris@16 1086 }
Chris@16 1087
Chris@16 1088 mutable OperationT op; // operation
Chris@16 1089 A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
Chris@16 1090 K k; L l; M m; // actors
Chris@16 1091 };
Chris@16 1092
Chris@16 1093 ///////////////////////////////////////////////////////////////////////////////
Chris@16 1094 //
Chris@16 1095 // composite <14 actors> class
Chris@16 1096 //
Chris@16 1097 ///////////////////////////////////////////////////////////////////////////////
Chris@16 1098 template <typename OperationT, typename TupleT,
Chris@16 1099 typename A, typename B, typename C, typename D, typename E,
Chris@16 1100 typename F, typename G, typename H, typename I, typename J,
Chris@16 1101 typename K, typename L, typename M, typename N>
Chris@16 1102 struct composite14_result {
Chris@16 1103
Chris@16 1104 typedef typename OperationT::template result<
Chris@16 1105 typename actor_result<A, TupleT>::plain_type,
Chris@16 1106 typename actor_result<B, TupleT>::plain_type,
Chris@16 1107 typename actor_result<C, TupleT>::plain_type,
Chris@16 1108 typename actor_result<D, TupleT>::plain_type,
Chris@16 1109 typename actor_result<E, TupleT>::plain_type,
Chris@16 1110 typename actor_result<F, TupleT>::plain_type,
Chris@16 1111 typename actor_result<G, TupleT>::plain_type,
Chris@16 1112 typename actor_result<H, TupleT>::plain_type,
Chris@16 1113 typename actor_result<I, TupleT>::plain_type,
Chris@16 1114 typename actor_result<J, TupleT>::plain_type,
Chris@16 1115 typename actor_result<K, TupleT>::plain_type,
Chris@16 1116 typename actor_result<L, TupleT>::plain_type,
Chris@16 1117 typename actor_result<M, TupleT>::plain_type,
Chris@16 1118 typename actor_result<N, TupleT>::plain_type
Chris@16 1119 >::type type;
Chris@16 1120 };
Chris@16 1121
Chris@16 1122 //////////////////////////////////
Chris@16 1123 template <typename OperationT,
Chris@16 1124 typename A, typename B, typename C, typename D, typename E,
Chris@16 1125 typename F, typename G, typename H, typename I, typename J,
Chris@16 1126 typename K, typename L, typename M, typename N>
Chris@16 1127 struct composite<OperationT,
Chris@16 1128 A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t
Chris@16 1129 > {
Chris@16 1130
Chris@16 1131 typedef composite<OperationT,
Chris@16 1132 A, B, C, D, E, F, G, H, I, J, K, L, M, N> self_t;
Chris@16 1133
Chris@16 1134 template <typename TupleT>
Chris@16 1135 struct result {
Chris@16 1136
Chris@16 1137 typedef typename composite14_result<
Chris@16 1138 OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
Chris@16 1139 >::type type;
Chris@16 1140 };
Chris@16 1141
Chris@16 1142 composite(OperationT const& op_,
Chris@16 1143 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 1144 F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
Chris@16 1145 K const& k_, L const& l_, M const& m_, N const& n_)
Chris@16 1146 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 1147 f(f_), g(g_), h(h_), i(i_), j(j_),
Chris@16 1148 k(k_), l(l_), m(m_), n(n_) {}
Chris@16 1149
Chris@16 1150 template <typename TupleT>
Chris@16 1151 typename actor_result<self_t, TupleT>::type
Chris@16 1152 eval(TupleT const& args) const
Chris@16 1153 {
Chris@16 1154 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 1155 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 1156 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 1157 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 1158 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 1159 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 1160 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 1161 typename actor_result<H, TupleT>::type rh = h.eval(args);
Chris@16 1162 typename actor_result<I, TupleT>::type ri = i.eval(args);
Chris@16 1163 typename actor_result<J, TupleT>::type rj = j.eval(args);
Chris@16 1164 typename actor_result<K, TupleT>::type rk = k.eval(args);
Chris@16 1165 typename actor_result<L, TupleT>::type rl = l.eval(args);
Chris@16 1166 typename actor_result<M, TupleT>::type rm = m.eval(args);
Chris@16 1167 typename actor_result<N, TupleT>::type rn = n.eval(args);
Chris@16 1168 return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn);
Chris@16 1169 }
Chris@16 1170
Chris@16 1171 mutable OperationT op; // operation
Chris@16 1172 A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
Chris@16 1173 K k; L l; M m; N n; // actors
Chris@16 1174 };
Chris@16 1175
Chris@16 1176 ///////////////////////////////////////////////////////////////////////////////
Chris@16 1177 //
Chris@16 1178 // composite <15 actors> class
Chris@16 1179 //
Chris@16 1180 ///////////////////////////////////////////////////////////////////////////////
Chris@16 1181 template <typename OperationT, typename TupleT,
Chris@16 1182 typename A, typename B, typename C, typename D, typename E,
Chris@16 1183 typename F, typename G, typename H, typename I, typename J,
Chris@16 1184 typename K, typename L, typename M, typename N, typename O>
Chris@16 1185 struct composite15_result {
Chris@16 1186
Chris@16 1187 typedef typename OperationT::template result<
Chris@16 1188 typename actor_result<A, TupleT>::plain_type,
Chris@16 1189 typename actor_result<B, TupleT>::plain_type,
Chris@16 1190 typename actor_result<C, TupleT>::plain_type,
Chris@16 1191 typename actor_result<D, TupleT>::plain_type,
Chris@16 1192 typename actor_result<E, TupleT>::plain_type,
Chris@16 1193 typename actor_result<F, TupleT>::plain_type,
Chris@16 1194 typename actor_result<G, TupleT>::plain_type,
Chris@16 1195 typename actor_result<H, TupleT>::plain_type,
Chris@16 1196 typename actor_result<I, TupleT>::plain_type,
Chris@16 1197 typename actor_result<J, TupleT>::plain_type,
Chris@16 1198 typename actor_result<K, TupleT>::plain_type,
Chris@16 1199 typename actor_result<L, TupleT>::plain_type,
Chris@16 1200 typename actor_result<M, TupleT>::plain_type,
Chris@16 1201 typename actor_result<N, TupleT>::plain_type,
Chris@16 1202 typename actor_result<O, TupleT>::plain_type
Chris@16 1203 >::type type;
Chris@16 1204 };
Chris@16 1205
Chris@16 1206 //////////////////////////////////
Chris@16 1207 template <typename OperationT,
Chris@16 1208 typename A, typename B, typename C, typename D, typename E,
Chris@16 1209 typename F, typename G, typename H, typename I, typename J,
Chris@16 1210 typename K, typename L, typename M, typename N, typename O>
Chris@16 1211 struct composite<OperationT,
Chris@16 1212 A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t
Chris@16 1213 > {
Chris@16 1214
Chris@16 1215 typedef composite<OperationT,
Chris@16 1216 A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> self_t;
Chris@16 1217
Chris@16 1218 template <typename TupleT>
Chris@16 1219 struct result {
Chris@16 1220
Chris@16 1221 typedef typename composite15_result<
Chris@16 1222 OperationT, TupleT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
Chris@16 1223 >::type type;
Chris@16 1224 };
Chris@16 1225
Chris@16 1226 composite(OperationT const& op_,
Chris@16 1227 A const& a_, B const& b_, C const& c_, D const& d_, E const& e_,
Chris@16 1228 F const& f_, G const& g_, H const& h_, I const& i_, J const& j_,
Chris@16 1229 K const& k_, L const& l_, M const& m_, N const& n_, O const& o_)
Chris@16 1230 : op(op_), a(a_), b(b_), c(c_), d(d_), e(e_),
Chris@16 1231 f(f_), g(g_), h(h_), i(i_), j(j_),
Chris@16 1232 k(k_), l(l_), m(m_), n(n_), o(o_) {}
Chris@16 1233
Chris@16 1234 template <typename TupleT>
Chris@16 1235 typename actor_result<self_t, TupleT>::type
Chris@16 1236 eval(TupleT const& args) const
Chris@16 1237 {
Chris@16 1238 typename actor_result<A, TupleT>::type ra = a.eval(args);
Chris@16 1239 typename actor_result<B, TupleT>::type rb = b.eval(args);
Chris@16 1240 typename actor_result<C, TupleT>::type rc = c.eval(args);
Chris@16 1241 typename actor_result<D, TupleT>::type rd = d.eval(args);
Chris@16 1242 typename actor_result<E, TupleT>::type re = e.eval(args);
Chris@16 1243 typename actor_result<F, TupleT>::type rf = f.eval(args);
Chris@16 1244 typename actor_result<G, TupleT>::type rg = g.eval(args);
Chris@16 1245 typename actor_result<H, TupleT>::type rh = h.eval(args);
Chris@16 1246 typename actor_result<I, TupleT>::type ri = i.eval(args);
Chris@16 1247 typename actor_result<J, TupleT>::type rj = j.eval(args);
Chris@16 1248 typename actor_result<K, TupleT>::type rk = k.eval(args);
Chris@16 1249 typename actor_result<L, TupleT>::type rl = l.eval(args);
Chris@16 1250 typename actor_result<M, TupleT>::type rm = m.eval(args);
Chris@16 1251 typename actor_result<N, TupleT>::type rn = n.eval(args);
Chris@16 1252 typename actor_result<O, TupleT>::type ro = o.eval(args);
Chris@16 1253 return op(ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn, ro);
Chris@16 1254 }
Chris@16 1255
Chris@16 1256 mutable OperationT op; // operation
Chris@16 1257 A a; B b; C c; D d; E e; F f; G g; H h; I i; J j;
Chris@16 1258 K k; L l; M m; N n; O o; // actors
Chris@16 1259 };
Chris@16 1260
Chris@16 1261 #endif
Chris@16 1262 #endif
Chris@16 1263 #endif
Chris@16 1264 #endif
Chris@16 1265
Chris@16 1266 namespace impl {
Chris@16 1267
Chris@16 1268 ///////////////////////////////////////////////////////////////////////////
Chris@16 1269 //
Chris@16 1270 // make_composite is basically a type computer that answers the
Chris@16 1271 // question "Given types T0..TN, what composite type should I
Chris@16 1272 // create <composite_type> and if I were to generate an actual
Chris@16 1273 // composite, what type <type> should I return?"
Chris@16 1274 //
Chris@16 1275 ///////////////////////////////////////////////////////////////////////////
Chris@16 1276 template <
Chris@16 1277 typename OperationT
Chris@16 1278 , typename A = nil_t
Chris@16 1279 , typename B = nil_t
Chris@16 1280 , typename C = nil_t
Chris@16 1281
Chris@16 1282 #if PHOENIX_LIMIT > 3
Chris@16 1283 , typename D = nil_t
Chris@16 1284 , typename E = nil_t
Chris@16 1285 , typename F = nil_t
Chris@16 1286
Chris@16 1287 #if PHOENIX_LIMIT > 6
Chris@16 1288 , typename G = nil_t
Chris@16 1289 , typename H = nil_t
Chris@16 1290 , typename I = nil_t
Chris@16 1291
Chris@16 1292 #if PHOENIX_LIMIT > 9
Chris@16 1293 , typename J = nil_t
Chris@16 1294 , typename K = nil_t
Chris@16 1295 , typename L = nil_t
Chris@16 1296
Chris@16 1297 #if PHOENIX_LIMIT > 12
Chris@16 1298 , typename M = nil_t
Chris@16 1299 , typename N = nil_t
Chris@16 1300 , typename O = nil_t
Chris@16 1301
Chris@16 1302 #endif
Chris@16 1303 #endif
Chris@16 1304 #endif
Chris@16 1305 #endif
Chris@16 1306 >
Chris@16 1307 struct make_composite {
Chris@16 1308
Chris@16 1309 typedef composite<OperationT
Chris@16 1310 , typename as_actor<A>::type
Chris@16 1311 , typename as_actor<B>::type
Chris@16 1312 , typename as_actor<C>::type
Chris@16 1313
Chris@16 1314 #if PHOENIX_LIMIT > 3
Chris@16 1315 , typename as_actor<D>::type
Chris@16 1316 , typename as_actor<E>::type
Chris@16 1317 , typename as_actor<F>::type
Chris@16 1318
Chris@16 1319 #if PHOENIX_LIMIT > 6
Chris@16 1320 , typename as_actor<G>::type
Chris@16 1321 , typename as_actor<H>::type
Chris@16 1322 , typename as_actor<I>::type
Chris@16 1323
Chris@16 1324 #if PHOENIX_LIMIT > 9
Chris@16 1325 , typename as_actor<J>::type
Chris@16 1326 , typename as_actor<K>::type
Chris@16 1327 , typename as_actor<L>::type
Chris@16 1328
Chris@16 1329 #if PHOENIX_LIMIT > 12
Chris@16 1330 , typename as_actor<M>::type
Chris@16 1331 , typename as_actor<N>::type
Chris@16 1332 , typename as_actor<O>::type
Chris@16 1333
Chris@16 1334 #endif
Chris@16 1335 #endif
Chris@16 1336 #endif
Chris@16 1337 #endif
Chris@16 1338 > composite_type;
Chris@16 1339
Chris@16 1340 typedef actor<composite_type> type;
Chris@16 1341 };
Chris@16 1342
Chris@16 1343 ///////////////////////////////////////////////////////////////////////////
Chris@16 1344 //
Chris@16 1345 // make_unary, make_binary, make_binary1, make_binary2 and
Chris@16 1346 // make_binary3 utilities are provided here for easy creation of
Chris@16 1347 // unary and binary composites.
Chris@16 1348 //
Chris@16 1349 ///////////////////////////////////////////////////////////////////////////
Chris@16 1350
Chris@16 1351 ////////////////////////////////// input is an actor
Chris@16 1352 template <typename OperationT, typename BaseT>
Chris@16 1353 struct make_unary {
Chris@16 1354
Chris@16 1355 typedef typename make_composite
Chris@16 1356 <OperationT, actor<BaseT> >::type type;
Chris@16 1357
Chris@16 1358 static type
Chris@16 1359 construct(actor<BaseT> const& _0)
Chris@16 1360 {
Chris@16 1361 typedef typename make_composite
Chris@16 1362 <OperationT, actor<BaseT> >::composite_type
Chris@16 1363 ret_t;
Chris@16 1364
Chris@16 1365 return ret_t(OperationT(), _0);
Chris@16 1366 }
Chris@16 1367 };
Chris@16 1368
Chris@16 1369 ////////////////////////////////// LHS is an actor, RHS is unknown
Chris@16 1370 template <typename OperationT, typename BaseT, typename B>
Chris@16 1371 struct make_binary1 {
Chris@16 1372
Chris@16 1373 typedef typename make_composite
Chris@16 1374 <OperationT, actor<BaseT>, B>::type type;
Chris@16 1375
Chris@16 1376 static type
Chris@16 1377 construct(actor<BaseT> const& _0, B const& _1)
Chris@16 1378 {
Chris@16 1379 typedef typename make_composite
Chris@16 1380 <OperationT, actor<BaseT>, B>::composite_type
Chris@16 1381 ret_t;
Chris@16 1382
Chris@16 1383 return ret_t(OperationT(), _0, as_actor<B>::convert(_1));
Chris@16 1384 }
Chris@16 1385 };
Chris@16 1386
Chris@16 1387 ////////////////////////////////// LHS is unknown, RHS is an actor
Chris@16 1388 template <typename OperationT, typename A, typename BaseT>
Chris@16 1389 struct make_binary2 {
Chris@16 1390
Chris@16 1391 typedef typename make_composite
Chris@16 1392 <OperationT, A, actor<BaseT> >::type type;
Chris@16 1393
Chris@16 1394 static type
Chris@16 1395 construct(A const& _0, actor<BaseT> const& _1)
Chris@16 1396 {
Chris@16 1397 typedef typename make_composite
Chris@16 1398 <OperationT, A, actor<BaseT> >::composite_type
Chris@16 1399 ret_t;
Chris@16 1400
Chris@16 1401 return ret_t(OperationT(), as_actor<A>::convert(_0), _1);
Chris@16 1402 }
Chris@16 1403 };
Chris@16 1404
Chris@16 1405 ////////////////////////////////// Both LHS and RHS are actors
Chris@16 1406 template <typename OperationT, typename BaseA, typename BaseB>
Chris@16 1407 struct make_binary3 {
Chris@16 1408
Chris@16 1409 typedef typename make_composite
Chris@16 1410 <OperationT, actor<BaseA>, actor<BaseB> >::type type;
Chris@16 1411
Chris@16 1412 static type
Chris@16 1413 construct(actor<BaseA> const& _0, actor<BaseB> const& _1)
Chris@16 1414 {
Chris@16 1415 typedef typename make_composite
Chris@16 1416 <OperationT, actor<BaseA>, actor<BaseB> >::composite_type
Chris@16 1417 ret_t;
Chris@16 1418
Chris@16 1419 return ret_t(OperationT(), _0, _1);
Chris@16 1420 }
Chris@16 1421 };
Chris@16 1422
Chris@16 1423 } // namespace impl
Chris@16 1424
Chris@16 1425 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
Chris@16 1426 #pragma warning(pop)
Chris@16 1427 #endif
Chris@16 1428
Chris@16 1429 } // namespace phoenix
Chris@16 1430
Chris@16 1431 #endif