1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/ossrv_pub/boost_apis/boost/spirit/phoenix/tuples.hpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1330 @@
1.4 +/*=============================================================================
1.5 + Phoenix V1.2.1
1.6 + Copyright (c) 2001-2002 Joel de Guzman
1.7 +
1.8 + Use, modification and distribution is subject to the Boost Software
1.9 + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
1.10 + http://www.boost.org/LICENSE_1_0.txt)
1.11 +==============================================================================*/
1.12 +#ifndef PHOENIX_TUPLES_HPP
1.13 +#define PHOENIX_TUPLES_HPP
1.14 +
1.15 +#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
1.16 +#error "Sorry, Phoenix does not support VC6 and VC7. Please upgrade to at least VC7.1"
1.17 +#endif
1.18 +
1.19 +///////////////////////////////////////////////////////////////////////////////
1.20 +//
1.21 +// Phoenix predefined maximum limit. This limit defines the maximum
1.22 +// number of elements a tuple can hold. This number defaults to 3. The
1.23 +// actual maximum is rounded up in multiples of 3. Thus, if this value
1.24 +// is 4, the actual limit is 6. The ultimate maximum limit in this
1.25 +// implementation is 15.
1.26 +//
1.27 +///////////////////////////////////////////////////////////////////////////////
1.28 +#ifndef PHOENIX_LIMIT
1.29 +#define PHOENIX_LIMIT 3
1.30 +#endif
1.31 +
1.32 +#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x561)
1.33 +namespace phoenix { namespace borland_only
1.34 +{
1.35 + namespace ftors
1.36 + {
1.37 + // We define these dummy template functions. Borland complains when
1.38 + // a template class has the same name as a template function,
1.39 + // regardless if they are in different namespaces.
1.40 +
1.41 + template <typename T> void if_(T) {}
1.42 + template <typename T> void for_(T) {}
1.43 + template <typename T> void while_(T) {}
1.44 + template <typename T> void do_(T) {}
1.45 + }
1.46 +
1.47 + namespace tmpls
1.48 + {
1.49 + // We define these dummy template functions. Borland complains when
1.50 + // a template class has the same name as a template function,
1.51 + // regardless if they are in different namespaces.
1.52 +
1.53 + template <typename T> struct if_ {};
1.54 + template <typename T> struct for_ {};
1.55 + template <typename T> struct while_ {};
1.56 + template <typename T> struct do_ {};
1.57 + }
1.58 +
1.59 +}} // namespace phoenix::borland_only
1.60 +#endif
1.61 +
1.62 +///////////////////////////////////////////////////////////////////////////////
1.63 +#include <boost/static_assert.hpp>
1.64 +#include <boost/call_traits.hpp>
1.65 +#include <boost/type_traits/remove_reference.hpp>
1.66 +
1.67 +///////////////////////////////////////////////////////////////////////////////
1.68 +namespace phoenix {
1.69 +
1.70 +///////////////////////////////////////////////////////////////////////////////
1.71 +//
1.72 +// tuple
1.73 +//
1.74 +// Tuples hold heterogeneous types up to a predefined maximum. Only
1.75 +// the most basic functionality needed is provided. Unlike other
1.76 +// recursive list-like tuple implementations, this tuple
1.77 +// implementation uses simple structs similar to std::pair with
1.78 +// specialization for 0 to N tuple elements.
1.79 +//
1.80 +// 1) Construction
1.81 +// Here are examples on how to construct tuples:
1.82 +//
1.83 +// typedef tuple<int, char> t1_t;
1.84 +// typedef tuple<int, std::string, double> t2_t;
1.85 +//
1.86 +// // this tuple has an int and char members
1.87 +// t1_t t1(3, 'c');
1.88 +//
1.89 +// // this tuple has an int, std::string and double members
1.90 +// t2_t t2(3, "hello", 3.14);
1.91 +//
1.92 +// Tuples can also be constructed from other tuples. The
1.93 +// source and destination tuples need not have exactly the
1.94 +// same element types. The only requirement is that the
1.95 +// source tuple have the same number of elements as the
1.96 +// destination and that each element slot in the
1.97 +// destination can be copy constructed from the source
1.98 +// element. For example:
1.99 +//
1.100 +// tuple<double, double> t3(t1); // OK. Compatible tuples
1.101 +// tuple<double, double> t4(t2); // Error! Incompatible tuples
1.102 +//
1.103 +// 2) Member access
1.104 +// A member in a tuple can be accessed using the
1.105 +// tuple's [] operator by specifying the Nth
1.106 +// tuple_index. Here are some examples:
1.107 +//
1.108 +// tuple_index<0> ix0; // 0th index == 1st item
1.109 +// tuple_index<1> ix1; // 1st index == 2nd item
1.110 +// tuple_index<2> ix2; // 2nd index == 3rd item
1.111 +//
1.112 +// t1[ix0] = 33; // sets the int member of the tuple t1
1.113 +// t2[ix2] = 6e6; // sets the double member of the tuple t2
1.114 +// t1[ix1] = 'a'; // sets the char member of the tuple t1
1.115 +//
1.116 +// There are some predefined names are provided in sub-
1.117 +// namespace tuple_index_names:
1.118 +//
1.119 +// tuple_index<0> _1;
1.120 +// tuple_index<1> _2;
1.121 +// ...
1.122 +// tuple_index<N> _N;
1.123 +//
1.124 +// These indexes may be used by 'using' namespace
1.125 +// phoenix::tuple_index_names.
1.126 +//
1.127 +// Access to out of bound indexes returns a nil_t value.
1.128 +//
1.129 +// 3) Member type inquiry
1.130 +// The type of an individual member can be queried.
1.131 +// Example:
1.132 +//
1.133 +// tuple_element<1, t2_t>::type
1.134 +//
1.135 +// Refers to the type of the second member (note zero based,
1.136 +// thus 0 = 1st item, 1 = 2nd item) of the tuple.
1.137 +//
1.138 +// Aside from tuple_element<N, T>::type, there are two
1.139 +// more types that tuple_element provides: rtype and
1.140 +// crtype. While 'type' is the plain underlying type,
1.141 +// 'rtype' is the reference type, or type& and 'crtype'
1.142 +// is the constant reference type or type const&. The
1.143 +// latter two are provided to make it easy for the
1.144 +// client in dealing with the possibility of reference
1.145 +// to reference when type is already a reference, which
1.146 +// is illegal in C++.
1.147 +//
1.148 +// Access to out of bound indexes returns a nil_t type.
1.149 +//
1.150 +// 4) Tuple length
1.151 +// The number of elements in a tuple can be queried.
1.152 +// Example:
1.153 +//
1.154 +// int n = t1.length;
1.155 +//
1.156 +// gets the number of elements in tuple t1.
1.157 +//
1.158 +// length is a static constant. Thus, TupleT::length
1.159 +// also works. Example:
1.160 +//
1.161 +// int n = t1_t::length;
1.162 +//
1.163 +///////////////////////////////////////////////////////////////////////////////
1.164 +struct nil_t {};
1.165 +using boost::remove_reference;
1.166 +using boost::call_traits;
1.167 +
1.168 +//////////////////////////////////
1.169 +namespace impl {
1.170 +
1.171 + template <typename T>
1.172 + struct access {
1.173 +
1.174 + typedef const T& ctype;
1.175 + typedef T& type;
1.176 + };
1.177 +
1.178 + template <typename T>
1.179 + struct access<T&> {
1.180 +
1.181 + typedef T& ctype;
1.182 + typedef T& type;
1.183 + };
1.184 +}
1.185 +
1.186 +///////////////////////////////////////////////////////////////////////////////
1.187 +//
1.188 +// tuple_element
1.189 +//
1.190 +// A query class that gets the Nth element inside a tuple.
1.191 +// Examples:
1.192 +//
1.193 +// tuple_element<1, tuple<int, char, void*> >::type // plain
1.194 +// tuple_element<1, tuple<int, char, void*> >::rtype // ref
1.195 +// tuple_element<1, tuple<int, char, void*> >::crtype // const ref
1.196 +//
1.197 +// Has type char which is the 2nd type in the tuple
1.198 +// (note zero based, thus 0 = 1st item, 1 = 2nd item).
1.199 +//
1.200 +// Given a tuple object, the static function tuple_element<N,
1.201 +// TupleT>::get(tuple) gets the Nth element in the tuple. The
1.202 +// tuple class' tuple::operator[] uses this to get its Nth
1.203 +// element.
1.204 +//
1.205 +///////////////////////////////////////////////////////////////////////////////
1.206 +template <int N, typename TupleT>
1.207 +struct tuple_element
1.208 +{
1.209 + typedef nil_t type;
1.210 + typedef nil_t& rtype;
1.211 + typedef nil_t const& crtype;
1.212 +
1.213 + static nil_t get(TupleT const& t) { return nil_t(); }
1.214 +};
1.215 +
1.216 +//////////////////////////////////
1.217 +template <typename TupleT>
1.218 +struct tuple_element<0, TupleT>
1.219 +{
1.220 + typedef typename TupleT::a_type type;
1.221 + typedef typename impl::access<type>::type rtype;
1.222 + typedef typename impl::access<type>::ctype crtype;
1.223 +
1.224 + static rtype get(TupleT& t) { return t.a; }
1.225 + static crtype get(TupleT const& t) { return t.a; }
1.226 +};
1.227 +
1.228 +//////////////////////////////////
1.229 +template <typename TupleT>
1.230 +struct tuple_element<1, TupleT>
1.231 +{
1.232 + typedef typename TupleT::b_type type;
1.233 + typedef typename impl::access<type>::type rtype;
1.234 + typedef typename impl::access<type>::ctype crtype;
1.235 +
1.236 + static rtype get(TupleT& t) { return t.b; }
1.237 + static crtype get(TupleT const& t) { return t.b; }
1.238 +};
1.239 +
1.240 +//////////////////////////////////
1.241 +template <typename TupleT>
1.242 +struct tuple_element<2, TupleT>
1.243 +{
1.244 + typedef typename TupleT::c_type type;
1.245 + typedef typename impl::access<type>::type rtype;
1.246 + typedef typename impl::access<type>::ctype crtype;
1.247 +
1.248 + static rtype get(TupleT& t) { return t.c; }
1.249 + static crtype get(TupleT const& t) { return t.c; }
1.250 +};
1.251 +
1.252 +#if PHOENIX_LIMIT > 3
1.253 +//////////////////////////////////
1.254 +template <typename TupleT>
1.255 +struct tuple_element<3, TupleT>
1.256 +{
1.257 + typedef typename TupleT::d_type type;
1.258 + typedef typename impl::access<type>::type rtype;
1.259 + typedef typename impl::access<type>::ctype crtype;
1.260 +
1.261 + static rtype get(TupleT& t) { return t.d; }
1.262 + static crtype get(TupleT const& t) { return t.d; }
1.263 +};
1.264 +
1.265 +//////////////////////////////////
1.266 +template <typename TupleT>
1.267 +struct tuple_element<4, TupleT>
1.268 +{
1.269 + typedef typename TupleT::e_type type;
1.270 + typedef typename impl::access<type>::type rtype;
1.271 + typedef typename impl::access<type>::ctype crtype;
1.272 +
1.273 + static rtype get(TupleT& t) { return t.e; }
1.274 + static crtype get(TupleT const& t) { return t.e; }
1.275 +};
1.276 +
1.277 +//////////////////////////////////
1.278 +template <typename TupleT>
1.279 +struct tuple_element<5, TupleT>
1.280 +{
1.281 + typedef typename TupleT::f_type type;
1.282 + typedef typename impl::access<type>::type rtype;
1.283 + typedef typename impl::access<type>::ctype crtype;
1.284 +
1.285 + static rtype get(TupleT& t) { return t.f; }
1.286 + static crtype get(TupleT const& t) { return t.f; }
1.287 +};
1.288 +
1.289 +#if PHOENIX_LIMIT > 6
1.290 +//////////////////////////////////
1.291 +template <typename TupleT>
1.292 +struct tuple_element<6, TupleT>
1.293 +{
1.294 + typedef typename TupleT::g_type type;
1.295 + typedef typename impl::access<type>::type rtype;
1.296 + typedef typename impl::access<type>::ctype crtype;
1.297 +
1.298 + static rtype get(TupleT& t) { return t.g; }
1.299 + static crtype get(TupleT const& t) { return t.g; }
1.300 +};
1.301 +
1.302 +//////////////////////////////////
1.303 +template <typename TupleT>
1.304 +struct tuple_element<7, TupleT>
1.305 +{
1.306 + typedef typename TupleT::h_type type;
1.307 + typedef typename impl::access<type>::type rtype;
1.308 + typedef typename impl::access<type>::ctype crtype;
1.309 +
1.310 + static rtype get(TupleT& t) { return t.h; }
1.311 + static crtype get(TupleT const& t) { return t.h; }
1.312 +};
1.313 +
1.314 +//////////////////////////////////
1.315 +template <typename TupleT>
1.316 +struct tuple_element<8, TupleT>
1.317 +{
1.318 + typedef typename TupleT::i_type type;
1.319 + typedef typename impl::access<type>::type rtype;
1.320 + typedef typename impl::access<type>::ctype crtype;
1.321 +
1.322 + static rtype get(TupleT& t) { return t.i; }
1.323 + static crtype get(TupleT const& t) { return t.i; }
1.324 +};
1.325 +
1.326 +#if PHOENIX_LIMIT > 9
1.327 +//////////////////////////////////
1.328 +template <typename TupleT>
1.329 +struct tuple_element<9, TupleT>
1.330 +{
1.331 + typedef typename TupleT::j_type type;
1.332 + typedef typename impl::access<type>::type rtype;
1.333 + typedef typename impl::access<type>::ctype crtype;
1.334 +
1.335 + static rtype get(TupleT& t) { return t.j; }
1.336 + static crtype get(TupleT const& t) { return t.j; }
1.337 +};
1.338 +
1.339 +//////////////////////////////////
1.340 +template <typename TupleT>
1.341 +struct tuple_element<10, TupleT>
1.342 +{
1.343 + typedef typename TupleT::k_type type;
1.344 + typedef typename impl::access<type>::type rtype;
1.345 + typedef typename impl::access<type>::ctype crtype;
1.346 +
1.347 + static rtype get(TupleT& t) { return t.k; }
1.348 + static crtype get(TupleT const& t) { return t.k; }
1.349 +};
1.350 +
1.351 +//////////////////////////////////
1.352 +template <typename TupleT>
1.353 +struct tuple_element<11, TupleT>
1.354 +{
1.355 + typedef typename TupleT::l_type type;
1.356 + typedef typename impl::access<type>::type rtype;
1.357 + typedef typename impl::access<type>::ctype crtype;
1.358 +
1.359 + static rtype get(TupleT& t) { return t.l; }
1.360 + static crtype get(TupleT const& t) { return t.l; }
1.361 +};
1.362 +
1.363 +#if PHOENIX_LIMIT > 12
1.364 +//////////////////////////////////
1.365 +template <typename TupleT>
1.366 +struct tuple_element<12, TupleT>
1.367 +{
1.368 + typedef typename TupleT::m_type type;
1.369 + typedef typename impl::access<type>::type rtype;
1.370 + typedef typename impl::access<type>::ctype crtype;
1.371 +
1.372 + static rtype get(TupleT& t) { return t.m; }
1.373 + static crtype get(TupleT const& t) { return t.m; }
1.374 +};
1.375 +
1.376 +//////////////////////////////////
1.377 +template <typename TupleT>
1.378 +struct tuple_element<13, TupleT>
1.379 +{
1.380 + typedef typename TupleT::n_type type;
1.381 + typedef typename impl::access<type>::type rtype;
1.382 + typedef typename impl::access<type>::ctype crtype;
1.383 +
1.384 + static rtype get(TupleT& t) { return t.n; }
1.385 + static crtype get(TupleT const& t) { return t.n; }
1.386 +};
1.387 +
1.388 +//////////////////////////////////
1.389 +template <typename TupleT>
1.390 +struct tuple_element<14, TupleT>
1.391 +{
1.392 + typedef typename TupleT::o_type type;
1.393 + typedef typename impl::access<type>::type rtype;
1.394 + typedef typename impl::access<type>::ctype crtype;
1.395 +
1.396 + static rtype get(TupleT& t) { return t.o; }
1.397 + static crtype get(TupleT const& t) { return t.o; }
1.398 +};
1.399 +
1.400 +#endif
1.401 +#endif
1.402 +#endif
1.403 +#endif
1.404 +
1.405 +///////////////////////////////////////////////////////////////////////////////
1.406 +//
1.407 +// tuple forward declaration.
1.408 +//
1.409 +///////////////////////////////////////////////////////////////////////////////
1.410 +template <
1.411 + typename A = nil_t
1.412 + , typename B = nil_t
1.413 + , typename C = nil_t
1.414 +
1.415 +#if PHOENIX_LIMIT > 3
1.416 + , typename D = nil_t
1.417 + , typename E = nil_t
1.418 + , typename F = nil_t
1.419 +
1.420 +#if PHOENIX_LIMIT > 6
1.421 + , typename G = nil_t
1.422 + , typename H = nil_t
1.423 + , typename I = nil_t
1.424 +
1.425 +#if PHOENIX_LIMIT > 9
1.426 + , typename J = nil_t
1.427 + , typename K = nil_t
1.428 + , typename L = nil_t
1.429 +
1.430 +#if PHOENIX_LIMIT > 12
1.431 + , typename M = nil_t
1.432 + , typename N = nil_t
1.433 + , typename O = nil_t
1.434 +
1.435 +#endif
1.436 +#endif
1.437 +#endif
1.438 +#endif
1.439 +
1.440 + , typename NU = nil_t // Not used
1.441 +>
1.442 +struct tuple;
1.443 +
1.444 +///////////////////////////////////////////////////////////////////////////////
1.445 +//
1.446 +// tuple_index
1.447 +//
1.448 +// This class wraps an integer in a type to be used for indexing
1.449 +// the Nth element in a tuple. See tuple operator[]. Some
1.450 +// predefined names are provided in sub-namespace
1.451 +// tuple_index_names.
1.452 +//
1.453 +///////////////////////////////////////////////////////////////////////////////
1.454 +template <int N>
1.455 +struct tuple_index {};
1.456 +
1.457 +//////////////////////////////////
1.458 +namespace tuple_index_names {
1.459 +
1.460 + tuple_index<0> const _1 = tuple_index<0>();
1.461 + tuple_index<1> const _2 = tuple_index<1>();
1.462 + tuple_index<2> const _3 = tuple_index<2>();
1.463 +
1.464 +#if PHOENIX_LIMIT > 3
1.465 + tuple_index<3> const _4 = tuple_index<3>();
1.466 + tuple_index<4> const _5 = tuple_index<4>();
1.467 + tuple_index<5> const _6 = tuple_index<5>();
1.468 +
1.469 +#if PHOENIX_LIMIT > 6
1.470 + tuple_index<6> const _7 = tuple_index<6>();
1.471 + tuple_index<7> const _8 = tuple_index<7>();
1.472 + tuple_index<8> const _9 = tuple_index<8>();
1.473 +
1.474 +#if PHOENIX_LIMIT > 9
1.475 + tuple_index<9> const _10 = tuple_index<9>();
1.476 + tuple_index<10> const _11 = tuple_index<10>();
1.477 + tuple_index<11> const _12 = tuple_index<11>();
1.478 +
1.479 +#if PHOENIX_LIMIT > 12
1.480 + tuple_index<12> const _13 = tuple_index<12>();
1.481 + tuple_index<13> const _14 = tuple_index<13>();
1.482 + tuple_index<14> const _15 = tuple_index<14>();
1.483 +
1.484 +#endif
1.485 +#endif
1.486 +#endif
1.487 +#endif
1.488 +}
1.489 +
1.490 +///////////////////////////////////////////////////////////////////////////////
1.491 +//
1.492 +// tuple_common class
1.493 +//
1.494 +///////////////////////////////////////////////////////////////////////////////
1.495 +template <typename DerivedT>
1.496 +struct tuple_base {
1.497 +
1.498 + typedef nil_t a_type;
1.499 + typedef nil_t b_type;
1.500 + typedef nil_t c_type;
1.501 +
1.502 +#if PHOENIX_LIMIT > 3
1.503 + typedef nil_t d_type;
1.504 + typedef nil_t e_type;
1.505 + typedef nil_t f_type;
1.506 +
1.507 +#if PHOENIX_LIMIT > 6
1.508 + typedef nil_t g_type;
1.509 + typedef nil_t h_type;
1.510 + typedef nil_t i_type;
1.511 +
1.512 +#if PHOENIX_LIMIT > 9
1.513 + typedef nil_t j_type;
1.514 + typedef nil_t k_type;
1.515 + typedef nil_t l_type;
1.516 +
1.517 +#if PHOENIX_LIMIT > 12
1.518 + typedef nil_t m_type;
1.519 + typedef nil_t n_type;
1.520 + typedef nil_t o_type;
1.521 +
1.522 +#endif
1.523 +#endif
1.524 +#endif
1.525 +#endif
1.526 +
1.527 + template <int N>
1.528 + typename tuple_element<N, DerivedT>::crtype
1.529 + operator[](tuple_index<N>) const
1.530 + {
1.531 + return tuple_element<N, DerivedT>
1.532 + ::get(*static_cast<DerivedT const*>(this));
1.533 + }
1.534 +
1.535 + template <int N>
1.536 + typename tuple_element<N, DerivedT>::rtype
1.537 + operator[](tuple_index<N>)
1.538 + {
1.539 + return tuple_element<N, DerivedT>
1.540 + ::get(*static_cast<DerivedT*>(this));
1.541 + }
1.542 +};
1.543 +
1.544 +///////////////////////////////////////////////////////////////////////////////
1.545 +//
1.546 +// tuple <0 member> class
1.547 +//
1.548 +///////////////////////////////////////////////////////////////////////////////
1.549 +template <>
1.550 +struct tuple<>
1.551 +: public tuple_base<tuple<> > {
1.552 +
1.553 + BOOST_STATIC_CONSTANT(int, length = 0);
1.554 +};
1.555 +
1.556 +///////////////////////////////////////////////////////////////////////////////
1.557 +//
1.558 +// tuple <1 member> class
1.559 +//
1.560 +///////////////////////////////////////////////////////////////////////////////
1.561 +template <typename A>
1.562 +struct tuple<A, nil_t, nil_t,
1.563 +#if PHOENIX_LIMIT > 3
1.564 + nil_t, nil_t, nil_t,
1.565 +#if PHOENIX_LIMIT > 6
1.566 + nil_t, nil_t, nil_t,
1.567 +#if PHOENIX_LIMIT > 9
1.568 + nil_t, nil_t, nil_t,
1.569 +#if PHOENIX_LIMIT > 12
1.570 + nil_t, nil_t, nil_t,
1.571 +#endif
1.572 +#endif
1.573 +#endif
1.574 +#endif
1.575 + nil_t // Unused
1.576 +>
1.577 +: public tuple_base<tuple<A> > {
1.578 +
1.579 + BOOST_STATIC_CONSTANT(int, length = 1);
1.580 + typedef A a_type;
1.581 +
1.582 + tuple() {}
1.583 +
1.584 + tuple(
1.585 + typename call_traits<A>::param_type a_
1.586 + ): a(a_) {}
1.587 +
1.588 + template <typename TupleT>
1.589 + tuple(TupleT const& init)
1.590 + : a(init[tuple_index<0>()])
1.591 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.592 +
1.593 + A a;
1.594 +};
1.595 +
1.596 +///////////////////////////////////////////////////////////////////////////////
1.597 +//
1.598 +// tuple <2 member> class
1.599 +//
1.600 +///////////////////////////////////////////////////////////////////////////////
1.601 +template <typename A, typename B>
1.602 +struct tuple<A, B, nil_t,
1.603 +#if PHOENIX_LIMIT > 3
1.604 + nil_t, nil_t, nil_t,
1.605 +#if PHOENIX_LIMIT > 6
1.606 + nil_t, nil_t, nil_t,
1.607 +#if PHOENIX_LIMIT > 9
1.608 + nil_t, nil_t, nil_t,
1.609 +#if PHOENIX_LIMIT > 12
1.610 + nil_t, nil_t, nil_t,
1.611 +#endif
1.612 +#endif
1.613 +#endif
1.614 +#endif
1.615 + nil_t // Unused
1.616 +>
1.617 +: public tuple_base<tuple<A, B> > {
1.618 +
1.619 + BOOST_STATIC_CONSTANT(int, length = 2);
1.620 + typedef A a_type; typedef B b_type;
1.621 +
1.622 + tuple() {}
1.623 +
1.624 + tuple(
1.625 + typename call_traits<A>::param_type a_,
1.626 + typename call_traits<B>::param_type b_
1.627 + ): a(a_), b(b_) {}
1.628 +
1.629 + template <typename TupleT>
1.630 + tuple(TupleT const& init)
1.631 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()])
1.632 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.633 +
1.634 + A a; B b;
1.635 +};
1.636 +
1.637 +///////////////////////////////////////////////////////////////////////////////
1.638 +//
1.639 +// tuple <3 member> class
1.640 +//
1.641 +///////////////////////////////////////////////////////////////////////////////
1.642 +template <typename A, typename B, typename C>
1.643 +struct tuple<A, B, C,
1.644 +#if PHOENIX_LIMIT > 3
1.645 + nil_t, nil_t, nil_t,
1.646 +#if PHOENIX_LIMIT > 6
1.647 + nil_t, nil_t, nil_t,
1.648 +#if PHOENIX_LIMIT > 9
1.649 + nil_t, nil_t, nil_t,
1.650 +#if PHOENIX_LIMIT > 12
1.651 + nil_t, nil_t, nil_t,
1.652 +#endif
1.653 +#endif
1.654 +#endif
1.655 +#endif
1.656 + nil_t // Unused
1.657 +>
1.658 +: public tuple_base<tuple<A, B, C> > {
1.659 +
1.660 + BOOST_STATIC_CONSTANT(int, length = 3);
1.661 + typedef A a_type; typedef B b_type;
1.662 + typedef C c_type;
1.663 +
1.664 + tuple() {}
1.665 +
1.666 + tuple(
1.667 + typename call_traits<A>::param_type a_,
1.668 + typename call_traits<B>::param_type b_,
1.669 + typename call_traits<C>::param_type c_
1.670 + ): a(a_), b(b_), c(c_) {}
1.671 +
1.672 + template <typename TupleT>
1.673 + tuple(TupleT const& init)
1.674 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.675 + c(init[tuple_index<2>()])
1.676 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.677 +
1.678 + A a; B b; C c;
1.679 +};
1.680 +
1.681 +#if PHOENIX_LIMIT > 3
1.682 +///////////////////////////////////////////////////////////////////////////////
1.683 +//
1.684 +// tuple <4 member> class
1.685 +//
1.686 +///////////////////////////////////////////////////////////////////////////////
1.687 +template <typename A, typename B, typename C, typename D>
1.688 +struct tuple<A, B, C, D, nil_t, nil_t,
1.689 +#if PHOENIX_LIMIT > 6
1.690 + nil_t, nil_t, nil_t,
1.691 +#if PHOENIX_LIMIT > 9
1.692 + nil_t, nil_t, nil_t,
1.693 +#if PHOENIX_LIMIT > 12
1.694 + nil_t, nil_t, nil_t,
1.695 +#endif
1.696 +#endif
1.697 +#endif
1.698 + nil_t // Unused
1.699 +>
1.700 +: public tuple_base<tuple<A, B, C, D> > {
1.701 +
1.702 + BOOST_STATIC_CONSTANT(int, length = 4);
1.703 + typedef A a_type; typedef B b_type;
1.704 + typedef C c_type; typedef D d_type;
1.705 +
1.706 + tuple() {}
1.707 +
1.708 + tuple(
1.709 + typename call_traits<A>::param_type a_,
1.710 + typename call_traits<B>::param_type b_,
1.711 + typename call_traits<C>::param_type c_,
1.712 + typename call_traits<D>::param_type d_
1.713 + ): a(a_), b(b_), c(c_), d(d_) {}
1.714 +
1.715 + template <typename TupleT>
1.716 + tuple(TupleT const& init)
1.717 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.718 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()])
1.719 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.720 +
1.721 + A a; B b; C c; D d;
1.722 +};
1.723 +
1.724 +///////////////////////////////////////////////////////////////////////////////
1.725 +//
1.726 +// tuple <5 member> class
1.727 +//
1.728 +///////////////////////////////////////////////////////////////////////////////
1.729 +template <typename A, typename B, typename C, typename D, typename E>
1.730 +struct tuple<A, B, C, D, E, nil_t,
1.731 +#if PHOENIX_LIMIT > 6
1.732 + nil_t, nil_t, nil_t,
1.733 +#if PHOENIX_LIMIT > 9
1.734 + nil_t, nil_t, nil_t,
1.735 +#if PHOENIX_LIMIT > 12
1.736 + nil_t, nil_t, nil_t,
1.737 +#endif
1.738 +#endif
1.739 +#endif
1.740 + nil_t // Unused
1.741 +>
1.742 +: public tuple_base<tuple<A, B, C, D, E> > {
1.743 +
1.744 + BOOST_STATIC_CONSTANT(int, length = 5);
1.745 + typedef A a_type; typedef B b_type;
1.746 + typedef C c_type; typedef D d_type;
1.747 + typedef E e_type;
1.748 +
1.749 + tuple() {}
1.750 +
1.751 + tuple(
1.752 + typename call_traits<A>::param_type a_,
1.753 + typename call_traits<B>::param_type b_,
1.754 + typename call_traits<C>::param_type c_,
1.755 + typename call_traits<D>::param_type d_,
1.756 + typename call_traits<E>::param_type e_
1.757 + ): a(a_), b(b_), c(c_), d(d_), e(e_) {}
1.758 +
1.759 + template <typename TupleT>
1.760 + tuple(TupleT const& init)
1.761 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.762 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.763 + e(init[tuple_index<4>()])
1.764 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.765 +
1.766 + A a; B b; C c; D d; E e;
1.767 +};
1.768 +
1.769 +///////////////////////////////////////////////////////////////////////////////
1.770 +//
1.771 +// tuple <6 member> class
1.772 +//
1.773 +///////////////////////////////////////////////////////////////////////////////
1.774 +template <
1.775 + typename A, typename B, typename C, typename D, typename E,
1.776 + typename F>
1.777 +struct tuple<A, B, C, D, E, F,
1.778 +#if PHOENIX_LIMIT > 6
1.779 + nil_t, nil_t, nil_t,
1.780 +#if PHOENIX_LIMIT > 9
1.781 + nil_t, nil_t, nil_t,
1.782 +#if PHOENIX_LIMIT > 12
1.783 + nil_t, nil_t, nil_t,
1.784 +#endif
1.785 +#endif
1.786 +#endif
1.787 + nil_t // Unused
1.788 +>
1.789 +: public tuple_base<tuple<A, B, C, D, E, F> > {
1.790 +
1.791 + BOOST_STATIC_CONSTANT(int, length = 6);
1.792 + typedef A a_type; typedef B b_type;
1.793 + typedef C c_type; typedef D d_type;
1.794 + typedef E e_type; typedef F f_type;
1.795 +
1.796 + tuple() {}
1.797 +
1.798 + tuple(
1.799 + typename call_traits<A>::param_type a_,
1.800 + typename call_traits<B>::param_type b_,
1.801 + typename call_traits<C>::param_type c_,
1.802 + typename call_traits<D>::param_type d_,
1.803 + typename call_traits<E>::param_type e_,
1.804 + typename call_traits<F>::param_type f_
1.805 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.806 + f(f_) {}
1.807 +
1.808 + template <typename TupleT>
1.809 + tuple(TupleT const& init)
1.810 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.811 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.812 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()])
1.813 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.814 +
1.815 + A a; B b; C c; D d; E e;
1.816 + F f;
1.817 +};
1.818 +
1.819 +#if PHOENIX_LIMIT > 6
1.820 +///////////////////////////////////////////////////////////////////////////////
1.821 +//
1.822 +// tuple <7 member> class
1.823 +//
1.824 +///////////////////////////////////////////////////////////////////////////////
1.825 +template <
1.826 + typename A, typename B, typename C, typename D, typename E,
1.827 + typename F, typename G>
1.828 +struct tuple<A, B, C, D, E, F, G, nil_t, nil_t,
1.829 +#if PHOENIX_LIMIT > 9
1.830 + nil_t, nil_t, nil_t,
1.831 +#if PHOENIX_LIMIT > 12
1.832 + nil_t, nil_t, nil_t,
1.833 +#endif
1.834 +#endif
1.835 + nil_t // Unused
1.836 +>
1.837 +: public tuple_base<tuple<A, B, C, D, E, F, G> > {
1.838 +
1.839 + BOOST_STATIC_CONSTANT(int, length = 7);
1.840 + typedef A a_type; typedef B b_type;
1.841 + typedef C c_type; typedef D d_type;
1.842 + typedef E e_type; typedef F f_type;
1.843 + typedef G g_type;
1.844 +
1.845 + tuple() {}
1.846 +
1.847 + tuple(
1.848 + typename call_traits<A>::param_type a_,
1.849 + typename call_traits<B>::param_type b_,
1.850 + typename call_traits<C>::param_type c_,
1.851 + typename call_traits<D>::param_type d_,
1.852 + typename call_traits<E>::param_type e_,
1.853 + typename call_traits<F>::param_type f_,
1.854 + typename call_traits<G>::param_type g_
1.855 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.856 + f(f_), g(g_) {}
1.857 +
1.858 + template <typename TupleT>
1.859 + tuple(TupleT const& init)
1.860 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.861 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.862 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.863 + g(init[tuple_index<6>()])
1.864 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.865 +
1.866 + A a; B b; C c; D d; E e;
1.867 + F f; G g;
1.868 +};
1.869 +
1.870 +///////////////////////////////////////////////////////////////////////////////
1.871 +//
1.872 +// tuple <8 member> class
1.873 +//
1.874 +///////////////////////////////////////////////////////////////////////////////
1.875 +template <
1.876 + typename A, typename B, typename C, typename D, typename E,
1.877 + typename F, typename G, typename H>
1.878 +struct tuple<A, B, C, D, E, F, G, H, nil_t,
1.879 +#if PHOENIX_LIMIT > 9
1.880 + nil_t, nil_t, nil_t,
1.881 +#if PHOENIX_LIMIT > 12
1.882 + nil_t, nil_t, nil_t,
1.883 +#endif
1.884 +#endif
1.885 + nil_t // Unused
1.886 +>
1.887 +: public tuple_base<tuple<A, B, C, D, E, F, G, H> > {
1.888 +
1.889 + BOOST_STATIC_CONSTANT(int, length = 8);
1.890 + typedef A a_type; typedef B b_type;
1.891 + typedef C c_type; typedef D d_type;
1.892 + typedef E e_type; typedef F f_type;
1.893 + typedef G g_type; typedef H h_type;
1.894 +
1.895 + tuple() {}
1.896 +
1.897 + tuple(
1.898 + typename call_traits<A>::param_type a_,
1.899 + typename call_traits<B>::param_type b_,
1.900 + typename call_traits<C>::param_type c_,
1.901 + typename call_traits<D>::param_type d_,
1.902 + typename call_traits<E>::param_type e_,
1.903 + typename call_traits<F>::param_type f_,
1.904 + typename call_traits<G>::param_type g_,
1.905 + typename call_traits<H>::param_type h_
1.906 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.907 + f(f_), g(g_), h(h_) {}
1.908 +
1.909 + template <typename TupleT>
1.910 + tuple(TupleT const& init)
1.911 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.912 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.913 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.914 + g(init[tuple_index<6>()]), h(init[tuple_index<7>()])
1.915 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.916 +
1.917 + A a; B b; C c; D d; E e;
1.918 + F f; G g; H h;
1.919 +};
1.920 +
1.921 +///////////////////////////////////////////////////////////////////////////////
1.922 +//
1.923 +// tuple <9 member> class
1.924 +//
1.925 +///////////////////////////////////////////////////////////////////////////////
1.926 +template <
1.927 + typename A, typename B, typename C, typename D, typename E,
1.928 + typename F, typename G, typename H, typename I>
1.929 +struct tuple<A, B, C, D, E, F, G, H, I,
1.930 +#if PHOENIX_LIMIT > 9
1.931 + nil_t, nil_t, nil_t,
1.932 +#if PHOENIX_LIMIT > 12
1.933 + nil_t, nil_t, nil_t,
1.934 +#endif
1.935 +#endif
1.936 + nil_t // Unused
1.937 +>
1.938 +: public tuple_base<tuple<A, B, C, D, E, F, G, H, I> > {
1.939 +
1.940 + BOOST_STATIC_CONSTANT(int, length = 9);
1.941 + typedef A a_type; typedef B b_type;
1.942 + typedef C c_type; typedef D d_type;
1.943 + typedef E e_type; typedef F f_type;
1.944 + typedef G g_type; typedef H h_type;
1.945 + typedef I i_type;
1.946 +
1.947 + tuple() {}
1.948 +
1.949 + tuple(
1.950 + typename call_traits<A>::param_type a_,
1.951 + typename call_traits<B>::param_type b_,
1.952 + typename call_traits<C>::param_type c_,
1.953 + typename call_traits<D>::param_type d_,
1.954 + typename call_traits<E>::param_type e_,
1.955 + typename call_traits<F>::param_type f_,
1.956 + typename call_traits<G>::param_type g_,
1.957 + typename call_traits<H>::param_type h_,
1.958 + typename call_traits<I>::param_type i_
1.959 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.960 + f(f_), g(g_), h(h_), i(i_) {}
1.961 +
1.962 + template <typename TupleT>
1.963 + tuple(TupleT const& init)
1.964 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.965 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.966 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.967 + g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1.968 + i(init[tuple_index<8>()])
1.969 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.970 +
1.971 + A a; B b; C c; D d; E e;
1.972 + F f; G g; H h; I i;
1.973 +};
1.974 +
1.975 +#if PHOENIX_LIMIT > 9
1.976 +///////////////////////////////////////////////////////////////////////////////
1.977 +//
1.978 +// tuple <10 member> class
1.979 +//
1.980 +///////////////////////////////////////////////////////////////////////////////
1.981 +template <
1.982 + typename A, typename B, typename C, typename D, typename E,
1.983 + typename F, typename G, typename H, typename I, typename J>
1.984 +struct tuple<A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
1.985 +#if PHOENIX_LIMIT > 12
1.986 + nil_t, nil_t, nil_t,
1.987 +#endif
1.988 + nil_t // Unused
1.989 +>
1.990 +: public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J> > {
1.991 +
1.992 + BOOST_STATIC_CONSTANT(int, length = 10);
1.993 + typedef A a_type; typedef B b_type;
1.994 + typedef C c_type; typedef D d_type;
1.995 + typedef E e_type; typedef F f_type;
1.996 + typedef G g_type; typedef H h_type;
1.997 + typedef I i_type; typedef J j_type;
1.998 +
1.999 + tuple() {}
1.1000 +
1.1001 + tuple(
1.1002 + typename call_traits<A>::param_type a_,
1.1003 + typename call_traits<B>::param_type b_,
1.1004 + typename call_traits<C>::param_type c_,
1.1005 + typename call_traits<D>::param_type d_,
1.1006 + typename call_traits<E>::param_type e_,
1.1007 + typename call_traits<F>::param_type f_,
1.1008 + typename call_traits<G>::param_type g_,
1.1009 + typename call_traits<H>::param_type h_,
1.1010 + typename call_traits<I>::param_type i_,
1.1011 + typename call_traits<J>::param_type j_
1.1012 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.1013 + f(f_), g(g_), h(h_), i(i_), j(j_) {}
1.1014 +
1.1015 + template <typename TupleT>
1.1016 + tuple(TupleT const& init)
1.1017 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.1018 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.1019 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.1020 + g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1.1021 + i(init[tuple_index<8>()]), j(init[tuple_index<9>()])
1.1022 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.1023 +
1.1024 + A a; B b; C c; D d; E e;
1.1025 + F f; G g; H h; I i; J j;
1.1026 +};
1.1027 +
1.1028 +///////////////////////////////////////////////////////////////////////////////
1.1029 +//
1.1030 +// tuple <11 member> class
1.1031 +//
1.1032 +///////////////////////////////////////////////////////////////////////////////
1.1033 +template <
1.1034 + typename A, typename B, typename C, typename D, typename E,
1.1035 + typename F, typename G, typename H, typename I, typename J,
1.1036 + typename K>
1.1037 +struct tuple<A, B, C, D, E, F, G, H, I, J, K, nil_t,
1.1038 +#if PHOENIX_LIMIT > 12
1.1039 + nil_t, nil_t, nil_t,
1.1040 +#endif
1.1041 + nil_t // Unused
1.1042 +>
1.1043 +: public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J, K> > {
1.1044 +
1.1045 + BOOST_STATIC_CONSTANT(int, length = 11);
1.1046 + typedef A a_type; typedef B b_type;
1.1047 + typedef C c_type; typedef D d_type;
1.1048 + typedef E e_type; typedef F f_type;
1.1049 + typedef G g_type; typedef H h_type;
1.1050 + typedef I i_type; typedef J j_type;
1.1051 + typedef K k_type;
1.1052 +
1.1053 + tuple() {}
1.1054 +
1.1055 + tuple(
1.1056 + typename call_traits<A>::param_type a_,
1.1057 + typename call_traits<B>::param_type b_,
1.1058 + typename call_traits<C>::param_type c_,
1.1059 + typename call_traits<D>::param_type d_,
1.1060 + typename call_traits<E>::param_type e_,
1.1061 + typename call_traits<F>::param_type f_,
1.1062 + typename call_traits<G>::param_type g_,
1.1063 + typename call_traits<H>::param_type h_,
1.1064 + typename call_traits<I>::param_type i_,
1.1065 + typename call_traits<J>::param_type j_,
1.1066 + typename call_traits<K>::param_type k_
1.1067 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.1068 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.1069 + k(k_) {}
1.1070 +
1.1071 + template <typename TupleT>
1.1072 + tuple(TupleT const& init)
1.1073 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.1074 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.1075 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.1076 + g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1.1077 + i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1.1078 + k(init[tuple_index<10>()])
1.1079 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.1080 +
1.1081 + A a; B b; C c; D d; E e;
1.1082 + F f; G g; H h; I i; J j;
1.1083 + K k;
1.1084 +};
1.1085 +
1.1086 +///////////////////////////////////////////////////////////////////////////////
1.1087 +//
1.1088 +// tuple <12 member> class
1.1089 +//
1.1090 +///////////////////////////////////////////////////////////////////////////////
1.1091 +template <
1.1092 + typename A, typename B, typename C, typename D, typename E,
1.1093 + typename F, typename G, typename H, typename I, typename J,
1.1094 + typename K, typename L>
1.1095 +struct tuple<A, B, C, D, E, F, G, H, I, J, K, L,
1.1096 +#if PHOENIX_LIMIT > 12
1.1097 + nil_t, nil_t, nil_t,
1.1098 +#endif
1.1099 + nil_t // Unused
1.1100 +>
1.1101 +: public tuple_base<tuple<A, B, C, D, E, F, G, H, I, J, K, L> > {
1.1102 +
1.1103 + BOOST_STATIC_CONSTANT(int, length = 12);
1.1104 + typedef A a_type; typedef B b_type;
1.1105 + typedef C c_type; typedef D d_type;
1.1106 + typedef E e_type; typedef F f_type;
1.1107 + typedef G g_type; typedef H h_type;
1.1108 + typedef I i_type; typedef J j_type;
1.1109 + typedef K k_type; typedef L l_type;
1.1110 +
1.1111 + tuple() {}
1.1112 +
1.1113 + tuple(
1.1114 + typename call_traits<A>::param_type a_,
1.1115 + typename call_traits<B>::param_type b_,
1.1116 + typename call_traits<C>::param_type c_,
1.1117 + typename call_traits<D>::param_type d_,
1.1118 + typename call_traits<E>::param_type e_,
1.1119 + typename call_traits<F>::param_type f_,
1.1120 + typename call_traits<G>::param_type g_,
1.1121 + typename call_traits<H>::param_type h_,
1.1122 + typename call_traits<I>::param_type i_,
1.1123 + typename call_traits<J>::param_type j_,
1.1124 + typename call_traits<K>::param_type k_,
1.1125 + typename call_traits<L>::param_type l_
1.1126 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.1127 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.1128 + k(k_), l(l_) {}
1.1129 +
1.1130 + template <typename TupleT>
1.1131 + tuple(TupleT const& init)
1.1132 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.1133 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.1134 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.1135 + g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1.1136 + i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1.1137 + k(init[tuple_index<10>()]), l(init[tuple_index<11>()])
1.1138 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.1139 +
1.1140 + A a; B b; C c; D d; E e;
1.1141 + F f; G g; H h; I i; J j;
1.1142 + K k; L l;
1.1143 +};
1.1144 +
1.1145 +#if PHOENIX_LIMIT > 12
1.1146 +///////////////////////////////////////////////////////////////////////////////
1.1147 +//
1.1148 +// tuple <13 member> class
1.1149 +//
1.1150 +///////////////////////////////////////////////////////////////////////////////
1.1151 +template <
1.1152 + typename A, typename B, typename C, typename D, typename E,
1.1153 + typename F, typename G, typename H, typename I, typename J,
1.1154 + typename K, typename L, typename M>
1.1155 +struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t>
1.1156 +: public tuple_base<
1.1157 + tuple<A, B, C, D, E, F, G, H, I, J, K, L, M> > {
1.1158 +
1.1159 + BOOST_STATIC_CONSTANT(int, length = 13);
1.1160 + typedef A a_type; typedef B b_type;
1.1161 + typedef C c_type; typedef D d_type;
1.1162 + typedef E e_type; typedef F f_type;
1.1163 + typedef G g_type; typedef H h_type;
1.1164 + typedef I i_type; typedef J j_type;
1.1165 + typedef K k_type; typedef L l_type;
1.1166 + typedef M m_type;
1.1167 +
1.1168 + tuple() {}
1.1169 +
1.1170 + tuple(
1.1171 + typename call_traits<A>::param_type a_,
1.1172 + typename call_traits<B>::param_type b_,
1.1173 + typename call_traits<C>::param_type c_,
1.1174 + typename call_traits<D>::param_type d_,
1.1175 + typename call_traits<E>::param_type e_,
1.1176 + typename call_traits<F>::param_type f_,
1.1177 + typename call_traits<G>::param_type g_,
1.1178 + typename call_traits<H>::param_type h_,
1.1179 + typename call_traits<I>::param_type i_,
1.1180 + typename call_traits<J>::param_type j_,
1.1181 + typename call_traits<K>::param_type k_,
1.1182 + typename call_traits<L>::param_type l_,
1.1183 + typename call_traits<M>::param_type m_
1.1184 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.1185 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.1186 + k(k_), l(l_), m(m_) {}
1.1187 +
1.1188 + template <typename TupleT>
1.1189 + tuple(TupleT const& init)
1.1190 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.1191 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.1192 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.1193 + g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1.1194 + i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1.1195 + k(init[tuple_index<10>()]), l(init[tuple_index<11>()]),
1.1196 + m(init[tuple_index<12>()])
1.1197 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.1198 +
1.1199 + A a; B b; C c; D d; E e;
1.1200 + F f; G g; H h; I i; J j;
1.1201 + K k; L l; M m;
1.1202 +};
1.1203 +
1.1204 +///////////////////////////////////////////////////////////////////////////////
1.1205 +//
1.1206 +// tuple <14 member> class
1.1207 +//
1.1208 +///////////////////////////////////////////////////////////////////////////////
1.1209 +template <
1.1210 + typename A, typename B, typename C, typename D, typename E,
1.1211 + typename F, typename G, typename H, typename I, typename J,
1.1212 + typename K, typename L, typename M, typename N>
1.1213 +struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t>
1.1214 +: public tuple_base<
1.1215 + tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N> > {
1.1216 +
1.1217 + BOOST_STATIC_CONSTANT(int, length = 14);
1.1218 + typedef A a_type; typedef B b_type;
1.1219 + typedef C c_type; typedef D d_type;
1.1220 + typedef E e_type; typedef F f_type;
1.1221 + typedef G g_type; typedef H h_type;
1.1222 + typedef I i_type; typedef J j_type;
1.1223 + typedef K k_type; typedef L l_type;
1.1224 + typedef M m_type; typedef N n_type;
1.1225 +
1.1226 + tuple() {}
1.1227 +
1.1228 + tuple(
1.1229 + typename call_traits<A>::param_type a_,
1.1230 + typename call_traits<B>::param_type b_,
1.1231 + typename call_traits<C>::param_type c_,
1.1232 + typename call_traits<D>::param_type d_,
1.1233 + typename call_traits<E>::param_type e_,
1.1234 + typename call_traits<F>::param_type f_,
1.1235 + typename call_traits<G>::param_type g_,
1.1236 + typename call_traits<H>::param_type h_,
1.1237 + typename call_traits<I>::param_type i_,
1.1238 + typename call_traits<J>::param_type j_,
1.1239 + typename call_traits<K>::param_type k_,
1.1240 + typename call_traits<L>::param_type l_,
1.1241 + typename call_traits<M>::param_type m_,
1.1242 + typename call_traits<N>::param_type n_
1.1243 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.1244 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.1245 + k(k_), l(l_), m(m_), n(n_) {}
1.1246 +
1.1247 + template <typename TupleT>
1.1248 + tuple(TupleT const& init)
1.1249 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.1250 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.1251 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.1252 + g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1.1253 + i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1.1254 + k(init[tuple_index<10>()]), l(init[tuple_index<11>()]),
1.1255 + m(init[tuple_index<12>()]), n(init[tuple_index<13>()])
1.1256 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.1257 +
1.1258 + A a; B b; C c; D d; E e;
1.1259 + F f; G g; H h; I i; J j;
1.1260 + K k; L l; M m; N n;
1.1261 +};
1.1262 +
1.1263 +///////////////////////////////////////////////////////////////////////////////
1.1264 +//
1.1265 +// tuple <15 member> class
1.1266 +//
1.1267 +///////////////////////////////////////////////////////////////////////////////
1.1268 +template <
1.1269 + typename A, typename B, typename C, typename D, typename E,
1.1270 + typename F, typename G, typename H, typename I, typename J,
1.1271 + typename K, typename L, typename M, typename N, typename O>
1.1272 +struct tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t>
1.1273 +: public tuple_base<
1.1274 + tuple<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> > {
1.1275 +
1.1276 + BOOST_STATIC_CONSTANT(int, length = 15);
1.1277 + typedef A a_type; typedef B b_type;
1.1278 + typedef C c_type; typedef D d_type;
1.1279 + typedef E e_type; typedef F f_type;
1.1280 + typedef G g_type; typedef H h_type;
1.1281 + typedef I i_type; typedef J j_type;
1.1282 + typedef K k_type; typedef L l_type;
1.1283 + typedef M m_type; typedef N n_type;
1.1284 + typedef O o_type;
1.1285 +
1.1286 + tuple() {}
1.1287 +
1.1288 + tuple(
1.1289 + typename call_traits<A>::param_type a_,
1.1290 + typename call_traits<B>::param_type b_,
1.1291 + typename call_traits<C>::param_type c_,
1.1292 + typename call_traits<D>::param_type d_,
1.1293 + typename call_traits<E>::param_type e_,
1.1294 + typename call_traits<F>::param_type f_,
1.1295 + typename call_traits<G>::param_type g_,
1.1296 + typename call_traits<H>::param_type h_,
1.1297 + typename call_traits<I>::param_type i_,
1.1298 + typename call_traits<J>::param_type j_,
1.1299 + typename call_traits<K>::param_type k_,
1.1300 + typename call_traits<L>::param_type l_,
1.1301 + typename call_traits<M>::param_type m_,
1.1302 + typename call_traits<N>::param_type n_,
1.1303 + typename call_traits<O>::param_type o_
1.1304 + ): a(a_), b(b_), c(c_), d(d_), e(e_),
1.1305 + f(f_), g(g_), h(h_), i(i_), j(j_),
1.1306 + k(k_), l(l_), m(m_), n(n_), o(o_) {}
1.1307 +
1.1308 + template <typename TupleT>
1.1309 + tuple(TupleT const& init)
1.1310 + : a(init[tuple_index<0>()]), b(init[tuple_index<1>()]),
1.1311 + c(init[tuple_index<2>()]), d(init[tuple_index<3>()]),
1.1312 + e(init[tuple_index<4>()]), f(init[tuple_index<5>()]),
1.1313 + g(init[tuple_index<6>()]), h(init[tuple_index<7>()]),
1.1314 + i(init[tuple_index<8>()]), j(init[tuple_index<9>()]),
1.1315 + k(init[tuple_index<10>()]), l(init[tuple_index<11>()]),
1.1316 + m(init[tuple_index<12>()]), n(init[tuple_index<13>()]),
1.1317 + o(init[tuple_index<14>()])
1.1318 + { BOOST_STATIC_ASSERT(TupleT::length == length); }
1.1319 +
1.1320 + A a; B b; C c; D d; E e;
1.1321 + F f; G g; H h; I i; J j;
1.1322 + K k; L l; M m; N n; O o;
1.1323 +};
1.1324 +
1.1325 +#endif
1.1326 +#endif
1.1327 +#endif
1.1328 +#endif
1.1329 +
1.1330 +///////////////////////////////////////////////////////////////////////////////
1.1331 +} // namespace phoenix
1.1332 +
1.1333 +#endif