Back to home page

EIC code displayed by LXR
 
 

    

Warning, file /include/boost/spirit/home/classic/phoenix/tuples.hpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

0001 /*=============================================================================
0002     Phoenix V1.2.1
0003     Copyright (c) 2001-2002 Joel de Guzman
0004 
0005   Distributed under the Boost Software License, Version 1.0. (See accompanying
0006   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0007 ==============================================================================*/
0008 #ifndef BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLES_HPP
0009 #define BOOST_SPIRIT_CLASSIC_PHOENIX_TUPLES_HPP
0010 
0011 ///////////////////////////////////////////////////////////////////////////////
0012 //
0013 //  Phoenix predefined maximum limit. This limit defines the maximum
0014 //  number of elements a tuple can hold. This number defaults to 3. The
0015 //  actual maximum is rounded up in multiples of 3. Thus, if this value
0016 //  is 4, the actual limit is 6. The ultimate maximum limit in this
0017 //  implementation is 15.
0018 //
0019 ///////////////////////////////////////////////////////////////////////////////
0020 #ifndef PHOENIX_LIMIT
0021 #define PHOENIX_LIMIT 3
0022 #endif
0023 
0024 ///////////////////////////////////////////////////////////////////////////////
0025 #include <boost/static_assert.hpp>
0026 #include <boost/call_traits.hpp>
0027 #include <boost/type_traits/remove_reference.hpp>
0028 
0029 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
0030 #pragma warning(push)
0031 #pragma warning(disable:4512) //assignment operator could not be generated
0032 // bogus https://developercommunity.visualstudio.com/t/buggy-warning-c4709/471956
0033 #pragma warning(disable:4709) //comma operator within array index expression
0034 #endif
0035 
0036 ///////////////////////////////////////////////////////////////////////////////
0037 namespace phoenix {
0038 
0039 ///////////////////////////////////////////////////////////////////////////////
0040 //
0041 //  tuple
0042 //
0043 //      Tuples hold heterogeneous types up to a predefined maximum. Only
0044 //      the most basic functionality needed is provided. Unlike other
0045 //      recursive list-like tuple implementations, this tuple
0046 //      implementation uses simple structs similar to std::pair with
0047 //      specialization for 0 to N tuple elements.
0048 //
0049 //          1)  Construction
0050 //              Here are examples on how to construct tuples:
0051 //
0052 //                  typedef tuple<int, char> t1_t;
0053 //                  typedef tuple<int, std::string, double> t2_t;
0054 //
0055 //                  // this tuple has an int and char members
0056 //                  t1_t t1(3, 'c');
0057 //
0058 //                  // this tuple has an int, std::string and double members
0059 //                  t2_t t2(3, "hello", 3.14);
0060 //
0061 //              Tuples can also be constructed from other tuples. The
0062 //              source and destination tuples need not have exactly the
0063 //              same element types. The only requirement is that the
0064 //              source tuple have the same number of elements as the
0065 //              destination and that each element slot in the
0066 //              destination can be copy constructed from the source
0067 //              element. For example:
0068 //
0069 //                  tuple<double, double> t3(t1); // OK. Compatible tuples
0070 //                  tuple<double, double> t4(t2); // Error! Incompatible tuples
0071 //
0072 //          2)  Member access
0073 //                  A member in a tuple can be accessed using the
0074 //                  tuple's [] operator by specifying the Nth
0075 //                  tuple_index. Here are some examples:
0076 //
0077 //                      tuple_index<0> ix0; // 0th index == 1st item
0078 //                      tuple_index<1> ix1; // 1st index == 2nd item
0079 //                      tuple_index<2> ix2; // 2nd index == 3rd item
0080 //
0081 //                      t1[ix0] = 33;  // sets the int member of the tuple t1
0082 //                      t2[ix2] = 6e6; // sets the double member of the tuple t2
0083 //                      t1[ix1] = 'a'; // sets the char member of the tuple t1
0084 //
0085 //                  There are some predefined names are provided in sub-
0086 //                  namespace tuple_index_names:
0087 //
0088 //                      tuple_index<0> _1;
0089 //                      tuple_index<1> _2;
0090 //                      ...
0091 //                      tuple_index<N> _N;
0092 //
0093 //                  These indexes may be used by 'using' namespace
0094 //                  phoenix::tuple_index_names.
0095 //
0096 //                  Access to out of bound indexes returns a nil_t value.
0097 //
0098 //          3)  Member type inquiry
0099 //                  The type of an individual member can be queried.
0100 //                  Example:
0101 //
0102 //                      tuple_element<1, t2_t>::type
0103 //
0104 //                  Refers to the type of the second member (note zero based,
0105 //                  thus 0 = 1st item, 1 = 2nd item) of the tuple.
0106 //
0107 //                  Aside from tuple_element<N, T>::type, there are two
0108 //                  more types that tuple_element provides: rtype and
0109 //                  crtype. While 'type' is the plain underlying type,
0110 //                  'rtype' is the reference type, or type& and 'crtype'
0111 //                  is the constant reference type or type const&. The
0112 //                  latter two are provided to make it easy for the
0113 //                  client in dealing with the possibility of reference
0114 //                  to reference when type is already a reference, which
0115 //                  is illegal in C++.
0116 //
0117 //                  Access to out of bound indexes returns a nil_t type.
0118 //
0119 //          4)  Tuple length
0120 //                  The number of elements in a tuple can be queried.
0121 //                  Example:
0122 //
0123 //                      int n = t1.length;
0124 //
0125 //                  gets the number of elements in tuple t1.
0126 //
0127 //                  length is a static constant. Thus, TupleT::length
0128 //                  also works. Example:
0129 //
0130 //                      int n = t1_t::length;
0131 //
0132 ///////////////////////////////////////////////////////////////////////////////
0133 struct nil_t {};
0134 using boost::remove_reference;
0135 using boost::call_traits;
0136 
0137 //////////////////////////////////
0138 namespace impl {
0139 
0140     template <typename T>
0141     struct access {
0142 
0143         typedef const T& ctype;
0144         typedef T& type;
0145     };
0146 
0147     template <typename T>
0148     struct access<T&> {
0149 
0150         typedef T& ctype;
0151         typedef T& type;
0152     };
0153 }
0154 
0155 ///////////////////////////////////////////////////////////////////////////////
0156 //
0157 //  tuple_element
0158 //
0159 //      A query class that gets the Nth element inside a tuple.
0160 //      Examples:
0161 //
0162 //          tuple_element<1, tuple<int, char, void*> >::type    //  plain
0163 //          tuple_element<1, tuple<int, char, void*> >::rtype   //  ref
0164 //          tuple_element<1, tuple<int, char, void*> >::crtype  //  const ref
0165 //
0166 //      Has type char which is the 2nd type in the tuple
0167 //      (note zero based, thus 0 = 1st item, 1 = 2nd item).
0168 //
0169 //          Given a tuple object, the static function tuple_element<N,
0170 //          TupleT>::get(tuple) gets the Nth element in the tuple. The
0171 //          tuple class' tuple::operator[] uses this to get its Nth
0172 //          element.
0173 //
0174 ///////////////////////////////////////////////////////////////////////////////
0175 template <int N, typename TupleT>
0176 struct tuple_element
0177 {
0178     typedef nil_t type;
0179     typedef nil_t& rtype;
0180     typedef nil_t const& crtype;
0181 
0182     static nil_t    get(TupleT const&)      { return nil_t(); }
0183 };
0184 
0185 //////////////////////////////////
0186 template <typename TupleT>
0187 struct tuple_element<0, TupleT>
0188 {
0189     typedef typename TupleT::a_type type;
0190     typedef typename impl::access<type>::type rtype;
0191     typedef typename impl::access<type>::ctype crtype;
0192 
0193     static rtype    get(TupleT& t)          { return t.a; }
0194     static crtype   get(TupleT const& t)    { return t.a; }
0195 };
0196 
0197 //////////////////////////////////
0198 template <typename TupleT>
0199 struct tuple_element<1, TupleT>
0200 {
0201     typedef typename TupleT::b_type type;
0202     typedef typename impl::access<type>::type rtype;
0203     typedef typename impl::access<type>::ctype crtype;
0204 
0205     static rtype    get(TupleT& t)          { return t.b; }
0206     static crtype   get(TupleT const& t)    { return t.b; }
0207 };
0208 
0209 //////////////////////////////////
0210 template <typename TupleT>
0211 struct tuple_element<2, TupleT>
0212 {
0213     typedef typename TupleT::c_type type;
0214     typedef typename impl::access<type>::type rtype;
0215     typedef typename impl::access<type>::ctype crtype;
0216 
0217     static rtype    get(TupleT& t)          { return t.c; }
0218     static crtype   get(TupleT const& t)    { return t.c; }
0219 };
0220 
0221 #if PHOENIX_LIMIT > 3
0222 //////////////////////////////////
0223 template <typename TupleT>
0224 struct tuple_element<3, TupleT>
0225 {
0226     typedef typename TupleT::d_type type;
0227     typedef typename impl::access<type>::type rtype;
0228     typedef typename impl::access<type>::ctype crtype;
0229 
0230     static rtype    get(TupleT& t)          { return t.d; }
0231     static crtype   get(TupleT const& t)    { return t.d; }
0232 };
0233 
0234 //////////////////////////////////
0235 template <typename TupleT>
0236 struct tuple_element<4, TupleT>
0237 {
0238     typedef typename TupleT::e_type type;
0239     typedef typename impl::access<type>::type rtype;
0240     typedef typename impl::access<type>::ctype crtype;
0241 
0242     static rtype    get(TupleT& t)          { return t.e; }
0243     static crtype   get(TupleT const& t)    { return t.e; }
0244 };
0245 
0246 //////////////////////////////////
0247 template <typename TupleT>
0248 struct tuple_element<5, TupleT>
0249 {
0250     typedef typename TupleT::f_type type;
0251     typedef typename impl::access<type>::type rtype;
0252     typedef typename impl::access<type>::ctype crtype;
0253 
0254     static rtype    get(TupleT& t)          { return t.f; }
0255     static crtype   get(TupleT const& t)    { return t.f; }
0256 };
0257 
0258 #if PHOENIX_LIMIT > 6
0259 //////////////////////////////////
0260 template <typename TupleT>
0261 struct tuple_element<6, TupleT>
0262 {
0263     typedef typename TupleT::g_type type;
0264     typedef typename impl::access<type>::type rtype;
0265     typedef typename impl::access<type>::ctype crtype;
0266 
0267     static rtype    get(TupleT& t)          { return t.g; }
0268     static crtype   get(TupleT const& t)    { return t.g; }
0269 };
0270 
0271 //////////////////////////////////
0272 template <typename TupleT>
0273 struct tuple_element<7, TupleT>
0274 {
0275     typedef typename TupleT::h_type type;
0276     typedef typename impl::access<type>::type rtype;
0277     typedef typename impl::access<type>::ctype crtype;
0278 
0279     static rtype    get(TupleT& t)          { return t.h; }
0280     static crtype   get(TupleT const& t)    { return t.h; }
0281 };
0282 
0283 //////////////////////////////////
0284 template <typename TupleT>
0285 struct tuple_element<8, TupleT>
0286 {
0287     typedef typename TupleT::i_type type;
0288     typedef typename impl::access<type>::type rtype;
0289     typedef typename impl::access<type>::ctype crtype;
0290 
0291     static rtype    get(TupleT& t)          { return t.i; }
0292     static crtype   get(TupleT const& t)    { return t.i; }
0293 };
0294 
0295 #if PHOENIX_LIMIT > 9
0296 //////////////////////////////////
0297 template <typename TupleT>
0298 struct tuple_element<9, TupleT>
0299 {
0300     typedef typename TupleT::j_type type;
0301     typedef typename impl::access<type>::type rtype;
0302     typedef typename impl::access<type>::ctype crtype;
0303 
0304     static rtype    get(TupleT& t)          { return t.j; }
0305     static crtype   get(TupleT const& t)    { return t.j; }
0306 };
0307 
0308 //////////////////////////////////
0309 template <typename TupleT>
0310 struct tuple_element<10, TupleT>
0311 {
0312     typedef typename TupleT::k_type type;
0313     typedef typename impl::access<type>::type rtype;
0314     typedef typename impl::access<type>::ctype crtype;
0315 
0316     static rtype    get(TupleT& t)          { return t.k; }
0317     static crtype   get(TupleT const& t)    { return t.k; }
0318 };
0319 
0320 //////////////////////////////////
0321 template <typename TupleT>
0322 struct tuple_element<11, TupleT>
0323 {
0324     typedef typename TupleT::l_type type;
0325     typedef typename impl::access<type>::type rtype;
0326     typedef typename impl::access<type>::ctype crtype;
0327 
0328     static rtype    get(TupleT& t)          { return t.l; }
0329     static crtype   get(TupleT const& t)    { return t.l; }
0330 };
0331 
0332 #if PHOENIX_LIMIT > 12
0333 //////////////////////////////////
0334 template <typename TupleT>
0335 struct tuple_element<12, TupleT>
0336 {
0337     typedef typename TupleT::m_type type;
0338     typedef typename impl::access<type>::type rtype;
0339     typedef typename impl::access<type>::ctype crtype;
0340 
0341     static rtype    get(TupleT& t)          { return t.m; }
0342     static crtype   get(TupleT const& t)    { return t.m; }
0343 };
0344 
0345 //////////////////////////////////
0346 template <typename TupleT>
0347 struct tuple_element<13, TupleT>
0348 {
0349     typedef typename TupleT::n_type type;
0350     typedef typename impl::access<type>::type rtype;
0351     typedef typename impl::access<type>::ctype crtype;
0352 
0353     static rtype    get(TupleT& t)          { return t.n; }
0354     static crtype   get(TupleT const& t)    { return t.n; }
0355 };
0356 
0357 //////////////////////////////////
0358 template <typename TupleT>
0359 struct tuple_element<14, TupleT>
0360 {
0361     typedef typename TupleT::o_type type;
0362     typedef typename impl::access<type>::type rtype;
0363     typedef typename impl::access<type>::ctype crtype;
0364 
0365     static rtype    get(TupleT& t)          { return t.o; }
0366     static crtype   get(TupleT const& t)    { return t.o; }
0367 };
0368 
0369 #endif
0370 #endif
0371 #endif
0372 #endif
0373 
0374 ///////////////////////////////////////////////////////////////////////////////
0375 //
0376 //  tuple forward declaration.
0377 //
0378 ///////////////////////////////////////////////////////////////////////////////
0379 template <
0380         typename A = nil_t
0381     ,   typename B = nil_t
0382     ,   typename C = nil_t
0383 
0384 #if PHOENIX_LIMIT > 3
0385     ,   typename D = nil_t
0386     ,   typename E = nil_t
0387     ,   typename F = nil_t
0388 
0389 #if PHOENIX_LIMIT > 6
0390     ,   typename G = nil_t
0391     ,   typename H = nil_t
0392     ,   typename I = nil_t
0393 
0394 #if PHOENIX_LIMIT > 9
0395     ,   typename J = nil_t
0396     ,   typename K = nil_t
0397     ,   typename L = nil_t
0398 
0399 #if PHOENIX_LIMIT > 12
0400     ,   typename M = nil_t
0401     ,   typename N = nil_t
0402     ,   typename O = nil_t
0403 
0404 #endif
0405 #endif
0406 #endif
0407 #endif
0408 
0409     ,   typename NU = nil_t  // Not used
0410 >
0411 struct tuple;
0412 
0413 ///////////////////////////////////////////////////////////////////////////////
0414 //
0415 //  tuple_index
0416 //
0417 //      This class wraps an integer in a type to be used for indexing
0418 //      the Nth element in a tuple. See tuple operator[]. Some
0419 //      predefined names are provided in sub-namespace
0420 //      tuple_index_names.
0421 //
0422 ///////////////////////////////////////////////////////////////////////////////
0423 template <int N>
0424 struct tuple_index {};
0425 
0426 //////////////////////////////////
0427 namespace tuple_index_names {
0428 
0429     tuple_index<0> const _1 = tuple_index<0>();
0430     tuple_index<1> const _2 = tuple_index<1>();
0431     tuple_index<2> const _3 = tuple_index<2>();
0432 
0433 #if PHOENIX_LIMIT > 3
0434     tuple_index<3> const _4 = tuple_index<3>();
0435     tuple_index<4> const _5 = tuple_index<4>();
0436     tuple_index<5> const _6 = tuple_index<5>();
0437 
0438 #if PHOENIX_LIMIT > 6
0439     tuple_index<6> const _7 = tuple_index<6>();
0440     tuple_index<7> const _8 = tuple_index<7>();
0441     tuple_index<8> const _9 = tuple_index<8>();
0442 
0443 #if PHOENIX_LIMIT > 9
0444     tuple_index<9> const _10 = tuple_index<9>();
0445     tuple_index<10> const _11 = tuple_index<10>();
0446     tuple_index<11> const _12 = tuple_index<11>();
0447 
0448 #if PHOENIX_LIMIT > 12
0449     tuple_index<12> const _13 = tuple_index<12>();
0450     tuple_index<13> const _14 = tuple_index<13>();
0451     tuple_index<14> const _15 = tuple_index<14>();
0452 
0453 #endif
0454 #endif
0455 #endif
0456 #endif
0457 }
0458 
0459 ///////////////////////////////////////////////////////////////////////////////
0460 //
0461 //  tuple_common class
0462 //
0463 ///////////////////////////////////////////////////////////////////////////////
0464 template <typename DerivedT>
0465 struct tuple_base {
0466 
0467     typedef nil_t   a_type;
0468     typedef nil_t   b_type;
0469     typedef nil_t   c_type;
0470 
0471 #if PHOENIX_LIMIT > 3
0472     typedef nil_t   d_type;
0473     typedef nil_t   e_type;
0474     typedef nil_t   f_type;
0475 
0476 #if PHOENIX_LIMIT > 6
0477     typedef nil_t   g_type;
0478     typedef nil_t   h_type;
0479     typedef nil_t   i_type;
0480 
0481 #if PHOENIX_LIMIT > 9
0482     typedef nil_t   j_type;
0483     typedef nil_t   k_type;
0484     typedef nil_t   l_type;
0485 
0486 #if PHOENIX_LIMIT > 12
0487     typedef nil_t   m_type;
0488     typedef nil_t   n_type;
0489     typedef nil_t   o_type;
0490 
0491 #endif
0492 #endif
0493 #endif
0494 #endif
0495 
0496     template <int N>
0497     typename tuple_element<N, DerivedT>::crtype
0498     operator[](tuple_index<N>) const
0499     {
0500         return tuple_element<N, DerivedT>
0501             ::get(*static_cast<DerivedT const*>(this));
0502     }
0503 
0504     template <int N>
0505     typename tuple_element<N, DerivedT>::rtype
0506     operator[](tuple_index<N>)
0507     {
0508         return tuple_element<N, DerivedT>
0509             ::get(*static_cast<DerivedT*>(this));
0510     }
0511 };
0512 
0513 ///////////////////////////////////////////////////////////////////////////////
0514 //
0515 //  tuple <0 member> class
0516 //
0517 ///////////////////////////////////////////////////////////////////////////////
0518 template <>
0519 struct tuple<>
0520 :   public tuple_base<tuple<> > {
0521 
0522     BOOST_STATIC_CONSTANT(int, length = 0);
0523 };
0524 
0525 ///////////////////////////////////////////////////////////////////////////////
0526 //
0527 //  tuple <1 member> class
0528 //
0529 ///////////////////////////////////////////////////////////////////////////////
0530 template <typename A>
0531 struct tuple<A, nil_t, nil_t,
0532 #if PHOENIX_LIMIT > 3
0533     nil_t, nil_t, nil_t,
0534 #if PHOENIX_LIMIT > 6
0535     nil_t, nil_t, nil_t,
0536 #if PHOENIX_LIMIT > 9
0537     nil_t, nil_t, nil_t,
0538 #if PHOENIX_LIMIT > 12
0539     nil_t, nil_t, nil_t,
0540 #endif
0541 #endif
0542 #endif
0543 #endif
0544     nil_t   //  Unused
0545 >
0546 :   public tuple_base<tuple<A> > {
0547 
0548     BOOST_STATIC_CONSTANT(int, length = 1);
0549     typedef A a_type;
0550 
0551     tuple() {}
0552 
0553     tuple(
0554         typename call_traits<A>::param_type a_
0555     ):  a(a_) {}
0556 
0557     template <typename TupleT>
0558     tuple(TupleT const& init)
0559     :   a(init[tuple_index<0>()])
0560     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0561 
0562     A a;
0563 };
0564 
0565 ///////////////////////////////////////////////////////////////////////////////
0566 //
0567 //  tuple <2 member> class
0568 //
0569 ///////////////////////////////////////////////////////////////////////////////
0570 template <typename A, typename B>
0571 struct tuple<A, B, nil_t,
0572 #if PHOENIX_LIMIT > 3
0573     nil_t, nil_t, nil_t,
0574 #if PHOENIX_LIMIT > 6
0575     nil_t, nil_t, nil_t,
0576 #if PHOENIX_LIMIT > 9
0577     nil_t, nil_t, nil_t,
0578 #if PHOENIX_LIMIT > 12
0579     nil_t, nil_t, nil_t,
0580 #endif
0581 #endif
0582 #endif
0583 #endif
0584     nil_t   //  Unused
0585 >
0586 :   public tuple_base<tuple<A, B> > {
0587 
0588     BOOST_STATIC_CONSTANT(int, length = 2);
0589     typedef A a_type; typedef B b_type;
0590 
0591     tuple() {}
0592 
0593     tuple(
0594         typename call_traits<A>::param_type a_,
0595         typename call_traits<B>::param_type b_
0596     ):  a(a_), b(b_) {}
0597 
0598     template <typename TupleT>
0599     tuple(TupleT const& init)
0600     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()])
0601     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0602 
0603     A a; B b;
0604 };
0605 
0606 ///////////////////////////////////////////////////////////////////////////////
0607 //
0608 //  tuple <3 member> class
0609 //
0610 ///////////////////////////////////////////////////////////////////////////////
0611 template <typename A, typename B, typename C>
0612 struct tuple<A, B, C,
0613 #if PHOENIX_LIMIT > 3
0614     nil_t, nil_t, nil_t,
0615 #if PHOENIX_LIMIT > 6
0616     nil_t, nil_t, nil_t,
0617 #if PHOENIX_LIMIT > 9
0618     nil_t, nil_t, nil_t,
0619 #if PHOENIX_LIMIT > 12
0620     nil_t, nil_t, nil_t,
0621 #endif
0622 #endif
0623 #endif
0624 #endif
0625     nil_t   //  Unused
0626 >
0627 :   public tuple_base<tuple<A, B, C> > {
0628 
0629     BOOST_STATIC_CONSTANT(int, length = 3);
0630     typedef A a_type; typedef B b_type;
0631     typedef C c_type;
0632 
0633     tuple() {}
0634 
0635     tuple(
0636         typename call_traits<A>::param_type a_,
0637         typename call_traits<B>::param_type b_,
0638         typename call_traits<C>::param_type c_
0639     ):  a(a_), b(b_), c(c_) {}
0640 
0641     template <typename TupleT>
0642     tuple(TupleT const& init)
0643     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
0644         c(init[tuple_index<2>()])
0645     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0646 
0647     A a; B b; C c;
0648 };
0649 
0650 #if PHOENIX_LIMIT > 3
0651 ///////////////////////////////////////////////////////////////////////////////
0652 //
0653 //  tuple <4 member> class
0654 //
0655 ///////////////////////////////////////////////////////////////////////////////
0656 template <typename A, typename B, typename C, typename D>
0657 struct tuple<A, B, C, D, nil_t, nil_t,
0658 #if PHOENIX_LIMIT > 6
0659     nil_t, nil_t, nil_t,
0660 #if PHOENIX_LIMIT > 9
0661     nil_t, nil_t, nil_t,
0662 #if PHOENIX_LIMIT > 12
0663     nil_t, nil_t, nil_t,
0664 #endif
0665 #endif
0666 #endif
0667     nil_t   //  Unused
0668 >
0669 :   public tuple_base<tuple<A, B, C, D> > {
0670 
0671     BOOST_STATIC_CONSTANT(int, length = 4);
0672     typedef A a_type; typedef B b_type;
0673     typedef C c_type; typedef D d_type;
0674 
0675     tuple() {}
0676 
0677     tuple(
0678         typename call_traits<A>::param_type a_,
0679         typename call_traits<B>::param_type b_,
0680         typename call_traits<C>::param_type c_,
0681         typename call_traits<D>::param_type d_
0682     ):  a(a_), b(b_), c(c_), d(d_) {}
0683 
0684     template <typename TupleT>
0685     tuple(TupleT const& init)
0686     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
0687         c(init[tuple_index<2>()]), d(init[tuple_index<3>()])
0688     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0689 
0690     A a; B b; C c; D d;
0691 };
0692 
0693 ///////////////////////////////////////////////////////////////////////////////
0694 //
0695 //  tuple <5 member> class
0696 //
0697 ///////////////////////////////////////////////////////////////////////////////
0698 template <typename A, typename B, typename C, typename D, typename E>
0699 struct tuple<A, B, C, D, E, nil_t,
0700 #if PHOENIX_LIMIT > 6
0701     nil_t, nil_t, nil_t,
0702 #if PHOENIX_LIMIT > 9
0703     nil_t, nil_t, nil_t,
0704 #if PHOENIX_LIMIT > 12
0705     nil_t, nil_t, nil_t,
0706 #endif
0707 #endif
0708 #endif
0709     nil_t   //  Unused
0710 >
0711 :   public tuple_base<tuple<A, B, C, D, E> > {
0712 
0713     BOOST_STATIC_CONSTANT(int, length = 5);
0714     typedef A a_type; typedef B b_type;
0715     typedef C c_type; typedef D d_type;
0716     typedef E e_type;
0717 
0718     tuple() {}
0719 
0720     tuple(
0721         typename call_traits<A>::param_type a_,
0722         typename call_traits<B>::param_type b_,
0723         typename call_traits<C>::param_type c_,
0724         typename call_traits<D>::param_type d_,
0725         typename call_traits<E>::param_type e_
0726     ):  a(a_), b(b_), c(c_), d(d_), e(e_) {}
0727 
0728     template <typename TupleT>
0729     tuple(TupleT const& init)
0730     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
0731         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
0732         e(init[tuple_index<4>()])
0733     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0734 
0735     A a; B b; C c; D d; E e;
0736 };
0737 
0738 ///////////////////////////////////////////////////////////////////////////////
0739 //
0740 //  tuple <6 member> class
0741 //
0742 ///////////////////////////////////////////////////////////////////////////////
0743 template <
0744     typename A, typename B, typename C, typename D, typename E,
0745     typename F>
0746 struct tuple<A, B, C, D, E, F,
0747 #if PHOENIX_LIMIT > 6
0748     nil_t, nil_t, nil_t,
0749 #if PHOENIX_LIMIT > 9
0750     nil_t, nil_t, nil_t,
0751 #if PHOENIX_LIMIT > 12
0752     nil_t, nil_t, nil_t,
0753 #endif
0754 #endif
0755 #endif
0756     nil_t   //  Unused
0757 >
0758 :   public tuple_base<tuple<A, B, C, D, E, F> > {
0759 
0760     BOOST_STATIC_CONSTANT(int, length = 6);
0761     typedef A a_type; typedef B b_type;
0762     typedef C c_type; typedef D d_type;
0763     typedef E e_type; typedef F f_type;
0764 
0765     tuple() {}
0766 
0767     tuple(
0768         typename call_traits<A>::param_type a_,
0769         typename call_traits<B>::param_type b_,
0770         typename call_traits<C>::param_type c_,
0771         typename call_traits<D>::param_type d_,
0772         typename call_traits<E>::param_type e_,
0773         typename call_traits<F>::param_type f_
0774     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
0775         f(f_) {}
0776 
0777     template <typename TupleT>
0778     tuple(TupleT const& init)
0779     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
0780         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
0781         e(init[tuple_index<4>()]), f(init[tuple_index<5>()])
0782     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0783 
0784     A a; B b; C c; D d; E e;
0785     F f;
0786 };
0787 
0788 #if PHOENIX_LIMIT > 6
0789 ///////////////////////////////////////////////////////////////////////////////
0790 //
0791 //  tuple <7 member> class
0792 //
0793 ///////////////////////////////////////////////////////////////////////////////
0794 template <
0795     typename A, typename B, typename C, typename D, typename E,
0796     typename F, typename G>
0797 struct tuple<A, B, C, D, E, F, G, nil_t, nil_t,
0798 #if PHOENIX_LIMIT > 9
0799     nil_t, nil_t, nil_t,
0800 #if PHOENIX_LIMIT > 12
0801     nil_t, nil_t, nil_t,
0802 #endif
0803 #endif
0804     nil_t   //  Unused
0805 >
0806 :   public tuple_base<tuple<A, B, C, D, E, F, G> > {
0807 
0808     BOOST_STATIC_CONSTANT(int, length = 7);
0809     typedef A a_type; typedef B b_type;
0810     typedef C c_type; typedef D d_type;
0811     typedef E e_type; typedef F f_type;
0812     typedef G g_type;
0813 
0814     tuple() {}
0815 
0816     tuple(
0817         typename call_traits<A>::param_type a_,
0818         typename call_traits<B>::param_type b_,
0819         typename call_traits<C>::param_type c_,
0820         typename call_traits<D>::param_type d_,
0821         typename call_traits<E>::param_type e_,
0822         typename call_traits<F>::param_type f_,
0823         typename call_traits<G>::param_type g_
0824     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
0825         f(f_), g(g_) {}
0826 
0827     template <typename TupleT>
0828     tuple(TupleT const& init)
0829     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
0830         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
0831         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
0832         g(init[tuple_index<6>()])
0833     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0834 
0835     A a; B b; C c; D d; E e;
0836     F f; G g;
0837 };
0838 
0839 ///////////////////////////////////////////////////////////////////////////////
0840 //
0841 //  tuple <8 member> class
0842 //
0843 ///////////////////////////////////////////////////////////////////////////////
0844 template <
0845     typename A, typename B, typename C, typename D, typename E,
0846     typename F, typename G, typename H>
0847 struct tuple<A, B, C, D, E, F, G, H, nil_t,
0848 #if PHOENIX_LIMIT > 9
0849     nil_t, nil_t, nil_t,
0850 #if PHOENIX_LIMIT > 12
0851     nil_t, nil_t, nil_t,
0852 #endif
0853 #endif
0854     nil_t   //  Unused
0855 >
0856 :   public tuple_base<tuple<A, B, C, D, E, F, G, H> > {
0857 
0858     BOOST_STATIC_CONSTANT(int, length = 8);
0859     typedef A a_type; typedef B b_type;
0860     typedef C c_type; typedef D d_type;
0861     typedef E e_type; typedef F f_type;
0862     typedef G g_type; typedef H h_type;
0863 
0864     tuple() {}
0865 
0866     tuple(
0867         typename call_traits<A>::param_type a_,
0868         typename call_traits<B>::param_type b_,
0869         typename call_traits<C>::param_type c_,
0870         typename call_traits<D>::param_type d_,
0871         typename call_traits<E>::param_type e_,
0872         typename call_traits<F>::param_type f_,
0873         typename call_traits<G>::param_type g_,
0874         typename call_traits<H>::param_type h_
0875     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
0876         f(f_), g(g_), h(h_) {}
0877 
0878     template <typename TupleT>
0879     tuple(TupleT const& init)
0880     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
0881         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
0882         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
0883         g(init[tuple_index<6>()]), h(init[tuple_index<7>()])
0884     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0885 
0886     A a; B b; C c; D d; E e;
0887     F f; G g; H h;
0888 };
0889 
0890 ///////////////////////////////////////////////////////////////////////////////
0891 //
0892 //  tuple <9 member> class
0893 //
0894 ///////////////////////////////////////////////////////////////////////////////
0895 template <
0896     typename A, typename B, typename C, typename D, typename E,
0897     typename F, typename G, typename H, typename I>
0898 struct tuple<A, B, C, D, E, F, G, H, I,
0899 #if PHOENIX_LIMIT > 9
0900     nil_t, nil_t, nil_t,
0901 #if PHOENIX_LIMIT > 12
0902     nil_t, nil_t, nil_t,
0903 #endif
0904 #endif
0905     nil_t   //  Unused
0906 >
0907 :   public tuple_base<tuple<A, B, C, D, E, F, G, H, I> > {
0908 
0909     BOOST_STATIC_CONSTANT(int, length = 9);
0910     typedef A a_type; typedef B b_type;
0911     typedef C c_type; typedef D d_type;
0912     typedef E e_type; typedef F f_type;
0913     typedef G g_type; typedef H h_type;
0914     typedef I i_type;
0915 
0916     tuple() {}
0917 
0918     tuple(
0919         typename call_traits<A>::param_type a_,
0920         typename call_traits<B>::param_type b_,
0921         typename call_traits<C>::param_type c_,
0922         typename call_traits<D>::param_type d_,
0923         typename call_traits<E>::param_type e_,
0924         typename call_traits<F>::param_type f_,
0925         typename call_traits<G>::param_type g_,
0926         typename call_traits<H>::param_type h_,
0927         typename call_traits<I>::param_type i_
0928     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
0929         f(f_), g(g_), h(h_), i(i_) {}
0930 
0931     template <typename TupleT>
0932     tuple(TupleT const& init)
0933     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
0934         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
0935         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
0936         g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
0937         i(init[tuple_index<8>()])
0938     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0939 
0940     A a; B b; C c; D d; E e;
0941     F f; G g; H h; I i;
0942 };
0943 
0944 #if PHOENIX_LIMIT > 9
0945 ///////////////////////////////////////////////////////////////////////////////
0946 //
0947 //  tuple <10 member> class
0948 //
0949 ///////////////////////////////////////////////////////////////////////////////
0950 template <
0951     typename A, typename B, typename C, typename D, typename E,
0952     typename F, typename G, typename H, typename I, typename J>
0953 struct tuple<A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
0954 #if PHOENIX_LIMIT > 12
0955     nil_t, nil_t, nil_t,
0956 #endif
0957     nil_t   //  Unused
0958 >
0959 :   public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J> > {
0960 
0961     BOOST_STATIC_CONSTANT(int, length = 10);
0962     typedef A a_type; typedef B b_type;
0963     typedef C c_type; typedef D d_type;
0964     typedef E e_type; typedef F f_type;
0965     typedef G g_type; typedef H h_type;
0966     typedef I i_type; typedef J j_type;
0967 
0968     tuple() {}
0969 
0970     tuple(
0971         typename call_traits<A>::param_type a_,
0972         typename call_traits<B>::param_type b_,
0973         typename call_traits<C>::param_type c_,
0974         typename call_traits<D>::param_type d_,
0975         typename call_traits<E>::param_type e_,
0976         typename call_traits<F>::param_type f_,
0977         typename call_traits<G>::param_type g_,
0978         typename call_traits<H>::param_type h_,
0979         typename call_traits<I>::param_type i_,
0980         typename call_traits<J>::param_type j_
0981     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
0982         f(f_), g(g_), h(h_), i(i_), j(j_) {}
0983 
0984     template <typename TupleT>
0985     tuple(TupleT const& init)
0986     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
0987         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
0988         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
0989         g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
0990         i(init[tuple_index<8>()]), j(init[tuple_index<9>()])
0991     { BOOST_STATIC_ASSERT(TupleT::length == length); }
0992 
0993     A a; B b; C c; D d; E e;
0994     F f; G g; H h; I i; J j;
0995 };
0996 
0997 ///////////////////////////////////////////////////////////////////////////////
0998 //
0999 //  tuple <11 member> class
1000 //
1001 ///////////////////////////////////////////////////////////////////////////////
1002 template <
1003     typename A, typename B, typename C, typename D, typename E,
1004     typename F, typename G, typename H, typename I, typename J,
1005     typename K>
1006 struct tuple<A, B, C, D, E, F, G, H, I, J, K, nil_t,
1007 #if PHOENIX_LIMIT > 12
1008     nil_t, nil_t, nil_t,
1009 #endif
1010     nil_t   //  Unused
1011 >
1012 :   public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J, K> > {
1013 
1014     BOOST_STATIC_CONSTANT(int, length = 11);
1015     typedef A a_type; typedef B b_type;
1016     typedef C c_type; typedef D d_type;
1017     typedef E e_type; typedef F f_type;
1018     typedef G g_type; typedef H h_type;
1019     typedef I i_type; typedef J j_type;
1020     typedef K k_type;
1021 
1022     tuple() {}
1023 
1024     tuple(
1025         typename call_traits<A>::param_type a_,
1026         typename call_traits<B>::param_type b_,
1027         typename call_traits<C>::param_type c_,
1028         typename call_traits<D>::param_type d_,
1029         typename call_traits<E>::param_type e_,
1030         typename call_traits<F>::param_type f_,
1031         typename call_traits<G>::param_type g_,
1032         typename call_traits<H>::param_type h_,
1033         typename call_traits<I>::param_type i_,
1034         typename call_traits<J>::param_type j_,
1035         typename call_traits<K>::param_type k_
1036     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
1037         f(f_), g(g_), h(h_), i(i_), j(j_),
1038         k(k_) {}
1039 
1040     template <typename TupleT>
1041     tuple(TupleT const& init)
1042     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1043         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1044         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1045         g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1046         i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1047         k(init[tuple_index<10>()])
1048     { BOOST_STATIC_ASSERT(TupleT::length == length); }
1049 
1050     A a; B b; C c; D d; E e;
1051     F f; G g; H h; I i; J j;
1052     K k;
1053 };
1054 
1055 ///////////////////////////////////////////////////////////////////////////////
1056 //
1057 //  tuple <12 member> class
1058 //
1059 ///////////////////////////////////////////////////////////////////////////////
1060 template <
1061     typename A, typename B, typename C, typename D, typename E,
1062     typename F, typename G, typename H, typename I, typename J,
1063     typename K, typename L>
1064 struct tuple<A, B, C, D, E, F, G, H, I, J, K, L,
1065 #if PHOENIX_LIMIT > 12
1066     nil_t, nil_t, nil_t,
1067 #endif
1068     nil_t   //  Unused
1069 >
1070 :   public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J, K, L> > {
1071 
1072     BOOST_STATIC_CONSTANT(int, length = 12);
1073     typedef A a_type; typedef B b_type;
1074     typedef C c_type; typedef D d_type;
1075     typedef E e_type; typedef F f_type;
1076     typedef G g_type; typedef H h_type;
1077     typedef I i_type; typedef J j_type;
1078     typedef K k_type; typedef L l_type;
1079 
1080     tuple() {}
1081 
1082     tuple(
1083         typename call_traits<A>::param_type a_,
1084         typename call_traits<B>::param_type b_,
1085         typename call_traits<C>::param_type c_,
1086         typename call_traits<D>::param_type d_,
1087         typename call_traits<E>::param_type e_,
1088         typename call_traits<F>::param_type f_,
1089         typename call_traits<G>::param_type g_,
1090         typename call_traits<H>::param_type h_,
1091         typename call_traits<I>::param_type i_,
1092         typename call_traits<J>::param_type j_,
1093         typename call_traits<K>::param_type k_,
1094         typename call_traits<L>::param_type l_
1095     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
1096         f(f_), g(g_), h(h_), i(i_), j(j_),
1097         k(k_), l(l_) {}
1098 
1099     template <typename TupleT>
1100     tuple(TupleT const& init)
1101     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1102         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1103         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1104         g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1105         i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1106         k(init[tuple_index<10>()]), l(init[tuple_index<11>()])
1107     { BOOST_STATIC_ASSERT(TupleT::length == length); }
1108 
1109     A a; B b; C c; D d; E e;
1110     F f; G g; H h; I i; J j;
1111     K k; L l;
1112 };
1113 
1114 #if PHOENIX_LIMIT > 12
1115 ///////////////////////////////////////////////////////////////////////////////
1116 //
1117 //  tuple <13 member> class
1118 //
1119 ///////////////////////////////////////////////////////////////////////////////
1120 template <
1121     typename A, typename B, typename C, typename D, typename E,
1122     typename F, typename G, typename H, typename I, typename J,
1123     typename K, typename L, typename M>
1124 struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t>
1125 :   public tuple_base<
1126         tuple<A, B, C, D, E, F, G, H, I, J, K, L, M> > {
1127 
1128     BOOST_STATIC_CONSTANT(int, length = 13);
1129     typedef A a_type; typedef B b_type;
1130     typedef C c_type; typedef D d_type;
1131     typedef E e_type; typedef F f_type;
1132     typedef G g_type; typedef H h_type;
1133     typedef I i_type; typedef J j_type;
1134     typedef K k_type; typedef L l_type;
1135     typedef M m_type;
1136 
1137     tuple() {}
1138 
1139     tuple(
1140         typename call_traits<A>::param_type a_,
1141         typename call_traits<B>::param_type b_,
1142         typename call_traits<C>::param_type c_,
1143         typename call_traits<D>::param_type d_,
1144         typename call_traits<E>::param_type e_,
1145         typename call_traits<F>::param_type f_,
1146         typename call_traits<G>::param_type g_,
1147         typename call_traits<H>::param_type h_,
1148         typename call_traits<I>::param_type i_,
1149         typename call_traits<J>::param_type j_,
1150         typename call_traits<K>::param_type k_,
1151         typename call_traits<L>::param_type l_,
1152         typename call_traits<M>::param_type m_
1153     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
1154         f(f_), g(g_), h(h_), i(i_), j(j_),
1155         k(k_), l(l_), m(m_) {}
1156 
1157     template <typename TupleT>
1158     tuple(TupleT const& init)
1159     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1160         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1161         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1162         g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1163         i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1164         k(init[tuple_index<10>()]), l(init[tuple_index<11>()]),
1165         m(init[tuple_index<12>()])
1166     { BOOST_STATIC_ASSERT(TupleT::length == length); }
1167 
1168     A a; B b; C c; D d; E e;
1169     F f; G g; H h; I i; J j;
1170     K k; L l; M m;
1171 };
1172 
1173 ///////////////////////////////////////////////////////////////////////////////
1174 //
1175 //  tuple <14 member> class
1176 //
1177 ///////////////////////////////////////////////////////////////////////////////
1178 template <
1179     typename A, typename B, typename C, typename D, typename E,
1180     typename F, typename G, typename H, typename I, typename J,
1181     typename K, typename L, typename M, typename N>
1182 struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t>
1183 :   public tuple_base<
1184         tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N> > {
1185 
1186     BOOST_STATIC_CONSTANT(int, length = 14);
1187     typedef A a_type; typedef B b_type;
1188     typedef C c_type; typedef D d_type;
1189     typedef E e_type; typedef F f_type;
1190     typedef G g_type; typedef H h_type;
1191     typedef I i_type; typedef J j_type;
1192     typedef K k_type; typedef L l_type;
1193     typedef M m_type; typedef N n_type;
1194 
1195     tuple() {}
1196 
1197     tuple(
1198         typename call_traits<A>::param_type a_,
1199         typename call_traits<B>::param_type b_,
1200         typename call_traits<C>::param_type c_,
1201         typename call_traits<D>::param_type d_,
1202         typename call_traits<E>::param_type e_,
1203         typename call_traits<F>::param_type f_,
1204         typename call_traits<G>::param_type g_,
1205         typename call_traits<H>::param_type h_,
1206         typename call_traits<I>::param_type i_,
1207         typename call_traits<J>::param_type j_,
1208         typename call_traits<K>::param_type k_,
1209         typename call_traits<L>::param_type l_,
1210         typename call_traits<M>::param_type m_,
1211         typename call_traits<N>::param_type n_
1212     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
1213         f(f_), g(g_), h(h_), i(i_), j(j_),
1214         k(k_), l(l_), m(m_), n(n_) {}
1215 
1216     template <typename TupleT>
1217     tuple(TupleT const& init)
1218     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1219         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1220         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1221         g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1222         i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1223         k(init[tuple_index<10>()]), l(init[tuple_index<11>()]),
1224         m(init[tuple_index<12>()]), n(init[tuple_index<13>()])
1225     { BOOST_STATIC_ASSERT(TupleT::length == length); }
1226 
1227     A a; B b; C c; D d; E e;
1228     F f; G g; H h; I i; J j;
1229     K k; L l; M m; N n;
1230 };
1231 
1232 ///////////////////////////////////////////////////////////////////////////////
1233 //
1234 //  tuple <15 member> class
1235 //
1236 ///////////////////////////////////////////////////////////////////////////////
1237 template <
1238     typename A, typename B, typename C, typename D, typename E,
1239     typename F, typename G, typename H, typename I, typename J,
1240     typename K, typename L, typename M, typename N, typename O>
1241 struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t>
1242 :   public tuple_base<
1243         tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> > {
1244 
1245     BOOST_STATIC_CONSTANT(int, length = 15);
1246     typedef A a_type; typedef B b_type;
1247     typedef C c_type; typedef D d_type;
1248     typedef E e_type; typedef F f_type;
1249     typedef G g_type; typedef H h_type;
1250     typedef I i_type; typedef J j_type;
1251     typedef K k_type; typedef L l_type;
1252     typedef M m_type; typedef N n_type;
1253     typedef O o_type;
1254 
1255     tuple() {}
1256 
1257     tuple(
1258         typename call_traits<A>::param_type a_,
1259         typename call_traits<B>::param_type b_,
1260         typename call_traits<C>::param_type c_,
1261         typename call_traits<D>::param_type d_,
1262         typename call_traits<E>::param_type e_,
1263         typename call_traits<F>::param_type f_,
1264         typename call_traits<G>::param_type g_,
1265         typename call_traits<H>::param_type h_,
1266         typename call_traits<I>::param_type i_,
1267         typename call_traits<J>::param_type j_,
1268         typename call_traits<K>::param_type k_,
1269         typename call_traits<L>::param_type l_,
1270         typename call_traits<M>::param_type m_,
1271         typename call_traits<N>::param_type n_,
1272         typename call_traits<O>::param_type o_
1273     ):  a(a_), b(b_), c(c_), d(d_), e(e_),
1274         f(f_), g(g_), h(h_), i(i_), j(j_),
1275         k(k_), l(l_), m(m_), n(n_), o(o_) {}
1276 
1277     template <typename TupleT>
1278     tuple(TupleT const& init)
1279     :   a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1280         c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1281         e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1282         g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1283         i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1284         k(init[tuple_index<10>()]), l(init[tuple_index<11>()]),
1285         m(init[tuple_index<12>()]), n(init[tuple_index<13>()]),
1286         o(init[tuple_index<14>()])
1287     { BOOST_STATIC_ASSERT(TupleT::length == length); }
1288 
1289     A a; B b; C c; D d; E e;
1290     F f; G g; H h; I i; J j;
1291     K k; L l; M m; N n; O o;
1292 };
1293 
1294 #endif
1295 #endif
1296 #endif
1297 #endif
1298 
1299 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
1300 #pragma warning(pop)
1301 #endif
1302 
1303 ///////////////////////////////////////////////////////////////////////////////
1304 }   //  namespace phoenix
1305 
1306 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!