1 /*============================================================================= 2 Phoenix V1.2.1 3 Copyright (c) 2002 Joel de Guzman 4 Copyright (c) 2002-2003 Hartmut Kaiser 5 6 Distributed under the Boost Software License, Version 1.0. (See accompanying 7 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 8 ==============================================================================*/ 9 #ifndef BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLE_HELPERS_HPP 10 #define BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLE_HELPERS_HPP 11 12 /////////////////////////////////////////////////////////////////////////////// 13 #include <cassert> 14 #include <boost/spirit/home/classic/phoenix/tuples.hpp> 15 16 /////////////////////////////////////////////////////////////////////////////// 17 namespace phoenix 18 { 19 20 /////////////////////////////////////////////////////////////////////////////// 21 // 22 // make_tuple template class 23 // 24 // This template class is used to calculate a tuple type required to hold 25 // the given template parameter type 26 // 27 /////////////////////////////////////////////////////////////////////////////// 28 29 /////////////////////////////////////////////////////////////////////////////// 30 // normal (non-tuple types are wrapped into a tuple) 31 template <typename ResultT> 32 struct make_tuple { 33 34 typedef tuple<ResultT> type; 35 }; 36 37 /////////////////////////////////////////////////////////////////////////////// 38 // nil_t is converted to an empty tuple type 39 template <> 40 struct make_tuple<nil_t> { 41 42 typedef tuple<> type; 43 }; 44 45 /////////////////////////////////////////////////////////////////////////////// 46 // tuple types are left alone without any refactoring 47 template < 48 typename A, typename B, typename C 49 #if PHOENIX_LIMIT > 3 50 , typename D, typename E, typename F 51 #if PHOENIX_LIMIT > 6 52 , typename G, typename H, typename I 53 #if PHOENIX_LIMIT > 9 54 , typename J, typename K, typename L 55 #if PHOENIX_LIMIT > 12 56 , typename M, typename N, typename O 57 #endif 58 #endif 59 #endif 60 #endif 61 > 62 struct make_tuple<tuple<A, B, C 63 #if PHOENIX_LIMIT > 3 64 , D, E, F 65 #if PHOENIX_LIMIT > 6 66 , G, H, I 67 #if PHOENIX_LIMIT > 9 68 , J, K, L 69 #if PHOENIX_LIMIT > 12 70 , M, N, O 71 #endif 72 #endif 73 #endif 74 #endif 75 > > { 76 77 // the tuple parameter itself is the required tuple type 78 typedef tuple<A, B, C 79 #if PHOENIX_LIMIT > 3 80 , D, E, F 81 #if PHOENIX_LIMIT > 6 82 , G, H, I 83 #if PHOENIX_LIMIT > 9 84 , J, K, L 85 #if PHOENIX_LIMIT > 12 86 , M, N, O 87 #endif 88 #endif 89 #endif 90 #endif 91 > type; 92 }; 93 94 /////////////////////////////////////////////////////////////////////////////// 95 // 96 // concat_tuple type computer 97 // 98 // This class returns the type of a tuple, which is constructed by 99 // concatenating a tuple with a given type 100 // 101 /////////////////////////////////////////////////////////////////////////////// 102 template <typename TupleT, typename AppendT> 103 struct concat_tuple; 104 105 /////////////////////////////////////////////////////////////////////////////// 106 // 107 // concat tuple <0 member> class 108 // 109 /////////////////////////////////////////////////////////////////////////////// 110 template <typename AppendT> 111 struct concat_tuple<tuple<>, AppendT> { 112 113 typedef tuple<AppendT> type; 114 }; 115 116 template <> 117 struct concat_tuple<tuple<>, nil_t> { 118 119 typedef tuple<> type; 120 }; 121 122 /////////////////////////////////////////////////////////////////////////////// 123 // 124 // concat tuple <1 member> class 125 // 126 /////////////////////////////////////////////////////////////////////////////// 127 template <typename A, typename AppendT> 128 struct concat_tuple<tuple<A>, AppendT> { 129 130 typedef tuple<A, AppendT> type; 131 }; 132 133 template <typename A> 134 struct concat_tuple<tuple<A>, nil_t> { 135 136 typedef tuple<A> type; 137 }; 138 139 /////////////////////////////////////////////////////////////////////////////// 140 // 141 // concat tuple <2 member> class 142 // 143 /////////////////////////////////////////////////////////////////////////////// 144 template <typename A, typename B, typename AppendT> 145 struct concat_tuple<tuple<A, B>, AppendT> { 146 147 typedef tuple<A, B, AppendT> type; 148 }; 149 150 template <typename A, typename B> 151 struct concat_tuple<tuple<A, B>, nil_t> { 152 153 typedef tuple<A, B> type; 154 }; 155 156 #if PHOENIX_LIMIT > 3 157 /////////////////////////////////////////////////////////////////////////////// 158 // 159 // concat tuple <3 member> class 160 // 161 /////////////////////////////////////////////////////////////////////////////// 162 template < 163 typename A, typename B, typename C, 164 typename AppendT 165 > 166 struct concat_tuple<tuple<A, B, C>, AppendT> { 167 168 typedef tuple<A, B, C, AppendT> type; 169 }; 170 171 template < 172 typename A, typename B, typename C 173 > 174 struct concat_tuple<tuple<A, B, C>, nil_t> { 175 176 typedef tuple<A, B, C> type; 177 }; 178 179 /////////////////////////////////////////////////////////////////////////////// 180 // 181 // concat tuple <4 member> class 182 // 183 /////////////////////////////////////////////////////////////////////////////// 184 template < 185 typename A, typename B, typename C, typename D, 186 typename AppendT 187 > 188 struct concat_tuple<tuple<A, B, C, D>, AppendT> { 189 190 typedef tuple<A, B, C, D, AppendT> type; 191 }; 192 193 template < 194 typename A, typename B, typename C, typename D 195 > 196 struct concat_tuple<tuple<A, B, C, D>, nil_t> { 197 198 typedef tuple<A, B, C, D> type; 199 }; 200 201 /////////////////////////////////////////////////////////////////////////////// 202 // 203 // concat tuple <5 member> class 204 // 205 /////////////////////////////////////////////////////////////////////////////// 206 template < 207 typename A, typename B, typename C, typename D, typename E, 208 typename AppendT 209 > 210 struct concat_tuple<tuple<A, B, C, D, E>, AppendT> { 211 212 typedef tuple<A, B, C, D, E, AppendT> type; 213 }; 214 215 template < 216 typename A, typename B, typename C, typename D, typename E 217 > 218 struct concat_tuple<tuple<A, B, C, D, E>, nil_t> { 219 220 typedef tuple<A, B, C, D, E> type; 221 }; 222 223 #if PHOENIX_LIMIT > 6 224 /////////////////////////////////////////////////////////////////////////////// 225 // 226 // concat tuple <6 member> class 227 // 228 /////////////////////////////////////////////////////////////////////////////// 229 template < 230 typename A, typename B, typename C, typename D, typename E, typename F, 231 typename AppendT 232 > 233 struct concat_tuple<tuple<A, B, C, D, E, F>, AppendT> { 234 235 typedef tuple<A, B, C, D, E, F, AppendT> type; 236 }; 237 238 template < 239 typename A, typename B, typename C, typename D, typename E, typename F 240 > 241 struct concat_tuple<tuple<A, B, C, D, E, F>, nil_t> { 242 243 typedef tuple<A, B, C, D, E, F> type; 244 }; 245 246 /////////////////////////////////////////////////////////////////////////////// 247 // 248 // concat tuple <7 member> class 249 // 250 /////////////////////////////////////////////////////////////////////////////// 251 template < 252 typename A, typename B, typename C, typename D, typename E, typename F, 253 typename G, 254 typename AppendT 255 > 256 struct concat_tuple<tuple<A, B, C, D, E, F, G>, AppendT> { 257 258 typedef tuple<A, B, C, D, E, F, G, AppendT> type; 259 }; 260 261 template < 262 typename A, typename B, typename C, typename D, typename E, typename F, 263 typename G 264 > 265 struct concat_tuple<tuple<A, B, C, D, E, F, G>, nil_t> { 266 267 typedef tuple<A, B, C, D, E, F, G> type; 268 }; 269 270 /////////////////////////////////////////////////////////////////////////////// 271 // 272 // concat tuple <8 member> class 273 // 274 /////////////////////////////////////////////////////////////////////////////// 275 template < 276 typename A, typename B, typename C, typename D, typename E, typename F, 277 typename G, typename H, 278 typename AppendT 279 > 280 struct concat_tuple<tuple<A, B, C, D, E, F, G, H>, AppendT> { 281 282 typedef tuple<A, B, C, D, E, F, G, H, AppendT> type; 283 }; 284 285 template < 286 typename A, typename B, typename C, typename D, typename E, typename F, 287 typename G, typename H 288 > 289 struct concat_tuple<tuple<A, B, C, D, E, F, G, H>, nil_t> { 290 291 typedef tuple<A, B, C, D, E, F, G, H> type; 292 }; 293 294 #if PHOENIX_LIMIT > 9 295 /////////////////////////////////////////////////////////////////////////////// 296 // 297 // concat tuple <9 member> class 298 // 299 /////////////////////////////////////////////////////////////////////////////// 300 template < 301 typename A, typename B, typename C, typename D, typename E, typename F, 302 typename G, typename H, typename I, 303 typename AppendT 304 > 305 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I>, AppendT> { 306 307 typedef tuple<A, B, C, D, E, F, G, H, I, AppendT> type; 308 }; 309 310 template < 311 typename A, typename B, typename C, typename D, typename E, typename F, 312 typename G, typename H, typename I 313 > 314 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I>, nil_t> { 315 316 typedef tuple<A, B, C, D, E, F, G, H, I> type; 317 }; 318 319 /////////////////////////////////////////////////////////////////////////////// 320 // 321 // concat tuple <10 member> class 322 // 323 /////////////////////////////////////////////////////////////////////////////// 324 template < 325 typename A, typename B, typename C, typename D, typename E, typename F, 326 typename G, typename H, typename I, typename J, 327 typename AppendT 328 > 329 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J>, AppendT> { 330 331 typedef tuple<A, B, C, D, E, F, G, H, I, J, AppendT> type; 332 }; 333 334 template < 335 typename A, typename B, typename C, typename D, typename E, typename F, 336 typename G, typename H, typename I, typename J 337 > 338 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J>, nil_t> { 339 340 typedef tuple<A, B, C, D, E, F, G, H, I, J> type; 341 }; 342 343 /////////////////////////////////////////////////////////////////////////////// 344 // 345 // concat tuple <11 member> class 346 // 347 /////////////////////////////////////////////////////////////////////////////// 348 template < 349 typename A, typename B, typename C, typename D, typename E, typename F, 350 typename G, typename H, typename I, typename J, typename K, 351 typename AppendT 352 > 353 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K>, AppendT> { 354 355 typedef tuple<A, B, C, D, E, F, G, H, I, J, K, AppendT> type; 356 }; 357 358 template < 359 typename A, typename B, typename C, typename D, typename E, typename F, 360 typename G, typename H, typename I, typename J, typename K 361 > 362 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K>, nil_t> { 363 364 typedef tuple<A, B, C, D, E, F, G, H, I, J, K> type; 365 }; 366 367 #if PHOENIX_LIMIT > 12 368 /////////////////////////////////////////////////////////////////////////////// 369 // 370 // concat tuple <12 member> class 371 // 372 /////////////////////////////////////////////////////////////////////////////// 373 template < 374 typename A, typename B, typename C, typename D, typename E, typename F, 375 typename G, typename H, typename I, typename J, typename K, typename L, 376 typename AppendT 377 > 378 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L>, AppendT> { 379 380 typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, AppendT> type; 381 }; 382 383 template < 384 typename A, typename B, typename C, typename D, typename E, typename F, 385 typename G, typename H, typename I, typename J, typename K, typename L 386 > 387 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L>, nil_t> { 388 389 typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L> type; 390 }; 391 392 /////////////////////////////////////////////////////////////////////////////// 393 // 394 // concat tuple <13 member> class 395 // 396 /////////////////////////////////////////////////////////////////////////////// 397 template < 398 typename A, typename B, typename C, typename D, typename E, typename F, 399 typename G, typename H, typename I, typename J, typename K, typename L, 400 typename M, 401 typename AppendT 402 > 403 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M>, AppendT> { 404 405 typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, AppendT> type; 406 }; 407 408 template < 409 typename A, typename B, typename C, typename D, typename E, typename F, 410 typename G, typename H, typename I, typename J, typename K, typename L, 411 typename M 412 > 413 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M>, nil_t> { 414 415 typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M> type; 416 }; 417 418 /////////////////////////////////////////////////////////////////////////////// 419 // 420 // concat tuple <14 member> class 421 // 422 /////////////////////////////////////////////////////////////////////////////// 423 template < 424 typename A, typename B, typename C, typename D, typename E, typename F, 425 typename G, typename H, typename I, typename J, typename K, typename L, 426 typename M, typename N, 427 typename AppendT 428 > 429 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, AppendT> { 430 431 typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, AppendT> type; 432 }; 433 434 template < 435 typename A, typename B, typename C, typename D, typename E, typename F, 436 typename G, typename H, typename I, typename J, typename K, typename L, 437 typename M, typename N 438 > 439 struct concat_tuple<tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N>, nil_t> { 440 441 typedef tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N> type; 442 }; 443 444 #endif 445 #endif 446 #endif 447 #endif 448 449 /////////////////////////////////////////////////////////////////////////////// 450 // 451 // concat_tuples type computer 452 // 453 // This template class returns the type of a tuple built from the 454 // concatenation of two given tuples. 455 // 456 /////////////////////////////////////////////////////////////////////////////// 457 template <typename TupleT1, typename TupleT2, int N, typename AppendT> 458 struct concat_tuple_element { 459 460 typedef 461 typename concat_tuple_element< 462 typename concat_tuple<TupleT1, AppendT>::type, TupleT2, N+1, 463 typename tuple_element<N+1, TupleT2>::type 464 >::type 465 type; 466 }; 467 468 template <typename TupleT1, typename TupleT2, int N> 469 struct concat_tuple_element<TupleT1, TupleT2, N, nil_t> { 470 471 typedef TupleT1 type; 472 }; 473 474 template <typename TupleT1, typename TupleT2> 475 struct concat_tuples { 476 477 typedef 478 typename concat_tuple_element< 479 TupleT1, TupleT2, 0, 480 typename tuple_element<0, TupleT2>::type 481 >::type 482 type; 483 }; 484 485 /////////////////////////////////////////////////////////////////////////////// 486 // 487 // convert_actors template function 488 // 489 // The convert_actors template functions constructs a new tuple object 490 // composed of the elements returned by the actors contained in the 491 // input tuple. (i.e. the given tuple type 'actor_tuple' contains a set 492 // of actors to evaluate and the resulting tuple contains the results of 493 // evaluating the actors.) 494 // 495 /////////////////////////////////////////////////////////////////////////////// 496 template <typename ActorT, typename TupleT> 497 struct actor_result; // forward declaration 498 499 namespace impl 500 { 501 template <unsigned N> 502 struct convert_actors_ {}; 503 } 504 505 template <typename TupleResultT, typename ActorTupleT> 506 TupleResultT 507 convert_actors(ActorTupleT const& actor_tuple) 508 { 509 BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length); 510 BOOST_STATIC_CONSTANT(int, length = TupleResultT::length); 511 return impl::convert_actors_<length> 512 ::template apply<TupleResultT, ActorTupleT>::do_(actor_tuple); 513 } 514 515 namespace impl 516 { 517 template <int N, typename TupleResultT, typename ActorTupleT> 518 struct convert_actor 519 { 520 typedef typename tuple_element<N, TupleResultT>::type type; 521 522 template <bool C> 523 struct is_default_t {}; 524 typedef is_default_t<true> is_default; 525 typedef is_default_t<false> is_not_default; 526 527 static type actor_elementphoenix::impl::convert_actor528 actor_element(ActorTupleT const& /*actor_tuple*/, is_default) 529 { 530 return type(); // default construct 531 } 532 533 static type actor_elementphoenix::impl::convert_actor534 actor_element(ActorTupleT const& actor_tuple, is_not_default) 535 { 536 BOOST_STATIC_ASSERT(ActorTupleT::length <= TupleResultT::length); 537 return actor_tuple[tuple_index<N>()](); // apply the actor 538 } 539 540 static type do_phoenix::impl::convert_actor541 do_(ActorTupleT const& actor_tuple) 542 { 543 return actor_element( 544 actor_tuple, is_default_t<(N >= ActorTupleT::length)>()); 545 } 546 }; 547 548 /////////////////////////////////////// 549 template <> 550 struct convert_actors_<1> 551 { 552 template <typename TupleResultT, typename ActorTupleT> 553 struct apply 554 { 555 static TupleResultT do_phoenix::impl::convert_actors_::apply556 do_(ActorTupleT const& actor_tuple) 557 { 558 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 559 560 return TupleResultT( 561 converter0::do_(actor_tuple) 562 ); 563 } 564 }; 565 }; 566 567 /////////////////////////////////////// 568 template <> 569 struct convert_actors_<2> 570 { 571 template <typename TupleResultT, typename ActorTupleT> 572 struct apply 573 { 574 static TupleResultT do_phoenix::impl::convert_actors_::apply575 do_(ActorTupleT const& actor_tuple) 576 { 577 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 578 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 579 580 using namespace tuple_index_names; 581 return TupleResultT( 582 converter0::do_(actor_tuple) 583 , converter1::do_(actor_tuple) 584 ); 585 } 586 }; 587 }; 588 589 /////////////////////////////////////// 590 template <> 591 struct convert_actors_<3> 592 { 593 template <typename TupleResultT, typename ActorTupleT> 594 struct apply 595 { 596 static TupleResultT do_phoenix::impl::convert_actors_::apply597 do_(ActorTupleT const& actor_tuple) 598 { 599 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 600 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 601 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 602 603 using namespace tuple_index_names; 604 return TupleResultT( 605 converter0::do_(actor_tuple) 606 , converter1::do_(actor_tuple) 607 , converter2::do_(actor_tuple) 608 ); 609 } 610 }; 611 }; 612 613 #if PHOENIX_LIMIT > 3 614 615 ///////////////////////////////////// 616 template <> 617 struct convert_actors_<4> 618 { 619 template <typename TupleResultT, typename ActorTupleT> 620 struct apply 621 { 622 static TupleResultT do_phoenix::impl::convert_actors_::apply623 do_(ActorTupleT const& actor_tuple) 624 { 625 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 626 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 627 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 628 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 629 630 using namespace tuple_index_names; 631 return TupleResultT( 632 converter0::do_(actor_tuple) 633 , converter1::do_(actor_tuple) 634 , converter2::do_(actor_tuple) 635 , converter3::do_(actor_tuple) 636 ); 637 } 638 }; 639 }; 640 641 ///////////////////////////////////// 642 template <> 643 struct convert_actors_<5> 644 { 645 template <typename TupleResultT, typename ActorTupleT> 646 struct apply 647 { 648 static TupleResultT do_phoenix::impl::convert_actors_::apply649 do_(ActorTupleT const& actor_tuple) 650 { 651 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 652 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 653 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 654 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 655 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 656 657 using namespace tuple_index_names; 658 return TupleResultT( 659 converter0::do_(actor_tuple) 660 , converter1::do_(actor_tuple) 661 , converter2::do_(actor_tuple) 662 , converter3::do_(actor_tuple) 663 , converter4::do_(actor_tuple) 664 ); 665 } 666 }; 667 }; 668 669 ///////////////////////////////////// 670 template <> 671 struct convert_actors_<6> 672 { 673 template <typename TupleResultT, typename ActorTupleT> 674 struct apply 675 { 676 static TupleResultT do_phoenix::impl::convert_actors_::apply677 do_(ActorTupleT const& actor_tuple) 678 { 679 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 680 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 681 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 682 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 683 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 684 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 685 686 using namespace tuple_index_names; 687 return TupleResultT( 688 converter0::do_(actor_tuple) 689 , converter1::do_(actor_tuple) 690 , converter2::do_(actor_tuple) 691 , converter3::do_(actor_tuple) 692 , converter4::do_(actor_tuple) 693 , converter5::do_(actor_tuple) 694 ); 695 } 696 }; 697 }; 698 699 #if PHOENIX_LIMIT > 6 700 701 ///////////////////////////////////// 702 template <> 703 struct convert_actors_<7> 704 { 705 template <typename TupleResultT, typename ActorTupleT> 706 struct apply 707 { 708 static TupleResultT do_phoenix::impl::convert_actors_::apply709 do_(ActorTupleT const& actor_tuple) 710 { 711 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 712 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 713 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 714 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 715 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 716 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 717 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 718 719 using namespace tuple_index_names; 720 return TupleResultT( 721 converter0::do_(actor_tuple) 722 , converter1::do_(actor_tuple) 723 , converter2::do_(actor_tuple) 724 , converter3::do_(actor_tuple) 725 , converter4::do_(actor_tuple) 726 , converter5::do_(actor_tuple) 727 , converter6::do_(actor_tuple) 728 ); 729 } 730 }; 731 }; 732 733 ///////////////////////////////////// 734 template <> 735 struct convert_actors_<8> 736 { 737 template <typename TupleResultT, typename ActorTupleT> 738 struct apply 739 { 740 static TupleResultT do_phoenix::impl::convert_actors_::apply741 do_(ActorTupleT const& actor_tuple) 742 { 743 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 744 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 745 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 746 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 747 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 748 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 749 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 750 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; 751 752 using namespace tuple_index_names; 753 return TupleResultT( 754 converter0::do_(actor_tuple) 755 , converter1::do_(actor_tuple) 756 , converter2::do_(actor_tuple) 757 , converter3::do_(actor_tuple) 758 , converter4::do_(actor_tuple) 759 , converter5::do_(actor_tuple) 760 , converter6::do_(actor_tuple) 761 , converter7::do_(actor_tuple) 762 ); 763 } 764 }; 765 }; 766 767 ///////////////////////////////////// 768 template <> 769 struct convert_actors_<9> 770 { 771 template <typename TupleResultT, typename ActorTupleT> 772 struct apply 773 { 774 static TupleResultT do_phoenix::impl::convert_actors_::apply775 do_(ActorTupleT const& actor_tuple) 776 { 777 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 778 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 779 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 780 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 781 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 782 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 783 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 784 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; 785 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; 786 787 using namespace tuple_index_names; 788 return TupleResultT( 789 converter0::do_(actor_tuple) 790 , converter1::do_(actor_tuple) 791 , converter2::do_(actor_tuple) 792 , converter3::do_(actor_tuple) 793 , converter4::do_(actor_tuple) 794 , converter5::do_(actor_tuple) 795 , converter6::do_(actor_tuple) 796 , converter7::do_(actor_tuple) 797 , converter8::do_(actor_tuple) 798 ); 799 } 800 }; 801 }; 802 803 #if PHOENIX_LIMIT > 9 804 805 ///////////////////////////////////// 806 template <> 807 struct convert_actors_<10> 808 { 809 template <typename TupleResultT, typename ActorTupleT> 810 struct apply 811 { 812 static TupleResultT do_phoenix::impl::convert_actors_::apply813 do_(ActorTupleT const& actor_tuple) 814 { 815 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 816 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 817 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 818 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 819 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 820 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 821 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 822 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; 823 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; 824 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; 825 826 using namespace tuple_index_names; 827 return TupleResultT( 828 converter0::do_(actor_tuple) 829 , converter1::do_(actor_tuple) 830 , converter2::do_(actor_tuple) 831 , converter3::do_(actor_tuple) 832 , converter4::do_(actor_tuple) 833 , converter5::do_(actor_tuple) 834 , converter6::do_(actor_tuple) 835 , converter7::do_(actor_tuple) 836 , converter8::do_(actor_tuple) 837 , converter9::do_(actor_tuple) 838 ); 839 } 840 }; 841 }; 842 843 ///////////////////////////////////// 844 template <> 845 struct convert_actors_<11> 846 { 847 template <typename TupleResultT, typename ActorTupleT> 848 struct apply 849 { 850 static TupleResultT do_phoenix::impl::convert_actors_::apply851 do_(ActorTupleT const& actor_tuple) 852 { 853 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 854 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 855 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 856 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 857 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 858 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 859 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 860 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; 861 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; 862 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; 863 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; 864 865 using namespace tuple_index_names; 866 return TupleResultT( 867 converter0::do_(actor_tuple) 868 , converter1::do_(actor_tuple) 869 , converter2::do_(actor_tuple) 870 , converter3::do_(actor_tuple) 871 , converter4::do_(actor_tuple) 872 , converter5::do_(actor_tuple) 873 , converter6::do_(actor_tuple) 874 , converter7::do_(actor_tuple) 875 , converter8::do_(actor_tuple) 876 , converter9::do_(actor_tuple) 877 , converter10::do_(actor_tuple) 878 ); 879 } 880 }; 881 }; 882 883 ///////////////////////////////////// 884 template <> 885 struct convert_actors_<12> 886 { 887 template <typename TupleResultT, typename ActorTupleT> 888 struct apply 889 { 890 static TupleResultT do_phoenix::impl::convert_actors_::apply891 do_(ActorTupleT const& actor_tuple) 892 { 893 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 894 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 895 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 896 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 897 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 898 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 899 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 900 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; 901 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; 902 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; 903 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; 904 typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; 905 906 using namespace tuple_index_names; 907 return TupleResultT( 908 converter0::do_(actor_tuple) 909 , converter1::do_(actor_tuple) 910 , converter2::do_(actor_tuple) 911 , converter3::do_(actor_tuple) 912 , converter4::do_(actor_tuple) 913 , converter5::do_(actor_tuple) 914 , converter6::do_(actor_tuple) 915 , converter7::do_(actor_tuple) 916 , converter8::do_(actor_tuple) 917 , converter9::do_(actor_tuple) 918 , converter10::do_(actor_tuple) 919 , converter11::do_(actor_tuple) 920 ); 921 } 922 }; 923 }; 924 925 #if PHOENIX_LIMIT > 12 926 927 ///////////////////////////////////// 928 template <> 929 struct convert_actors_<13> 930 { 931 template <typename TupleResultT, typename ActorTupleT> 932 struct apply 933 { 934 static TupleResultT do_phoenix::impl::convert_actors_::apply935 do_(ActorTupleT const& actor_tuple) 936 { 937 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 938 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 939 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 940 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 941 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 942 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 943 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 944 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; 945 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; 946 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; 947 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; 948 typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; 949 typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; 950 951 using namespace tuple_index_names; 952 return TupleResultT( 953 converter0::do_(actor_tuple) 954 , converter1::do_(actor_tuple) 955 , converter2::do_(actor_tuple) 956 , converter3::do_(actor_tuple) 957 , converter4::do_(actor_tuple) 958 , converter5::do_(actor_tuple) 959 , converter6::do_(actor_tuple) 960 , converter7::do_(actor_tuple) 961 , converter8::do_(actor_tuple) 962 , converter9::do_(actor_tuple) 963 , converter10::do_(actor_tuple) 964 , converter11::do_(actor_tuple) 965 , converter12::do_(actor_tuple) 966 ); 967 } 968 }; 969 }; 970 971 /////////////////////////////////////// 972 template <> 973 struct convert_actors_<14> 974 { 975 template <typename TupleResultT, typename ActorTupleT> 976 struct apply 977 { 978 static TupleResultT do_phoenix::impl::convert_actors_::apply979 do_(ActorTupleT const& actor_tuple) 980 { 981 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 982 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 983 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 984 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 985 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 986 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 987 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 988 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; 989 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; 990 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; 991 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; 992 typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; 993 typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; 994 typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; 995 996 using namespace tuple_index_names; 997 return TupleResultT( 998 converter0::do_(actor_tuple) 999 , converter1::do_(actor_tuple) 1000 , converter2::do_(actor_tuple) 1001 , converter3::do_(actor_tuple) 1002 , converter4::do_(actor_tuple) 1003 , converter5::do_(actor_tuple) 1004 , converter6::do_(actor_tuple) 1005 , converter7::do_(actor_tuple) 1006 , converter8::do_(actor_tuple) 1007 , converter9::do_(actor_tuple) 1008 , converter10::do_(actor_tuple) 1009 , converter11::do_(actor_tuple) 1010 , converter12::do_(actor_tuple) 1011 , converter13::do_(actor_tuple) 1012 ); 1013 } 1014 }; 1015 }; 1016 1017 /////////////////////////////////////// 1018 template <> 1019 struct convert_actors_<15> 1020 { 1021 template <typename TupleResultT, typename ActorTupleT> 1022 struct apply 1023 { 1024 static TupleResultT do_phoenix::impl::convert_actors_::apply1025 do_(ActorTupleT const& actor_tuple) 1026 { 1027 typedef impl::convert_actor<0, TupleResultT, ActorTupleT> converter0; 1028 typedef impl::convert_actor<1, TupleResultT, ActorTupleT> converter1; 1029 typedef impl::convert_actor<2, TupleResultT, ActorTupleT> converter2; 1030 typedef impl::convert_actor<3, TupleResultT, ActorTupleT> converter3; 1031 typedef impl::convert_actor<4, TupleResultT, ActorTupleT> converter4; 1032 typedef impl::convert_actor<5, TupleResultT, ActorTupleT> converter5; 1033 typedef impl::convert_actor<6, TupleResultT, ActorTupleT> converter6; 1034 typedef impl::convert_actor<7, TupleResultT, ActorTupleT> converter7; 1035 typedef impl::convert_actor<8, TupleResultT, ActorTupleT> converter8; 1036 typedef impl::convert_actor<9, TupleResultT, ActorTupleT> converter9; 1037 typedef impl::convert_actor<10, TupleResultT, ActorTupleT> converter10; 1038 typedef impl::convert_actor<11, TupleResultT, ActorTupleT> converter11; 1039 typedef impl::convert_actor<12, TupleResultT, ActorTupleT> converter12; 1040 typedef impl::convert_actor<13, TupleResultT, ActorTupleT> converter13; 1041 typedef impl::convert_actor<14, TupleResultT, ActorTupleT> converter14; 1042 1043 using namespace tuple_index_names; 1044 return TupleResultT( 1045 converter0::do_(actor_tuple) 1046 , converter1::do_(actor_tuple) 1047 , converter2::do_(actor_tuple) 1048 , converter3::do_(actor_tuple) 1049 , converter4::do_(actor_tuple) 1050 , converter5::do_(actor_tuple) 1051 , converter6::do_(actor_tuple) 1052 , converter7::do_(actor_tuple) 1053 , converter8::do_(actor_tuple) 1054 , converter9::do_(actor_tuple) 1055 , converter10::do_(actor_tuple) 1056 , converter11::do_(actor_tuple) 1057 , converter12::do_(actor_tuple) 1058 , converter13::do_(actor_tuple) 1059 , converter14::do_(actor_tuple) 1060 ); 1061 } 1062 }; 1063 }; 1064 1065 #endif 1066 #endif 1067 #endif 1068 #endif 1069 } // namespace impl 1070 1071 1072 /////////////////////////////////////////////////////////////////////////////// 1073 } // namespace phoenix 1074 1075 #endif 1076