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