sl@0: /*============================================================================= sl@0: Phoenix V1.2.1 sl@0: Copyright (c) 2001-2002 Joel de Guzman sl@0: sl@0: Use, modification and distribution is subject to the Boost Software sl@0: License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at sl@0: http://www.boost.org/LICENSE_1_0.txt) sl@0: ==============================================================================*/ sl@0: #ifndef PHOENIX_TUPLES_HPP sl@0: #define PHOENIX_TUPLES_HPP sl@0: sl@0: #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) sl@0: #error "Sorry, Phoenix does not support VC6 and VC7. Please upgrade to at least VC7.1" sl@0: #endif sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // Phoenix predefined maximum limit. This limit defines the maximum sl@0: // number of elements a tuple can hold. This number defaults to 3. The sl@0: // actual maximum is rounded up in multiples of 3. Thus, if this value sl@0: // is 4, the actual limit is 6. The ultimate maximum limit in this sl@0: // implementation is 15. sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: #ifndef PHOENIX_LIMIT sl@0: #define PHOENIX_LIMIT 3 sl@0: #endif sl@0: sl@0: #if defined(__BORLANDC__) && (__BORLANDC__ <= 0x561) sl@0: namespace phoenix { namespace borland_only sl@0: { sl@0: namespace ftors sl@0: { sl@0: // We define these dummy template functions. Borland complains when sl@0: // a template class has the same name as a template function, sl@0: // regardless if they are in different namespaces. sl@0: sl@0: template void if_(T) {} sl@0: template void for_(T) {} sl@0: template void while_(T) {} sl@0: template void do_(T) {} sl@0: } sl@0: sl@0: namespace tmpls sl@0: { sl@0: // We define these dummy template functions. Borland complains when sl@0: // a template class has the same name as a template function, sl@0: // regardless if they are in different namespaces. sl@0: sl@0: template struct if_ {}; sl@0: template struct for_ {}; sl@0: template struct while_ {}; sl@0: template struct do_ {}; sl@0: } sl@0: sl@0: }} // namespace phoenix::borland_only sl@0: #endif sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: #include sl@0: #include sl@0: #include sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: namespace phoenix { sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple sl@0: // sl@0: // Tuples hold heterogeneous types up to a predefined maximum. Only sl@0: // the most basic functionality needed is provided. Unlike other sl@0: // recursive list-like tuple implementations, this tuple sl@0: // implementation uses simple structs similar to std::pair with sl@0: // specialization for 0 to N tuple elements. sl@0: // sl@0: // 1) Construction sl@0: // Here are examples on how to construct tuples: sl@0: // sl@0: // typedef tuple t1_t; sl@0: // typedef tuple t2_t; sl@0: // sl@0: // // this tuple has an int and char members sl@0: // t1_t t1(3, 'c'); sl@0: // sl@0: // // this tuple has an int, std::string and double members sl@0: // t2_t t2(3, "hello", 3.14); sl@0: // sl@0: // Tuples can also be constructed from other tuples. The sl@0: // source and destination tuples need not have exactly the sl@0: // same element types. The only requirement is that the sl@0: // source tuple have the same number of elements as the sl@0: // destination and that each element slot in the sl@0: // destination can be copy constructed from the source sl@0: // element. For example: sl@0: // sl@0: // tuple t3(t1); // OK. Compatible tuples sl@0: // tuple t4(t2); // Error! Incompatible tuples sl@0: // sl@0: // 2) Member access sl@0: // A member in a tuple can be accessed using the sl@0: // tuple's [] operator by specifying the Nth sl@0: // tuple_index. Here are some examples: sl@0: // sl@0: // tuple_index<0> ix0; // 0th index == 1st item sl@0: // tuple_index<1> ix1; // 1st index == 2nd item sl@0: // tuple_index<2> ix2; // 2nd index == 3rd item sl@0: // sl@0: // t1[ix0] = 33; // sets the int member of the tuple t1 sl@0: // t2[ix2] = 6e6; // sets the double member of the tuple t2 sl@0: // t1[ix1] = 'a'; // sets the char member of the tuple t1 sl@0: // sl@0: // There are some predefined names are provided in sub- sl@0: // namespace tuple_index_names: sl@0: // sl@0: // tuple_index<0> _1; sl@0: // tuple_index<1> _2; sl@0: // ... sl@0: // tuple_index _N; sl@0: // sl@0: // These indexes may be used by 'using' namespace sl@0: // phoenix::tuple_index_names. sl@0: // sl@0: // Access to out of bound indexes returns a nil_t value. sl@0: // sl@0: // 3) Member type inquiry sl@0: // The type of an individual member can be queried. sl@0: // Example: sl@0: // sl@0: // tuple_element<1, t2_t>::type sl@0: // sl@0: // Refers to the type of the second member (note zero based, sl@0: // thus 0 = 1st item, 1 = 2nd item) of the tuple. sl@0: // sl@0: // Aside from tuple_element::type, there are two sl@0: // more types that tuple_element provides: rtype and sl@0: // crtype. While 'type' is the plain underlying type, sl@0: // 'rtype' is the reference type, or type& and 'crtype' sl@0: // is the constant reference type or type const&. The sl@0: // latter two are provided to make it easy for the sl@0: // client in dealing with the possibility of reference sl@0: // to reference when type is already a reference, which sl@0: // is illegal in C++. sl@0: // sl@0: // Access to out of bound indexes returns a nil_t type. sl@0: // sl@0: // 4) Tuple length sl@0: // The number of elements in a tuple can be queried. sl@0: // Example: sl@0: // sl@0: // int n = t1.length; sl@0: // sl@0: // gets the number of elements in tuple t1. sl@0: // sl@0: // length is a static constant. Thus, TupleT::length sl@0: // also works. Example: sl@0: // sl@0: // int n = t1_t::length; sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: struct nil_t {}; sl@0: using boost::remove_reference; sl@0: using boost::call_traits; sl@0: sl@0: ////////////////////////////////// sl@0: namespace impl { sl@0: sl@0: template sl@0: struct access { sl@0: sl@0: typedef const T& ctype; sl@0: typedef T& type; sl@0: }; sl@0: sl@0: template sl@0: struct access { sl@0: sl@0: typedef T& ctype; sl@0: typedef T& type; sl@0: }; sl@0: } sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple_element sl@0: // sl@0: // A query class that gets the Nth element inside a tuple. sl@0: // Examples: sl@0: // sl@0: // tuple_element<1, tuple >::type // plain sl@0: // tuple_element<1, tuple >::rtype // ref sl@0: // tuple_element<1, tuple >::crtype // const ref sl@0: // sl@0: // Has type char which is the 2nd type in the tuple sl@0: // (note zero based, thus 0 = 1st item, 1 = 2nd item). sl@0: // sl@0: // Given a tuple object, the static function tuple_element::get(tuple) gets the Nth element in the tuple. The sl@0: // tuple class' tuple::operator[] uses this to get its Nth sl@0: // element. sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template sl@0: struct tuple_element sl@0: { sl@0: typedef nil_t type; sl@0: typedef nil_t& rtype; sl@0: typedef nil_t const& crtype; sl@0: sl@0: static nil_t get(TupleT const& t) { return nil_t(); } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<0, TupleT> sl@0: { sl@0: typedef typename TupleT::a_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.a; } sl@0: static crtype get(TupleT const& t) { return t.a; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<1, TupleT> sl@0: { sl@0: typedef typename TupleT::b_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.b; } sl@0: static crtype get(TupleT const& t) { return t.b; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<2, TupleT> sl@0: { sl@0: typedef typename TupleT::c_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.c; } sl@0: static crtype get(TupleT const& t) { return t.c; } sl@0: }; sl@0: sl@0: #if PHOENIX_LIMIT > 3 sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<3, TupleT> sl@0: { sl@0: typedef typename TupleT::d_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.d; } sl@0: static crtype get(TupleT const& t) { return t.d; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<4, TupleT> sl@0: { sl@0: typedef typename TupleT::e_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.e; } sl@0: static crtype get(TupleT const& t) { return t.e; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<5, TupleT> sl@0: { sl@0: typedef typename TupleT::f_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.f; } sl@0: static crtype get(TupleT const& t) { return t.f; } sl@0: }; sl@0: sl@0: #if PHOENIX_LIMIT > 6 sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<6, TupleT> sl@0: { sl@0: typedef typename TupleT::g_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.g; } sl@0: static crtype get(TupleT const& t) { return t.g; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<7, TupleT> sl@0: { sl@0: typedef typename TupleT::h_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.h; } sl@0: static crtype get(TupleT const& t) { return t.h; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<8, TupleT> sl@0: { sl@0: typedef typename TupleT::i_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.i; } sl@0: static crtype get(TupleT const& t) { return t.i; } sl@0: }; sl@0: sl@0: #if PHOENIX_LIMIT > 9 sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<9, TupleT> sl@0: { sl@0: typedef typename TupleT::j_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.j; } sl@0: static crtype get(TupleT const& t) { return t.j; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<10, TupleT> sl@0: { sl@0: typedef typename TupleT::k_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.k; } sl@0: static crtype get(TupleT const& t) { return t.k; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<11, TupleT> sl@0: { sl@0: typedef typename TupleT::l_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.l; } sl@0: static crtype get(TupleT const& t) { return t.l; } sl@0: }; sl@0: sl@0: #if PHOENIX_LIMIT > 12 sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<12, TupleT> sl@0: { sl@0: typedef typename TupleT::m_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.m; } sl@0: static crtype get(TupleT const& t) { return t.m; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<13, TupleT> sl@0: { sl@0: typedef typename TupleT::n_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.n; } sl@0: static crtype get(TupleT const& t) { return t.n; } sl@0: }; sl@0: sl@0: ////////////////////////////////// sl@0: template sl@0: struct tuple_element<14, TupleT> sl@0: { sl@0: typedef typename TupleT::o_type type; sl@0: typedef typename impl::access::type rtype; sl@0: typedef typename impl::access::ctype crtype; sl@0: sl@0: static rtype get(TupleT& t) { return t.o; } sl@0: static crtype get(TupleT const& t) { return t.o; } sl@0: }; sl@0: sl@0: #endif sl@0: #endif sl@0: #endif sl@0: #endif sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple forward declaration. sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A = nil_t sl@0: , typename B = nil_t sl@0: , typename C = nil_t sl@0: sl@0: #if PHOENIX_LIMIT > 3 sl@0: , typename D = nil_t sl@0: , typename E = nil_t sl@0: , typename F = nil_t sl@0: sl@0: #if PHOENIX_LIMIT > 6 sl@0: , typename G = nil_t sl@0: , typename H = nil_t sl@0: , typename I = nil_t sl@0: sl@0: #if PHOENIX_LIMIT > 9 sl@0: , typename J = nil_t sl@0: , typename K = nil_t sl@0: , typename L = nil_t sl@0: sl@0: #if PHOENIX_LIMIT > 12 sl@0: , typename M = nil_t sl@0: , typename N = nil_t sl@0: , typename O = nil_t sl@0: sl@0: #endif sl@0: #endif sl@0: #endif sl@0: #endif sl@0: sl@0: , typename NU = nil_t // Not used sl@0: > sl@0: struct tuple; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple_index sl@0: // sl@0: // This class wraps an integer in a type to be used for indexing sl@0: // the Nth element in a tuple. See tuple operator[]. Some sl@0: // predefined names are provided in sub-namespace sl@0: // tuple_index_names. sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template sl@0: struct tuple_index {}; sl@0: sl@0: ////////////////////////////////// sl@0: namespace tuple_index_names { sl@0: sl@0: tuple_index<0> const _1 = tuple_index<0>(); sl@0: tuple_index<1> const _2 = tuple_index<1>(); sl@0: tuple_index<2> const _3 = tuple_index<2>(); sl@0: sl@0: #if PHOENIX_LIMIT > 3 sl@0: tuple_index<3> const _4 = tuple_index<3>(); sl@0: tuple_index<4> const _5 = tuple_index<4>(); sl@0: tuple_index<5> const _6 = tuple_index<5>(); sl@0: sl@0: #if PHOENIX_LIMIT > 6 sl@0: tuple_index<6> const _7 = tuple_index<6>(); sl@0: tuple_index<7> const _8 = tuple_index<7>(); sl@0: tuple_index<8> const _9 = tuple_index<8>(); sl@0: sl@0: #if PHOENIX_LIMIT > 9 sl@0: tuple_index<9> const _10 = tuple_index<9>(); sl@0: tuple_index<10> const _11 = tuple_index<10>(); sl@0: tuple_index<11> const _12 = tuple_index<11>(); sl@0: sl@0: #if PHOENIX_LIMIT > 12 sl@0: tuple_index<12> const _13 = tuple_index<12>(); sl@0: tuple_index<13> const _14 = tuple_index<13>(); sl@0: tuple_index<14> const _15 = tuple_index<14>(); sl@0: sl@0: #endif sl@0: #endif sl@0: #endif sl@0: #endif sl@0: } sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple_common class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template sl@0: struct tuple_base { sl@0: sl@0: typedef nil_t a_type; sl@0: typedef nil_t b_type; sl@0: typedef nil_t c_type; sl@0: sl@0: #if PHOENIX_LIMIT > 3 sl@0: typedef nil_t d_type; sl@0: typedef nil_t e_type; sl@0: typedef nil_t f_type; sl@0: sl@0: #if PHOENIX_LIMIT > 6 sl@0: typedef nil_t g_type; sl@0: typedef nil_t h_type; sl@0: typedef nil_t i_type; sl@0: sl@0: #if PHOENIX_LIMIT > 9 sl@0: typedef nil_t j_type; sl@0: typedef nil_t k_type; sl@0: typedef nil_t l_type; sl@0: sl@0: #if PHOENIX_LIMIT > 12 sl@0: typedef nil_t m_type; sl@0: typedef nil_t n_type; sl@0: typedef nil_t o_type; sl@0: sl@0: #endif sl@0: #endif sl@0: #endif sl@0: #endif sl@0: sl@0: template sl@0: typename tuple_element::crtype sl@0: operator[](tuple_index) const sl@0: { sl@0: return tuple_element sl@0: ::get(*static_cast(this)); sl@0: } sl@0: sl@0: template sl@0: typename tuple_element::rtype sl@0: operator[](tuple_index) sl@0: { sl@0: return tuple_element sl@0: ::get(*static_cast(this)); sl@0: } sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <0 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template <> sl@0: struct tuple<> sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 0); sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <1 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template sl@0: struct tuple 3 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 6 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 1); sl@0: typedef A a_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_ sl@0: ): a(a_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <2 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template sl@0: struct tuple 3 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 6 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 2); sl@0: typedef A a_type; typedef B b_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits ::param_type a_, sl@0: typename call_traits::param_type b_ sl@0: ): a(a_), b(b_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <3 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template sl@0: struct tuple 3 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 6 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 3); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_ sl@0: ): a(a_), b(b_), c(c_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; sl@0: }; sl@0: sl@0: #if PHOENIX_LIMIT > 3 sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <4 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template sl@0: struct tuple 6 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 4); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_ sl@0: ): a(a_), b(b_), c(c_), d(d_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <5 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template sl@0: struct tuple 6 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 5); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <6 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F> sl@0: struct tuple 6 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 6); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; sl@0: }; sl@0: sl@0: #if PHOENIX_LIMIT > 6 sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <7 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G> sl@0: struct tuple 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 7); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <8 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G, typename H> sl@0: struct tuple 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 8); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; typedef H h_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_, sl@0: typename call_traits::param_type h_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_), h(h_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]), h(init[tuple_index<7>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; H h; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <9 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G, typename H, typename I> sl@0: struct tuple 9 sl@0: nil_t, nil_t, nil_t, sl@0: #if PHOENIX_LIMIT > 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 9); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; typedef H h_type; sl@0: typedef I i_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_, sl@0: typename call_traits::param_type h_, sl@0: typename call_traits::param_type i_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_), h(h_), i(i_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), sl@0: i(init[tuple_index<8>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; H h; I i; sl@0: }; sl@0: sl@0: #if PHOENIX_LIMIT > 9 sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <10 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G, typename H, typename I, typename J> sl@0: struct tuple 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 10); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; typedef H h_type; sl@0: typedef I i_type; typedef J j_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_, sl@0: typename call_traits::param_type h_, sl@0: typename call_traits::param_type i_, sl@0: typename call_traits::param_type j_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_), h(h_), i(i_), j(j_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), sl@0: i(init[tuple_index<8>()]), j(init[tuple_index<9>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; H h; I i; J j; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <11 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G, typename H, typename I, typename J, sl@0: typename K> sl@0: struct tuple 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 11); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; typedef H h_type; sl@0: typedef I i_type; typedef J j_type; sl@0: typedef K k_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_, sl@0: typename call_traits::param_type h_, sl@0: typename call_traits::param_type i_, sl@0: typename call_traits::param_type j_, sl@0: typename call_traits::param_type k_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_), h(h_), i(i_), j(j_), sl@0: k(k_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), sl@0: i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), sl@0: k(init[tuple_index<10>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; H h; I i; J j; sl@0: K k; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <12 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G, typename H, typename I, typename J, sl@0: typename K, typename L> sl@0: struct tuple 12 sl@0: nil_t, nil_t, nil_t, sl@0: #endif sl@0: nil_t // Unused sl@0: > sl@0: : public tuple_base > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 12); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; typedef H h_type; sl@0: typedef I i_type; typedef J j_type; sl@0: typedef K k_type; typedef L l_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_, sl@0: typename call_traits::param_type h_, sl@0: typename call_traits::param_type i_, sl@0: typename call_traits::param_type j_, sl@0: typename call_traits::param_type k_, sl@0: typename call_traits::param_type l_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_), h(h_), i(i_), j(j_), sl@0: k(k_), l(l_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), sl@0: i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), sl@0: k(init[tuple_index<10>()]), l(init[tuple_index<11>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; H h; I i; J j; sl@0: K k; L l; sl@0: }; sl@0: sl@0: #if PHOENIX_LIMIT > 12 sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <13 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G, typename H, typename I, typename J, sl@0: typename K, typename L, typename M> sl@0: struct tuple sl@0: : public tuple_base< sl@0: tuple > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 13); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; typedef H h_type; sl@0: typedef I i_type; typedef J j_type; sl@0: typedef K k_type; typedef L l_type; sl@0: typedef M m_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_, sl@0: typename call_traits::param_type h_, sl@0: typename call_traits::param_type i_, sl@0: typename call_traits::param_type j_, sl@0: typename call_traits::param_type k_, sl@0: typename call_traits::param_type l_, sl@0: typename call_traits::param_type m_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_), h(h_), i(i_), j(j_), sl@0: k(k_), l(l_), m(m_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), sl@0: i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), sl@0: k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), sl@0: m(init[tuple_index<12>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; H h; I i; J j; sl@0: K k; L l; M m; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <14 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G, typename H, typename I, typename J, sl@0: typename K, typename L, typename M, typename N> sl@0: struct tuple sl@0: : public tuple_base< sl@0: tuple > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 14); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; typedef H h_type; sl@0: typedef I i_type; typedef J j_type; sl@0: typedef K k_type; typedef L l_type; sl@0: typedef M m_type; typedef N n_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_, sl@0: typename call_traits::param_type h_, sl@0: typename call_traits::param_type i_, sl@0: typename call_traits::param_type j_, sl@0: typename call_traits::param_type k_, sl@0: typename call_traits::param_type l_, sl@0: typename call_traits::param_type m_, sl@0: typename call_traits::param_type n_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_), h(h_), i(i_), j(j_), sl@0: k(k_), l(l_), m(m_), n(n_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), sl@0: i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), sl@0: k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), sl@0: m(init[tuple_index<12>()]), n(init[tuple_index<13>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; H h; I i; J j; sl@0: K k; L l; M m; N n; sl@0: }; sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: // sl@0: // tuple <15 member> class sl@0: // sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: template < sl@0: typename A, typename B, typename C, typename D, typename E, sl@0: typename F, typename G, typename H, typename I, typename J, sl@0: typename K, typename L, typename M, typename N, typename O> sl@0: struct tuple sl@0: : public tuple_base< sl@0: tuple > { sl@0: sl@0: BOOST_STATIC_CONSTANT(int, length = 15); sl@0: typedef A a_type; typedef B b_type; sl@0: typedef C c_type; typedef D d_type; sl@0: typedef E e_type; typedef F f_type; sl@0: typedef G g_type; typedef H h_type; sl@0: typedef I i_type; typedef J j_type; sl@0: typedef K k_type; typedef L l_type; sl@0: typedef M m_type; typedef N n_type; sl@0: typedef O o_type; sl@0: sl@0: tuple() {} sl@0: sl@0: tuple( sl@0: typename call_traits::param_type a_, sl@0: typename call_traits::param_type b_, sl@0: typename call_traits::param_type c_, sl@0: typename call_traits::param_type d_, sl@0: typename call_traits::param_type e_, sl@0: typename call_traits::param_type f_, sl@0: typename call_traits::param_type g_, sl@0: typename call_traits::param_type h_, sl@0: typename call_traits::param_type i_, sl@0: typename call_traits::param_type j_, sl@0: typename call_traits::param_type k_, sl@0: typename call_traits::param_type l_, sl@0: typename call_traits::param_type m_, sl@0: typename call_traits::param_type n_, sl@0: typename call_traits::param_type o_ sl@0: ): a(a_), b(b_), c(c_), d(d_), e(e_), sl@0: f(f_), g(g_), h(h_), i(i_), j(j_), sl@0: k(k_), l(l_), m(m_), n(n_), o(o_) {} sl@0: sl@0: template sl@0: tuple(TupleT const& init) sl@0: : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]), sl@0: c(init[tuple_index<2>()]), d(init[tuple_index<3>()]), sl@0: e(init[tuple_index<4>()]), f(init[tuple_index<5>()]), sl@0: g(init[tuple_index<6>()]), h(init[tuple_index<7>()]), sl@0: i(init[tuple_index<8>()]), j(init[tuple_index<9>()]), sl@0: k(init[tuple_index<10>()]), l(init[tuple_index<11>()]), sl@0: m(init[tuple_index<12>()]), n(init[tuple_index<13>()]), sl@0: o(init[tuple_index<14>()]) sl@0: { BOOST_STATIC_ASSERT(TupleT::length == length); } sl@0: sl@0: A a; B b; C c; D d; E e; sl@0: F f; G g; H h; I i; J j; sl@0: K k; L l; M m; N n; O o; sl@0: }; sl@0: sl@0: #endif sl@0: #endif sl@0: #endif sl@0: #endif sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////// sl@0: } // namespace phoenix sl@0: sl@0: #endif