1 /*============================================================================= 2 Phoenix V1.2.1 3 Copyright (c) 2001-2002 Joel de Guzman 4 5 Distributed under the Boost Software License, Version 1.0. (See accompanying 6 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 7 ==============================================================================*/ 8 #ifndef BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLES_HPP 9 #define BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLES_HPP 10 11 /////////////////////////////////////////////////////////////////////////////// 12 // 13 // Phoenix predefined maximum limit. This limit defines the maximum 14 // number of elements a tuple can hold. This number defaults to 3. The 15 // actual maximum is rounded up in multiples of 3. Thus, if this value 16 // is 4, the actual limit is 6. The ultimate maximum limit in this 17 // implementation is 15. 18 // 19 /////////////////////////////////////////////////////////////////////////////// 20 #ifndef PHOENIX_LIMIT 21 #define PHOENIX_LIMIT 3 22 #endif 23 24 /////////////////////////////////////////////////////////////////////////////// 25 #include <boost/static_assert.hpp> 26 #include <boost/call_traits.hpp> 27 #include <boost/type_traits/remove_reference.hpp> 28 29 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) 30 #pragma warning(push) 31 #pragma warning(disable:4512) //assignment operator could not be generated 32 #endif 33 34 /////////////////////////////////////////////////////////////////////////////// 35 namespace phoenix { 36 37 /////////////////////////////////////////////////////////////////////////////// 38 // 39 // tuple 40 // 41 // Tuples hold heterogeneous types up to a predefined maximum. Only 42 // the most basic functionality needed is provided. Unlike other 43 // recursive list-like tuple implementations, this tuple 44 // implementation uses simple structs similar to std::pair with 45 // specialization for 0 to N tuple elements. 46 // 47 // 1) Construction 48 // Here are examples on how to construct tuples: 49 // 50 // typedef tuple<int, char> t1_t; 51 // typedef tuple<int, std::string, double> t2_t; 52 // 53 // // this tuple has an int and char members 54 // t1_t t1(3, 'c'); 55 // 56 // // this tuple has an int, std::string and double members 57 // t2_t t2(3, "hello", 3.14); 58 // 59 // Tuples can also be constructed from other tuples. The 60 // source and destination tuples need not have exactly the 61 // same element types. The only requirement is that the 62 // source tuple have the same number of elements as the 63 // destination and that each element slot in the 64 // destination can be copy constructed from the source 65 // element. For example: 66 // 67 // tuple<double, double> t3(t1); // OK. Compatible tuples 68 // tuple<double, double> t4(t2); // Error! Incompatible tuples 69 // 70 // 2) Member access 71 // A member in a tuple can be accessed using the 72 // tuple's [] operator by specifying the Nth 73 // tuple_index. Here are some examples: 74 // 75 // tuple_index<0> ix0; // 0th index == 1st item 76 // tuple_index<1> ix1; // 1st index == 2nd item 77 // tuple_index<2> ix2; // 2nd index == 3rd item 78 // 79 // t1[ix0] = 33; // sets the int member of the tuple t1 80 // t2[ix2] = 6e6; // sets the double member of the tuple t2 81 // t1[ix1] = 'a'; // sets the char member of the tuple t1 82 // 83 // There are some predefined names are provided in sub- 84 // namespace tuple_index_names: 85 // 86 // tuple_index<0> _1; 87 // tuple_index<1> _2; 88 // ... 89 // tuple_index<N> _N; 90 // 91 // These indexes may be used by 'using' namespace 92 // phoenix::tuple_index_names. 93 // 94 // Access to out of bound indexes returns a nil_t value. 95 // 96 // 3) Member type inquiry 97 // The type of an individual member can be queried. 98 // Example: 99 // 100 // tuple_element<1, t2_t>::type 101 // 102 // Refers to the type of the second member (note zero based, 103 // thus 0 = 1st item, 1 = 2nd item) of the tuple. 104 // 105 // Aside from tuple_element<N, T>::type, there are two 106 // more types that tuple_element provides: rtype and 107 // crtype. While 'type' is the plain underlying type, 108 // 'rtype' is the reference type, or type& and 'crtype' 109 // is the constant reference type or type const&. The 110 // latter two are provided to make it easy for the 111 // client in dealing with the possibility of reference 112 // to reference when type is already a reference, which 113 // is illegal in C++. 114 // 115 // Access to out of bound indexes returns a nil_t type. 116 // 117 // 4) Tuple length 118 // The number of elements in a tuple can be queried. 119 // Example: 120 // 121 // int n = t1.length; 122 // 123 // gets the number of elements in tuple t1. 124 // 125 // length is a static constant. Thus, TupleT::length 126 // also works. Example: 127 // 128 // int n = t1_t::length; 129 // 130 /////////////////////////////////////////////////////////////////////////////// 131 struct nil_t {}; 132 using boost::remove_reference; 133 using boost::call_traits; 134 135 ////////////////////////////////// 136 namespace impl { 137 138 template <typename T> 139 struct access { 140 141 typedef const T& ctype; 142 typedef T& type; 143 }; 144 145 template <typename T> 146 struct access<T&> { 147 148 typedef T& ctype; 149 typedef T& type; 150 }; 151 } 152 153 /////////////////////////////////////////////////////////////////////////////// 154 // 155 // tuple_element 156 // 157 // A query class that gets the Nth element inside a tuple. 158 // Examples: 159 // 160 // tuple_element<1, tuple<int, char, void*> >::type // plain 161 // tuple_element<1, tuple<int, char, void*> >::rtype // ref 162 // tuple_element<1, tuple<int, char, void*> >::crtype // const ref 163 // 164 // Has type char which is the 2nd type in the tuple 165 // (note zero based, thus 0 = 1st item, 1 = 2nd item). 166 // 167 // Given a tuple object, the static function tuple_element<N, 168 // TupleT>::get(tuple) gets the Nth element in the tuple. The 169 // tuple class' tuple::operator[] uses this to get its Nth 170 // element. 171 // 172 /////////////////////////////////////////////////////////////////////////////// 173 template <int N, typename TupleT> 174 struct tuple_element 175 { 176 typedef nil_t type; 177 typedef nil_t& rtype; 178 typedef nil_t const& crtype; 179 getphoenix::tuple_element180 static nil_t get(TupleT const&) { return nil_t(); } 181 }; 182 183 ////////////////////////////////// 184 template <typename TupleT> 185 struct tuple_element<0, TupleT> 186 { 187 typedef typename TupleT::a_type type; 188 typedef typename impl::access<type>::type rtype; 189 typedef typename impl::access<type>::ctype crtype; 190 getphoenix::tuple_element191 static rtype get(TupleT& t) { return t.a; } getphoenix::tuple_element192 static crtype get(TupleT const& t) { return t.a; } 193 }; 194 195 ////////////////////////////////// 196 template <typename TupleT> 197 struct tuple_element<1, TupleT> 198 { 199 typedef typename TupleT::b_type type; 200 typedef typename impl::access<type>::type rtype; 201 typedef typename impl::access<type>::ctype crtype; 202 getphoenix::tuple_element203 static rtype get(TupleT& t) { return t.b; } getphoenix::tuple_element204 static crtype get(TupleT const& t) { return t.b; } 205 }; 206 207 ////////////////////////////////// 208 template <typename TupleT> 209 struct tuple_element<2, TupleT> 210 { 211 typedef typename TupleT::c_type type; 212 typedef typename impl::access<type>::type rtype; 213 typedef typename impl::access<type>::ctype crtype; 214 getphoenix::tuple_element215 static rtype get(TupleT& t) { return t.c; } getphoenix::tuple_element216 static crtype get(TupleT const& t) { return t.c; } 217 }; 218 219 #if PHOENIX_LIMIT > 3 220 ////////////////////////////////// 221 template <typename TupleT> 222 struct tuple_element<3, TupleT> 223 { 224 typedef typename TupleT::d_type type; 225 typedef typename impl::access<type>::type rtype; 226 typedef typename impl::access<type>::ctype crtype; 227 getphoenix::tuple_element228 static rtype get(TupleT& t) { return t.d; } getphoenix::tuple_element229 static crtype get(TupleT const& t) { return t.d; } 230 }; 231 232 ////////////////////////////////// 233 template <typename TupleT> 234 struct tuple_element<4, TupleT> 235 { 236 typedef typename TupleT::e_type type; 237 typedef typename impl::access<type>::type rtype; 238 typedef typename impl::access<type>::ctype crtype; 239 getphoenix::tuple_element240 static rtype get(TupleT& t) { return t.e; } getphoenix::tuple_element241 static crtype get(TupleT const& t) { return t.e; } 242 }; 243 244 ////////////////////////////////// 245 template <typename TupleT> 246 struct tuple_element<5, TupleT> 247 { 248 typedef typename TupleT::f_type type; 249 typedef typename impl::access<type>::type rtype; 250 typedef typename impl::access<type>::ctype crtype; 251 getphoenix::tuple_element252 static rtype get(TupleT& t) { return t.f; } getphoenix::tuple_element253 static crtype get(TupleT const& t) { return t.f; } 254 }; 255 256 #if PHOENIX_LIMIT > 6 257 ////////////////////////////////// 258 template <typename TupleT> 259 struct tuple_element<6, TupleT> 260 { 261 typedef typename TupleT::g_type type; 262 typedef typename impl::access<type>::type rtype; 263 typedef typename impl::access<type>::ctype crtype; 264 getphoenix::tuple_element265 static rtype get(TupleT& t) { return t.g; } getphoenix::tuple_element266 static crtype get(TupleT const& t) { return t.g; } 267 }; 268 269 ////////////////////////////////// 270 template <typename TupleT> 271 struct tuple_element<7, TupleT> 272 { 273 typedef typename TupleT::h_type type; 274 typedef typename impl::access<type>::type rtype; 275 typedef typename impl::access<type>::ctype crtype; 276 getphoenix::tuple_element277 static rtype get(TupleT& t) { return t.h; } getphoenix::tuple_element278 static crtype get(TupleT const& t) { return t.h; } 279 }; 280 281 ////////////////////////////////// 282 template <typename TupleT> 283 struct tuple_element<8, TupleT> 284 { 285 typedef typename TupleT::i_type type; 286 typedef typename impl::access<type>::type rtype; 287 typedef typename impl::access<type>::ctype crtype; 288 getphoenix::tuple_element289 static rtype get(TupleT& t) { return t.i; } getphoenix::tuple_element290 static crtype get(TupleT const& t) { return t.i; } 291 }; 292 293 #if PHOENIX_LIMIT > 9 294 ////////////////////////////////// 295 template <typename TupleT> 296 struct tuple_element<9, TupleT> 297 { 298 typedef typename TupleT::j_type type; 299 typedef typename impl::access<type>::type rtype; 300 typedef typename impl::access<type>::ctype crtype; 301 getphoenix::tuple_element302 static rtype get(TupleT& t) { return t.j; } getphoenix::tuple_element303 static crtype get(TupleT const& t) { return t.j; } 304 }; 305 306 ////////////////////////////////// 307 template <typename TupleT> 308 struct tuple_element<10, TupleT> 309 { 310 typedef typename TupleT::k_type type; 311 typedef typename impl::access<type>::type rtype; 312 typedef typename impl::access<type>::ctype crtype; 313 getphoenix::tuple_element314 static rtype get(TupleT& t) { return t.k; } getphoenix::tuple_element315 static crtype get(TupleT const& t) { return t.k; } 316 }; 317 318 ////////////////////////////////// 319 template <typename TupleT> 320 struct tuple_element<11, TupleT> 321 { 322 typedef typename TupleT::l_type type; 323 typedef typename impl::access<type>::type rtype; 324 typedef typename impl::access<type>::ctype crtype; 325 getphoenix::tuple_element326 static rtype get(TupleT& t) { return t.l; } getphoenix::tuple_element327 static crtype get(TupleT const& t) { return t.l; } 328 }; 329 330 #if PHOENIX_LIMIT > 12 331 ////////////////////////////////// 332 template <typename TupleT> 333 struct tuple_element<12, TupleT> 334 { 335 typedef typename TupleT::m_type type; 336 typedef typename impl::access<type>::type rtype; 337 typedef typename impl::access<type>::ctype crtype; 338 getphoenix::tuple_element339 static rtype get(TupleT& t) { return t.m; } getphoenix::tuple_element340 static crtype get(TupleT const& t) { return t.m; } 341 }; 342 343 ////////////////////////////////// 344 template <typename TupleT> 345 struct tuple_element<13, TupleT> 346 { 347 typedef typename TupleT::n_type type; 348 typedef typename impl::access<type>::type rtype; 349 typedef typename impl::access<type>::ctype crtype; 350 getphoenix::tuple_element351 static rtype get(TupleT& t) { return t.n; } getphoenix::tuple_element352 static crtype get(TupleT const& t) { return t.n; } 353 }; 354 355 ////////////////////////////////// 356 template <typename TupleT> 357 struct tuple_element<14, TupleT> 358 { 359 typedef typename TupleT::o_type type; 360 typedef typename impl::access<type>::type rtype; 361 typedef typename impl::access<type>::ctype crtype; 362 getphoenix::tuple_element363 static rtype get(TupleT& t) { return t.o; } getphoenix::tuple_element364 static crtype get(TupleT const& t) { return t.o; } 365 }; 366 367 #endif 368 #endif 369 #endif 370 #endif 371 372 /////////////////////////////////////////////////////////////////////////////// 373 // 374 // tuple forward declaration. 375 // 376 /////////////////////////////////////////////////////////////////////////////// 377 template < 378 typename A = nil_t 379 , typename B = nil_t 380 , typename C = nil_t 381 382 #if PHOENIX_LIMIT > 3 383 , typename D = nil_t 384 , typename E = nil_t 385 , typename F = nil_t 386 387 #if PHOENIX_LIMIT > 6 388 , typename G = nil_t 389 , typename H = nil_t 390 , typename I = nil_t 391 392 #if PHOENIX_LIMIT > 9 393 , typename J = nil_t 394 , typename K = nil_t 395 , typename L = nil_t 396 397 #if PHOENIX_LIMIT > 12 398 , typename M = nil_t 399 , typename N = nil_t 400 , typename O = nil_t 401 402 #endif 403 #endif 404 #endif 405 #endif 406 407 , typename NU = nil_t // Not used 408 > 409 struct tuple; 410 411 /////////////////////////////////////////////////////////////////////////////// 412 // 413 // tuple_index 414 // 415 // This class wraps an integer in a type to be used for indexing 416 // the Nth element in a tuple. See tuple operator[]. Some 417 // predefined names are provided in sub-namespace 418 // tuple_index_names. 419 // 420 /////////////////////////////////////////////////////////////////////////////// 421 template <int N> 422 struct tuple_index {}; 423 424 ////////////////////////////////// 425 namespace tuple_index_names { 426 427 tuple_index<0> const _1 = tuple_index<0>(); 428 tuple_index<1> const _2 = tuple_index<1>(); 429 tuple_index<2> const _3 = tuple_index<2>(); 430 431 #if PHOENIX_LIMIT > 3 432 tuple_index<3> const _4 = tuple_index<3>(); 433 tuple_index<4> const _5 = tuple_index<4>(); 434 tuple_index<5> const _6 = tuple_index<5>(); 435 436 #if PHOENIX_LIMIT > 6 437 tuple_index<6> const _7 = tuple_index<6>(); 438 tuple_index<7> const _8 = tuple_index<7>(); 439 tuple_index<8> const _9 = tuple_index<8>(); 440 441 #if PHOENIX_LIMIT > 9 442 tuple_index<9> const _10 = tuple_index<9>(); 443 tuple_index<10> const _11 = tuple_index<10>(); 444 tuple_index<11> const _12 = tuple_index<11>(); 445 446 #if PHOENIX_LIMIT > 12 447 tuple_index<12> const _13 = tuple_index<12>(); 448 tuple_index<13> const _14 = tuple_index<13>(); 449 tuple_index<14> const _15 = tuple_index<14>(); 450 451 #endif 452 #endif 453 #endif 454 #endif 455 } 456 457 /////////////////////////////////////////////////////////////////////////////// 458 // 459 // tuple_common class 460 // 461 /////////////////////////////////////////////////////////////////////////////// 462 template <typename DerivedT> 463 struct tuple_base { 464 465 typedef nil_t a_type; 466 typedef nil_t b_type; 467 typedef nil_t c_type; 468 469 #if PHOENIX_LIMIT > 3 470 typedef nil_t d_type; 471 typedef nil_t e_type; 472 typedef nil_t f_type; 473 474 #if PHOENIX_LIMIT > 6 475 typedef nil_t g_type; 476 typedef nil_t h_type; 477 typedef nil_t i_type; 478 479 #if PHOENIX_LIMIT > 9 480 typedef nil_t j_type; 481 typedef nil_t k_type; 482 typedef nil_t l_type; 483 484 #if PHOENIX_LIMIT > 12 485 typedef nil_t m_type; 486 typedef nil_t n_type; 487 typedef nil_t o_type; 488 489 #endif 490 #endif 491 #endif 492 #endif 493 494 template <int N> 495 typename tuple_element<N, DerivedT>::crtype operator []phoenix::tuple_base496 operator[](tuple_index<N>) const 497 { 498 return tuple_element<N, DerivedT> 499 ::get(*static_cast<DerivedT const*>(this)); 500 } 501 502 template <int N> 503 typename tuple_element<N, DerivedT>::rtype operator []phoenix::tuple_base504 operator[](tuple_index<N>) 505 { 506 return tuple_element<N, DerivedT> 507 ::get(*static_cast<DerivedT*>(this)); 508 } 509 }; 510 511 /////////////////////////////////////////////////////////////////////////////// 512 // 513 // tuple <0 member> class 514 // 515 /////////////////////////////////////////////////////////////////////////////// 516 template <> 517 struct tuple<> 518 : public tuple_base<tuple<> > { 519 520 BOOST_STATIC_CONSTANT(int, length = 0); 521 }; 522 523 /////////////////////////////////////////////////////////////////////////////// 524 // 525 // tuple <1 member> class 526 // 527 /////////////////////////////////////////////////////////////////////////////// 528 template <typename A> 529 struct tuple<A, nil_t, nil_t, 530 #if PHOENIX_LIMIT > 3 531 nil_t, nil_t, nil_t, 532 #if PHOENIX_LIMIT > 6 533 nil_t, nil_t, nil_t, 534 #if PHOENIX_LIMIT > 9 535 nil_t, nil_t, nil_t, 536 #if PHOENIX_LIMIT > 12 537 nil_t, nil_t, nil_t, 538 #endif 539 #endif 540 #endif 541 #endif 542 nil_t // Unused 543 > 544 : public tuple_base<tuple<A> > { 545 546 BOOST_STATIC_CONSTANT(int, length = 1); 547 typedef A a_type; 548 tuplephoenix::tuple549 tuple() {} 550 tuplephoenix::tuple551 tuple( 552 typename call_traits<A>::param_type a_ 553 ): a(a_) {} 554 555 template <typename TupleT> tuplephoenix::tuple556 tuple(TupleT const& init) 557 : a(init[tuple_index<0>()]) 558 { BOOST_STATIC_ASSERT(TupleT::length == length); } 559 560 A a; 561 }; 562 563 /////////////////////////////////////////////////////////////////////////////// 564 // 565 // tuple <2 member> class 566 // 567 /////////////////////////////////////////////////////////////////////////////// 568 template <typename A, typename B> 569 struct tuple<A, B, nil_t, 570 #if PHOENIX_LIMIT > 3 571 nil_t, nil_t, nil_t, 572 #if PHOENIX_LIMIT > 6 573 nil_t, nil_t, nil_t, 574 #if PHOENIX_LIMIT > 9 575 nil_t, nil_t, nil_t, 576 #if PHOENIX_LIMIT > 12 577 nil_t, nil_t, nil_t, 578 #endif 579 #endif 580 #endif 581 #endif 582 nil_t // Unused 583 > 584 : public tuple_base<tuple<A, B> > { 585 586 BOOST_STATIC_CONSTANT(int, length = 2); 587 typedef A a_type; typedef B b_type; 588 tuplephoenix::tuple589 tuple() {} 590 tuplephoenix::tuple591 tuple( 592 typename call_traits<A>::param_type a_, 593 typename call_traits<B>::param_type b_ 594 ): a(a_), b(b_) {} 595 596 template <typename TupleT> tuplephoenix::tuple597 tuple(TupleT const& init) 598 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]) 599 { BOOST_STATIC_ASSERT(TupleT::length == length); } 600 601 A a; B b; 602 }; 603 604 /////////////////////////////////////////////////////////////////////////////// 605 // 606 // tuple <3 member> class 607 // 608 /////////////////////////////////////////////////////////////////////////////// 609 template <typename A, typename B, typename C> 610 struct tuple<A, B, C, 611 #if PHOENIX_LIMIT > 3 612 nil_t, nil_t, nil_t, 613 #if PHOENIX_LIMIT > 6 614 nil_t, nil_t, nil_t, 615 #if PHOENIX_LIMIT > 9 616 nil_t, nil_t, nil_t, 617 #if PHOENIX_LIMIT > 12 618 nil_t, nil_t, nil_t, 619 #endif 620 #endif 621 #endif 622 #endif 623 nil_t // Unused 624 > 625 : public tuple_base<tuple<A, B, C> > { 626 627 BOOST_STATIC_CONSTANT(int, length = 3); 628 typedef A a_type; typedef B b_type; 629 typedef C c_type; 630 tuplephoenix::tuple631 tuple() {} 632 tuplephoenix::tuple633 tuple( 634 typename call_traits<A>::param_type a_, 635 typename call_traits<B>::param_type b_, 636 typename call_traits<C>::param_type c_ 637 ): a(a_), b(b_), c(c_) {} 638 639 template <typename TupleT> tuplephoenix::tuple640 tuple(TupleT const& init) 641 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 642 c(init[tuple_index<2>()]) 643 { BOOST_STATIC_ASSERT(TupleT::length == length); } 644 645 A a; B b; C c; 646 }; 647 648 #if PHOENIX_LIMIT > 3 649 /////////////////////////////////////////////////////////////////////////////// 650 // 651 // tuple <4 member> class 652 // 653 /////////////////////////////////////////////////////////////////////////////// 654 template <typename A, typename B, typename C, typename D> 655 struct tuple<A, B, C, D, nil_t, nil_t, 656 #if PHOENIX_LIMIT > 6 657 nil_t, nil_t, nil_t, 658 #if PHOENIX_LIMIT > 9 659 nil_t, nil_t, nil_t, 660 #if PHOENIX_LIMIT > 12 661 nil_t, nil_t, nil_t, 662 #endif 663 #endif 664 #endif 665 nil_t // Unused 666 > 667 : public tuple_base<tuple<A, B, C, D> > { 668 669 BOOST_STATIC_CONSTANT(int, length = 4); 670 typedef A a_type; typedef B b_type; 671 typedef C c_type; typedef D d_type; 672 tuplephoenix::tuple673 tuple() {} 674 tuplephoenix::tuple675 tuple( 676 typename call_traits<A>::param_type a_, 677 typename call_traits<B>::param_type b_, 678 typename call_traits<C>::param_type c_, 679 typename call_traits<D>::param_type d_ 680 ): a(a_), b(b_), c(c_), d(d_) {} 681 682 template <typename TupleT> tuplephoenix::tuple683 tuple(TupleT const& init) 684 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 685 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]) 686 { BOOST_STATIC_ASSERT(TupleT::length == length); } 687 688 A a; B b; C c; D d; 689 }; 690 691 /////////////////////////////////////////////////////////////////////////////// 692 // 693 // tuple <5 member> class 694 // 695 /////////////////////////////////////////////////////////////////////////////// 696 template <typename A, typename B, typename C, typename D, typename E> 697 struct tuple<A, B, C, D, E, nil_t, 698 #if PHOENIX_LIMIT > 6 699 nil_t, nil_t, nil_t, 700 #if PHOENIX_LIMIT > 9 701 nil_t, nil_t, nil_t, 702 #if PHOENIX_LIMIT > 12 703 nil_t, nil_t, nil_t, 704 #endif 705 #endif 706 #endif 707 nil_t // Unused 708 > 709 : public tuple_base<tuple<A, B, C, D, E> > { 710 711 BOOST_STATIC_CONSTANT(int, length = 5); 712 typedef A a_type; typedef B b_type; 713 typedef C c_type; typedef D d_type; 714 typedef E e_type; 715 tuplephoenix::tuple716 tuple() {} 717 tuplephoenix::tuple718 tuple( 719 typename call_traits<A>::param_type a_, 720 typename call_traits<B>::param_type b_, 721 typename call_traits<C>::param_type c_, 722 typename call_traits<D>::param_type d_, 723 typename call_traits<E>::param_type e_ 724 ): a(a_), b(b_), c(c_), d(d_), e(e_) {} 725 726 template <typename TupleT> tuplephoenix::tuple727 tuple(TupleT const& init) 728 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 729 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 730 e(init[tuple_index<4>()]) 731 { BOOST_STATIC_ASSERT(TupleT::length == length); } 732 733 A a; B b; C c; D d; E e; 734 }; 735 736 /////////////////////////////////////////////////////////////////////////////// 737 // 738 // tuple <6 member> class 739 // 740 /////////////////////////////////////////////////////////////////////////////// 741 template < 742 typename A, typename B, typename C, typename D, typename E, 743 typename F> 744 struct tuple<A, B, C, D, E, F, 745 #if PHOENIX_LIMIT > 6 746 nil_t, nil_t, nil_t, 747 #if PHOENIX_LIMIT > 9 748 nil_t, nil_t, nil_t, 749 #if PHOENIX_LIMIT > 12 750 nil_t, nil_t, nil_t, 751 #endif 752 #endif 753 #endif 754 nil_t // Unused 755 > 756 : public tuple_base<tuple<A, B, C, D, E, F> > { 757 758 BOOST_STATIC_CONSTANT(int, length = 6); 759 typedef A a_type; typedef B b_type; 760 typedef C c_type; typedef D d_type; 761 typedef E e_type; typedef F f_type; 762 tuplephoenix::tuple763 tuple() {} 764 tuplephoenix::tuple765 tuple( 766 typename call_traits<A>::param_type a_, 767 typename call_traits<B>::param_type b_, 768 typename call_traits<C>::param_type c_, 769 typename call_traits<D>::param_type d_, 770 typename call_traits<E>::param_type e_, 771 typename call_traits<F>::param_type f_ 772 ): a(a_), b(b_), c(c_), d(d_), e(e_), 773 f(f_) {} 774 775 template <typename TupleT> tuplephoenix::tuple776 tuple(TupleT const& init) 777 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 778 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 779 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]) 780 { BOOST_STATIC_ASSERT(TupleT::length == length); } 781 782 A a; B b; C c; D d; E e; 783 F f; 784 }; 785 786 #if PHOENIX_LIMIT > 6 787 /////////////////////////////////////////////////////////////////////////////// 788 // 789 // tuple <7 member> class 790 // 791 /////////////////////////////////////////////////////////////////////////////// 792 template < 793 typename A, typename B, typename C, typename D, typename E, 794 typename F, typename G> 795 struct tuple<A, B, C, D, E, F, G, nil_t, nil_t, 796 #if PHOENIX_LIMIT > 9 797 nil_t, nil_t, nil_t, 798 #if PHOENIX_LIMIT > 12 799 nil_t, nil_t, nil_t, 800 #endif 801 #endif 802 nil_t // Unused 803 > 804 : public tuple_base<tuple<A, B, C, D, E, F, G> > { 805 806 BOOST_STATIC_CONSTANT(int, length = 7); 807 typedef A a_type; typedef B b_type; 808 typedef C c_type; typedef D d_type; 809 typedef E e_type; typedef F f_type; 810 typedef G g_type; 811 tuplephoenix::tuple812 tuple() {} 813 tuplephoenix::tuple814 tuple( 815 typename call_traits<A>::param_type a_, 816 typename call_traits<B>::param_type b_, 817 typename call_traits<C>::param_type c_, 818 typename call_traits<D>::param_type d_, 819 typename call_traits<E>::param_type e_, 820 typename call_traits<F>::param_type f_, 821 typename call_traits<G>::param_type g_ 822 ): a(a_), b(b_), c(c_), d(d_), e(e_), 823 f(f_), g(g_) {} 824 825 template <typename TupleT> tuplephoenix::tuple826 tuple(TupleT const& init) 827 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 828 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 829 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 830 g(init[tuple_index<6>()]) 831 { BOOST_STATIC_ASSERT(TupleT::length == length); } 832 833 A a; B b; C c; D d; E e; 834 F f; G g; 835 }; 836 837 /////////////////////////////////////////////////////////////////////////////// 838 // 839 // tuple <8 member> class 840 // 841 /////////////////////////////////////////////////////////////////////////////// 842 template < 843 typename A, typename B, typename C, typename D, typename E, 844 typename F, typename G, typename H> 845 struct tuple<A, B, C, D, E, F, G, H, nil_t, 846 #if PHOENIX_LIMIT > 9 847 nil_t, nil_t, nil_t, 848 #if PHOENIX_LIMIT > 12 849 nil_t, nil_t, nil_t, 850 #endif 851 #endif 852 nil_t // Unused 853 > 854 : public tuple_base<tuple<A, B, C, D, E, F, G, H> > { 855 856 BOOST_STATIC_CONSTANT(int, length = 8); 857 typedef A a_type; typedef B b_type; 858 typedef C c_type; typedef D d_type; 859 typedef E e_type; typedef F f_type; 860 typedef G g_type; typedef H h_type; 861 tuplephoenix::tuple862 tuple() {} 863 tuplephoenix::tuple864 tuple( 865 typename call_traits<A>::param_type a_, 866 typename call_traits<B>::param_type b_, 867 typename call_traits<C>::param_type c_, 868 typename call_traits<D>::param_type d_, 869 typename call_traits<E>::param_type e_, 870 typename call_traits<F>::param_type f_, 871 typename call_traits<G>::param_type g_, 872 typename call_traits<H>::param_type h_ 873 ): a(a_), b(b_), c(c_), d(d_), e(e_), 874 f(f_), g(g_), h(h_) {} 875 876 template <typename TupleT> tuplephoenix::tuple877 tuple(TupleT const& init) 878 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 879 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 880 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 881 g(init[tuple_index<6>()]), h(init[tuple_index<7>()]) 882 { BOOST_STATIC_ASSERT(TupleT::length == length); } 883 884 A a; B b; C c; D d; E e; 885 F f; G g; H h; 886 }; 887 888 /////////////////////////////////////////////////////////////////////////////// 889 // 890 // tuple <9 member> class 891 // 892 /////////////////////////////////////////////////////////////////////////////// 893 template < 894 typename A, typename B, typename C, typename D, typename E, 895 typename F, typename G, typename H, typename I> 896 struct tuple<A, B, C, D, E, F, G, H, I, 897 #if PHOENIX_LIMIT > 9 898 nil_t, nil_t, nil_t, 899 #if PHOENIX_LIMIT > 12 900 nil_t, nil_t, nil_t, 901 #endif 902 #endif 903 nil_t // Unused 904 > 905 : public tuple_base<tuple<A, B, C, D, E, F, G, H, I> > { 906 907 BOOST_STATIC_CONSTANT(int, length = 9); 908 typedef A a_type; typedef B b_type; 909 typedef C c_type; typedef D d_type; 910 typedef E e_type; typedef F f_type; 911 typedef G g_type; typedef H h_type; 912 typedef I i_type; 913 tuplephoenix::tuple914 tuple() {} 915 tuplephoenix::tuple916 tuple( 917 typename call_traits<A>::param_type a_, 918 typename call_traits<B>::param_type b_, 919 typename call_traits<C>::param_type c_, 920 typename call_traits<D>::param_type d_, 921 typename call_traits<E>::param_type e_, 922 typename call_traits<F>::param_type f_, 923 typename call_traits<G>::param_type g_, 924 typename call_traits<H>::param_type h_, 925 typename call_traits<I>::param_type i_ 926 ): a(a_), b(b_), c(c_), d(d_), e(e_), 927 f(f_), g(g_), h(h_), i(i_) {} 928 929 template <typename TupleT> tuplephoenix::tuple930 tuple(TupleT const& init) 931 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 932 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 933 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 934 g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), 935 i(init[tuple_index<8>()]) 936 { BOOST_STATIC_ASSERT(TupleT::length == length); } 937 938 A a; B b; C c; D d; E e; 939 F f; G g; H h; I i; 940 }; 941 942 #if PHOENIX_LIMIT > 9 943 /////////////////////////////////////////////////////////////////////////////// 944 // 945 // tuple <10 member> class 946 // 947 /////////////////////////////////////////////////////////////////////////////// 948 template < 949 typename A, typename B, typename C, typename D, typename E, 950 typename F, typename G, typename H, typename I, typename J> 951 struct tuple<A, B, C, D, E, F, G, H, I, J, nil_t, nil_t, 952 #if PHOENIX_LIMIT > 12 953 nil_t, nil_t, nil_t, 954 #endif 955 nil_t // Unused 956 > 957 : public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J> > { 958 959 BOOST_STATIC_CONSTANT(int, length = 10); 960 typedef A a_type; typedef B b_type; 961 typedef C c_type; typedef D d_type; 962 typedef E e_type; typedef F f_type; 963 typedef G g_type; typedef H h_type; 964 typedef I i_type; typedef J j_type; 965 tuplephoenix::tuple966 tuple() {} 967 tuplephoenix::tuple968 tuple( 969 typename call_traits<A>::param_type a_, 970 typename call_traits<B>::param_type b_, 971 typename call_traits<C>::param_type c_, 972 typename call_traits<D>::param_type d_, 973 typename call_traits<E>::param_type e_, 974 typename call_traits<F>::param_type f_, 975 typename call_traits<G>::param_type g_, 976 typename call_traits<H>::param_type h_, 977 typename call_traits<I>::param_type i_, 978 typename call_traits<J>::param_type j_ 979 ): a(a_), b(b_), c(c_), d(d_), e(e_), 980 f(f_), g(g_), h(h_), i(i_), j(j_) {} 981 982 template <typename TupleT> tuplephoenix::tuple983 tuple(TupleT const& init) 984 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 985 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 986 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 987 g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), 988 i(init[tuple_index<8>()]), j(init[tuple_index<9>()]) 989 { BOOST_STATIC_ASSERT(TupleT::length == length); } 990 991 A a; B b; C c; D d; E e; 992 F f; G g; H h; I i; J j; 993 }; 994 995 /////////////////////////////////////////////////////////////////////////////// 996 // 997 // tuple <11 member> class 998 // 999 /////////////////////////////////////////////////////////////////////////////// 1000 template < 1001 typename A, typename B, typename C, typename D, typename E, 1002 typename F, typename G, typename H, typename I, typename J, 1003 typename K> 1004 struct tuple<A, B, C, D, E, F, G, H, I, J, K, nil_t, 1005 #if PHOENIX_LIMIT > 12 1006 nil_t, nil_t, nil_t, 1007 #endif 1008 nil_t // Unused 1009 > 1010 : public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J, K> > { 1011 1012 BOOST_STATIC_CONSTANT(int, length = 11); 1013 typedef A a_type; typedef B b_type; 1014 typedef C c_type; typedef D d_type; 1015 typedef E e_type; typedef F f_type; 1016 typedef G g_type; typedef H h_type; 1017 typedef I i_type; typedef J j_type; 1018 typedef K k_type; 1019 tuplephoenix::tuple1020 tuple() {} 1021 tuplephoenix::tuple1022 tuple( 1023 typename call_traits<A>::param_type a_, 1024 typename call_traits<B>::param_type b_, 1025 typename call_traits<C>::param_type c_, 1026 typename call_traits<D>::param_type d_, 1027 typename call_traits<E>::param_type e_, 1028 typename call_traits<F>::param_type f_, 1029 typename call_traits<G>::param_type g_, 1030 typename call_traits<H>::param_type h_, 1031 typename call_traits<I>::param_type i_, 1032 typename call_traits<J>::param_type j_, 1033 typename call_traits<K>::param_type k_ 1034 ): a(a_), b(b_), c(c_), d(d_), e(e_), 1035 f(f_), g(g_), h(h_), i(i_), j(j_), 1036 k(k_) {} 1037 1038 template <typename TupleT> tuplephoenix::tuple1039 tuple(TupleT const& init) 1040 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 1041 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 1042 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 1043 g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), 1044 i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), 1045 k(init[tuple_index<10>()]) 1046 { BOOST_STATIC_ASSERT(TupleT::length == length); } 1047 1048 A a; B b; C c; D d; E e; 1049 F f; G g; H h; I i; J j; 1050 K k; 1051 }; 1052 1053 /////////////////////////////////////////////////////////////////////////////// 1054 // 1055 // tuple <12 member> class 1056 // 1057 /////////////////////////////////////////////////////////////////////////////// 1058 template < 1059 typename A, typename B, typename C, typename D, typename E, 1060 typename F, typename G, typename H, typename I, typename J, 1061 typename K, typename L> 1062 struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, 1063 #if PHOENIX_LIMIT > 12 1064 nil_t, nil_t, nil_t, 1065 #endif 1066 nil_t // Unused 1067 > 1068 : public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J, K, L> > { 1069 1070 BOOST_STATIC_CONSTANT(int, length = 12); 1071 typedef A a_type; typedef B b_type; 1072 typedef C c_type; typedef D d_type; 1073 typedef E e_type; typedef F f_type; 1074 typedef G g_type; typedef H h_type; 1075 typedef I i_type; typedef J j_type; 1076 typedef K k_type; typedef L l_type; 1077 tuplephoenix::tuple1078 tuple() {} 1079 tuplephoenix::tuple1080 tuple( 1081 typename call_traits<A>::param_type a_, 1082 typename call_traits<B>::param_type b_, 1083 typename call_traits<C>::param_type c_, 1084 typename call_traits<D>::param_type d_, 1085 typename call_traits<E>::param_type e_, 1086 typename call_traits<F>::param_type f_, 1087 typename call_traits<G>::param_type g_, 1088 typename call_traits<H>::param_type h_, 1089 typename call_traits<I>::param_type i_, 1090 typename call_traits<J>::param_type j_, 1091 typename call_traits<K>::param_type k_, 1092 typename call_traits<L>::param_type l_ 1093 ): a(a_), b(b_), c(c_), d(d_), e(e_), 1094 f(f_), g(g_), h(h_), i(i_), j(j_), 1095 k(k_), l(l_) {} 1096 1097 template <typename TupleT> tuplephoenix::tuple1098 tuple(TupleT const& init) 1099 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 1100 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 1101 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 1102 g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), 1103 i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), 1104 k(init[tuple_index<10>()]), l(init[tuple_index<11>()]) 1105 { BOOST_STATIC_ASSERT(TupleT::length == length); } 1106 1107 A a; B b; C c; D d; E e; 1108 F f; G g; H h; I i; J j; 1109 K k; L l; 1110 }; 1111 1112 #if PHOENIX_LIMIT > 12 1113 /////////////////////////////////////////////////////////////////////////////// 1114 // 1115 // tuple <13 member> class 1116 // 1117 /////////////////////////////////////////////////////////////////////////////// 1118 template < 1119 typename A, typename B, typename C, typename D, typename E, 1120 typename F, typename G, typename H, typename I, typename J, 1121 typename K, typename L, typename M> 1122 struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t> 1123 : public tuple_base< 1124 tuple<A, B, C, D, E, F, G, H, I, J, K, L, M> > { 1125 1126 BOOST_STATIC_CONSTANT(int, length = 13); 1127 typedef A a_type; typedef B b_type; 1128 typedef C c_type; typedef D d_type; 1129 typedef E e_type; typedef F f_type; 1130 typedef G g_type; typedef H h_type; 1131 typedef I i_type; typedef J j_type; 1132 typedef K k_type; typedef L l_type; 1133 typedef M m_type; 1134 tuplephoenix::tuple1135 tuple() {} 1136 tuplephoenix::tuple1137 tuple( 1138 typename call_traits<A>::param_type a_, 1139 typename call_traits<B>::param_type b_, 1140 typename call_traits<C>::param_type c_, 1141 typename call_traits<D>::param_type d_, 1142 typename call_traits<E>::param_type e_, 1143 typename call_traits<F>::param_type f_, 1144 typename call_traits<G>::param_type g_, 1145 typename call_traits<H>::param_type h_, 1146 typename call_traits<I>::param_type i_, 1147 typename call_traits<J>::param_type j_, 1148 typename call_traits<K>::param_type k_, 1149 typename call_traits<L>::param_type l_, 1150 typename call_traits<M>::param_type m_ 1151 ): a(a_), b(b_), c(c_), d(d_), e(e_), 1152 f(f_), g(g_), h(h_), i(i_), j(j_), 1153 k(k_), l(l_), m(m_) {} 1154 1155 template <typename TupleT> tuplephoenix::tuple1156 tuple(TupleT const& init) 1157 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 1158 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 1159 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 1160 g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), 1161 i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), 1162 k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), 1163 m(init[tuple_index<12>()]) 1164 { BOOST_STATIC_ASSERT(TupleT::length == length); } 1165 1166 A a; B b; C c; D d; E e; 1167 F f; G g; H h; I i; J j; 1168 K k; L l; M m; 1169 }; 1170 1171 /////////////////////////////////////////////////////////////////////////////// 1172 // 1173 // tuple <14 member> class 1174 // 1175 /////////////////////////////////////////////////////////////////////////////// 1176 template < 1177 typename A, typename B, typename C, typename D, typename E, 1178 typename F, typename G, typename H, typename I, typename J, 1179 typename K, typename L, typename M, typename N> 1180 struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t> 1181 : public tuple_base< 1182 tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N> > { 1183 1184 BOOST_STATIC_CONSTANT(int, length = 14); 1185 typedef A a_type; typedef B b_type; 1186 typedef C c_type; typedef D d_type; 1187 typedef E e_type; typedef F f_type; 1188 typedef G g_type; typedef H h_type; 1189 typedef I i_type; typedef J j_type; 1190 typedef K k_type; typedef L l_type; 1191 typedef M m_type; typedef N n_type; 1192 tuplephoenix::tuple1193 tuple() {} 1194 tuplephoenix::tuple1195 tuple( 1196 typename call_traits<A>::param_type a_, 1197 typename call_traits<B>::param_type b_, 1198 typename call_traits<C>::param_type c_, 1199 typename call_traits<D>::param_type d_, 1200 typename call_traits<E>::param_type e_, 1201 typename call_traits<F>::param_type f_, 1202 typename call_traits<G>::param_type g_, 1203 typename call_traits<H>::param_type h_, 1204 typename call_traits<I>::param_type i_, 1205 typename call_traits<J>::param_type j_, 1206 typename call_traits<K>::param_type k_, 1207 typename call_traits<L>::param_type l_, 1208 typename call_traits<M>::param_type m_, 1209 typename call_traits<N>::param_type n_ 1210 ): a(a_), b(b_), c(c_), d(d_), e(e_), 1211 f(f_), g(g_), h(h_), i(i_), j(j_), 1212 k(k_), l(l_), m(m_), n(n_) {} 1213 1214 template <typename TupleT> tuplephoenix::tuple1215 tuple(TupleT const& init) 1216 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 1217 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 1218 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 1219 g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), 1220 i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), 1221 k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), 1222 m(init[tuple_index<12>()]), n(init[tuple_index<13>()]) 1223 { BOOST_STATIC_ASSERT(TupleT::length == length); } 1224 1225 A a; B b; C c; D d; E e; 1226 F f; G g; H h; I i; J j; 1227 K k; L l; M m; N n; 1228 }; 1229 1230 /////////////////////////////////////////////////////////////////////////////// 1231 // 1232 // tuple <15 member> class 1233 // 1234 /////////////////////////////////////////////////////////////////////////////// 1235 template < 1236 typename A, typename B, typename C, typename D, typename E, 1237 typename F, typename G, typename H, typename I, typename J, 1238 typename K, typename L, typename M, typename N, typename O> 1239 struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t> 1240 : public tuple_base< 1241 tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> > { 1242 1243 BOOST_STATIC_CONSTANT(int, length = 15); 1244 typedef A a_type; typedef B b_type; 1245 typedef C c_type; typedef D d_type; 1246 typedef E e_type; typedef F f_type; 1247 typedef G g_type; typedef H h_type; 1248 typedef I i_type; typedef J j_type; 1249 typedef K k_type; typedef L l_type; 1250 typedef M m_type; typedef N n_type; 1251 typedef O o_type; 1252 tuplephoenix::tuple1253 tuple() {} 1254 tuplephoenix::tuple1255 tuple( 1256 typename call_traits<A>::param_type a_, 1257 typename call_traits<B>::param_type b_, 1258 typename call_traits<C>::param_type c_, 1259 typename call_traits<D>::param_type d_, 1260 typename call_traits<E>::param_type e_, 1261 typename call_traits<F>::param_type f_, 1262 typename call_traits<G>::param_type g_, 1263 typename call_traits<H>::param_type h_, 1264 typename call_traits<I>::param_type i_, 1265 typename call_traits<J>::param_type j_, 1266 typename call_traits<K>::param_type k_, 1267 typename call_traits<L>::param_type l_, 1268 typename call_traits<M>::param_type m_, 1269 typename call_traits<N>::param_type n_, 1270 typename call_traits<O>::param_type o_ 1271 ): a(a_), b(b_), c(c_), d(d_), e(e_), 1272 f(f_), g(g_), h(h_), i(i_), j(j_), 1273 k(k_), l(l_), m(m_), n(n_), o(o_) {} 1274 1275 template <typename TupleT> tuplephoenix::tuple1276 tuple(TupleT const& init) 1277 : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), 1278 c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), 1279 e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), 1280 g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), 1281 i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), 1282 k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), 1283 m(init[tuple_index<12>()]), n(init[tuple_index<13>()]), 1284 o(init[tuple_index<14>()]) 1285 { BOOST_STATIC_ASSERT(TupleT::length == length); } 1286 1287 A a; B b; C c; D d; E e; 1288 F f; G g; H h; I i; J j; 1289 K k; L l; M m; N n; O o; 1290 }; 1291 1292 #endif 1293 #endif 1294 #endif 1295 #endif 1296 1297 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) 1298 #pragma warning(pop) 1299 #endif 1300 1301 /////////////////////////////////////////////////////////////////////////////// 1302 } // namespace phoenix 1303 1304 #endif 1305