ceph/src/boost/boost/spirit/home/classic/phoenix/tuple_helpers.hpp

   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 PHOENIX_TUPLEHELPERS_HPP
  10 #define PHOENIX_TUPLEHELPERS_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
 528         actor_element(ActorTupleT const& /*actor_tuple*/, is_default)
 529         {
 530             return type(); // default construct
 531         }
 532
 533         static type
 534         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
 541         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
 556             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
 575             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
 597             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
 623             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
 649             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
 677             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
 709             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
 741             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
 775             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
 813             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
 851             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
 891             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
 935             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
 979             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
1025             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 // PHOENIX_TUPLEHELPERS_HPP