Mercurial > hg > vamp-build-and-test

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