libstdc++-v3/include/tr1/tuple

   1 // class template tuple -*- C++ -*-
   2
   3 // Copyright (C) 2004 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 2, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 /** @file
  22  *  This is a TR1 C++ Library header.
  23  */
  24
  25 // Chris Jefferson <chris@bubblescope.net>
  26
  27 // This header is automatically generated: see maketuple.c for details.
  28
  29 #ifndef _TUPLE
  30 #define _TUPLE 1
  31
  32 #include <tr1/utility>
  33 #include <tr1/functional>
  34
  35 namespace std
  36 {
  37 namespace tr1
  38 {
  39   // An implementation specific class which is used in the tuple class
  40   // when the tuple is not maximum possible size.
  41   struct _NullClass { };
  42
  43   template<typename _Tp0 = _NullClass, typename _Tp1 = _NullClass,
  44            typename _Tp2 = _NullClass, typename _Tp3 = _NullClass,
  45            typename _Tp4 = _NullClass, typename _Tp5 = _NullClass,
  46            typename _Tp6 = _NullClass, typename _Tp7 = _NullClass,
  47            typename _Tp8 = _NullClass, typename _Tp9 = _NullClass>
  48     class tuple;
  49
  50   /// Gives the type of the ith element of a given tuple type.
  51   template<int __i, typename _Tp>
  52     struct tuple_element;
  53
  54   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
  55            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
  56            typename _Tp8, typename _Tp9>
  57     struct tuple_element<0, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
  58                                   _Tp7, _Tp8, _Tp9> >
  59     { typedef _Tp0 type; };
  60
  61   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
  62            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
  63            typename _Tp8, typename _Tp9>
  64     struct tuple_element<1, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
  65                                   _Tp7, _Tp8, _Tp9> >
  66     { typedef _Tp1 type; };
  67
  68   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
  69            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
  70            typename _Tp8, typename _Tp9>
  71     struct tuple_element<2, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
  72                                   _Tp7, _Tp8, _Tp9> >
  73     { typedef _Tp2 type; };
  74
  75   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
  76            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
  77            typename _Tp8, typename _Tp9>
  78     struct tuple_element<3, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
  79                                   _Tp7, _Tp8, _Tp9> >
  80     { typedef _Tp3 type; };
  81
  82   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
  83            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
  84            typename _Tp8, typename _Tp9>
  85     struct tuple_element<4, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
  86                                   _Tp7, _Tp8, _Tp9> >
  87     { typedef _Tp4 type; };
  88
  89   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
  90            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
  91            typename _Tp8, typename _Tp9>
  92     struct tuple_element<5, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
  93                                   _Tp7, _Tp8, _Tp9> >
  94     { typedef _Tp5 type; };
  95
  96   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
  97            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
  98            typename _Tp8, typename _Tp9>
  99     struct tuple_element<6, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
 100                                   _Tp7, _Tp8, _Tp9> >
 101     { typedef _Tp6 type; };
 102
 103   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 104            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
 105            typename _Tp8, typename _Tp9>
 106     struct tuple_element<7, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
 107                                   _Tp7, _Tp8, _Tp9> >
 108     { typedef _Tp7 type; };
 109
 110   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 111            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
 112            typename _Tp8, typename _Tp9>
 113     struct tuple_element<8, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
 114                                   _Tp7, _Tp8, _Tp9> >
 115     { typedef _Tp8 type; };
 116
 117   /// @brief  class tuple_element
 118   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 119            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
 120            typename _Tp8, typename _Tp9>
 121     struct tuple_element<9, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
 122                                   _Tp7, _Tp8, _Tp9> >
 123     { typedef _Tp9 type; };
 124
 125   /// Finds the size of a given tuple type.
 126   template<typename _Tp>
 127     struct tuple_size;
 128
 129   template<>
 130     struct tuple_size<tuple<_NullClass, _NullClass, _NullClass, _NullClass,
 131                             _NullClass, _NullClass, _NullClass, _NullClass,
 132                             _NullClass, _NullClass> >
 133     { static const int value = 0; };
 134
 135   template< typename _Tp0>
 136     struct tuple_size<tuple< _Tp0, _NullClass, _NullClass, _NullClass,
 137                             _NullClass, _NullClass, _NullClass, _NullClass,
 138                             _NullClass, _NullClass> >
 139     { static const int value = 1; };
 140
 141   template<typename _Tp0, typename _Tp1>
 142     struct tuple_size<tuple<_Tp0, _Tp1, _NullClass, _NullClass, _NullClass,
 143                             _NullClass, _NullClass, _NullClass, _NullClass,
 144                             _NullClass> >
 145     { static const int value = 2; };
 146
 147   template<typename _Tp0, typename _Tp1, typename _Tp2>
 148     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _NullClass, _NullClass,
 149                             _NullClass, _NullClass, _NullClass, _NullClass,
 150                             _NullClass> >
 151     { static const int value = 3; };
 152
 153   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
 154     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _NullClass, _NullClass,
 155                             _NullClass, _NullClass, _NullClass, _NullClass> >
 156     { static const int value = 4; };
 157
 158   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 159            typename _Tp4>
 160     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _NullClass,
 161                             _NullClass, _NullClass, _NullClass, _NullClass> >
 162     { static const int value = 5; };
 163
 164   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 165            typename _Tp4, typename _Tp5>
 166     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _NullClass,
 167                             _NullClass, _NullClass, _NullClass> >
 168     { static const int value = 6; };
 169
 170   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 171            typename _Tp4, typename _Tp5, typename _Tp6>
 172     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
 173                             _NullClass, _NullClass, _NullClass> >
 174     { static const int value = 7; };
 175
 176   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 177            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
 178     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7,
 179                             _NullClass, _NullClass> >
 180     { static const int value = 8; };
 181
 182   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 183            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
 184            typename _Tp8>
 185     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7,
 186                             _Tp8,  _NullClass> >
 187     { static const int value = 9; };
 188
 189   /// @brief  class tuple_size
 190   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 191            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
 192            typename _Tp8, typename _Tp9>
 193     struct tuple_size<tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7,
 194                             _Tp8, _Tp9> >
 195     { static const int value = 10; };
 196
 197   // Adds a const reference to a non-reference type.
 198   template<typename _Tp>
 199     struct __add_c_ref
 200     { typedef const _Tp& type; };
 201
 202   template<typename _Tp>
 203     struct __add_c_ref<_Tp&>
 204     { typedef _Tp& type; };
 205
 206   // Adds a reference to a non-reference type.
 207   template<typename _Tp>
 208     struct __add_ref
 209     { typedef _Tp& type; };
 210
 211   template<typename _Tp>
 212     struct __add_ref<_Tp&>
 213     { typedef _Tp& type; };
 214
 215   // The empty tuple.
 216   template<>
 217     class tuple<_NullClass, _NullClass, _NullClass, _NullClass, _NullClass,
 218                 _NullClass, _NullClass, _NullClass, _NullClass, _NullClass>
 219     {
 220     public:
 221       tuple()
 222       { }
 223
 224       tuple(const tuple& __in)
 225       { }
 226
 227       tuple& operator=(const tuple& __in)
 228       { return *this; }
 229     };
 230
 231   template< typename _Tp0>
 232     class tuple< _Tp0, _NullClass, _NullClass, _NullClass, _NullClass,
 233                 _NullClass, _NullClass, _NullClass, _NullClass, _NullClass>
 234     {
 235       _Tp0 _M_t0;
 236
 237     public:
 238       tuple()
 239       { }
 240
 241       explicit tuple( typename __add_c_ref<_Tp0>::type __in0):
 242          _M_t0(__in0)
 243       { }
 244
 245       tuple(const tuple& __in):
 246          _M_t0(__in._M_t0)
 247       { }
 248
 249       template< typename _Up0>
 250         tuple(const tuple< _Up0>& __in):
 251            _M_t0(__in._M_t0)
 252         { }
 253
 254       tuple&
 255       operator=(const tuple& __in)
 256       {
 257         _M_t0=__in._M_t0;
 258         return *this;
 259       }
 260
 261       template< typename _Up0>
 262         tuple&
 263         operator=(const tuple< _Up0>& __in)
 264         {
 265           _M_t0=__in._M_t0;
 266           return *this;
 267         }
 268
 269       template<int __i, typename _Up>
 270         friend class __get_helper;
 271       template<typename, typename, typename, typename, typename, typename,
 272                typename, typename, typename, typename>
 273         friend class tuple;
 274   };
 275
 276   template<typename _Tp0, typename _Tp1>
 277     class tuple<_Tp0, _Tp1, _NullClass, _NullClass, _NullClass, _NullClass,
 278                 _NullClass, _NullClass, _NullClass, _NullClass>
 279     {
 280       _Tp0 _M_t0;
 281       _Tp1 _M_t1;
 282
 283     public:
 284       tuple()
 285       { }
 286
 287       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 288                      typename __add_c_ref<_Tp1>::type __in1):
 289         _M_t0(__in0), _M_t1(__in1)
 290       { }
 291
 292       tuple(const tuple& __in):
 293         _M_t0(__in._M_t0), _M_t1(__in._M_t1)
 294       { }
 295
 296       template<typename _Up0, typename _Up1>
 297         tuple(const tuple<_Up0, _Up1>& __in):
 298           _M_t0(__in._M_t0), _M_t1(__in._M_t1)
 299         { }
 300
 301       template<class _Up1, class _Up2>
 302         tuple(const std::pair<_Up1, _Up2>& __u):
 303            _M_t0(__u.first), _M_t1(__u.second)
 304         { }
 305
 306       tuple&
 307       operator=(const tuple& __in)
 308       {
 309         _M_t0=__in._M_t0;
 310         _M_t1=__in._M_t1;
 311         return *this;
 312       }
 313
 314       template<typename _Up0, typename _Up1>
 315         tuple&
 316         operator=(const tuple<_Up0, _Up1>& __in)
 317         {
 318           _M_t0=__in._M_t0;
 319           _M_t1=__in._M_t1;
 320           return *this;
 321         }
 322
 323       template<int __i, typename _Up>
 324         friend class __get_helper;
 325       template<typename, typename, typename, typename, typename, typename,
 326                typename, typename, typename, typename>
 327         friend class tuple;
 328   };
 329
 330   template<typename _Tp0, typename _Tp1, typename _Tp2>
 331     class tuple<_Tp0, _Tp1, _Tp2, _NullClass, _NullClass, _NullClass,
 332                 _NullClass, _NullClass, _NullClass, _NullClass>
 333     {
 334       _Tp0 _M_t0;
 335       _Tp1 _M_t1;
 336       _Tp2 _M_t2;
 337
 338     public:
 339       tuple()
 340       { }
 341
 342       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 343                      typename __add_c_ref<_Tp1>::type __in1,
 344                      typename __add_c_ref<_Tp2>::type __in2):
 345         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2)
 346       { }
 347
 348       tuple(const tuple& __in):
 349         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2)
 350       { }
 351
 352       template<typename _Up0, typename _Up1, typename _Up2>
 353         tuple(const tuple<_Up0, _Up1, _Up2>& __in):
 354           _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2)
 355         { }
 356
 357       tuple&
 358       operator=(const tuple& __in)
 359       {
 360         _M_t0=__in._M_t0;
 361         _M_t1=__in._M_t1;
 362         _M_t2=__in._M_t2;
 363         return *this;
 364       }
 365
 366       template<typename _Up0, typename _Up1, typename _Up2>
 367         tuple&
 368         operator=(const tuple<_Up0, _Up1, _Up2>& __in)
 369         {
 370           _M_t0=__in._M_t0;
 371           _M_t1=__in._M_t1;
 372           _M_t2=__in._M_t2;
 373           return *this;
 374         }
 375
 376       template<int __i, typename _Up>
 377         friend class __get_helper;
 378       template<typename, typename, typename, typename, typename, typename,
 379                typename, typename, typename, typename>
 380         friend class tuple;
 381   };
 382
 383   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
 384     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _NullClass, _NullClass, _NullClass,
 385                 _NullClass, _NullClass, _NullClass>
 386     {
 387       _Tp0 _M_t0;
 388       _Tp1 _M_t1;
 389       _Tp2 _M_t2;
 390       _Tp3 _M_t3;
 391
 392     public:
 393       tuple()
 394       { }
 395
 396       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 397                      typename __add_c_ref<_Tp1>::type __in1,
 398                      typename __add_c_ref<_Tp2>::type __in2,
 399                      typename __add_c_ref<_Tp3>::type __in3):
 400         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3)
 401       { }
 402
 403       tuple(const tuple& __in):
 404         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 405         _M_t3(__in._M_t3)
 406       { }
 407
 408       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3>
 409         tuple(const tuple<_Up0, _Up1, _Up2, _Up3>& __in):
 410           _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 411           _M_t3(__in._M_t3)
 412         { }
 413
 414       tuple&
 415       operator=(const tuple& __in)
 416       {
 417         _M_t0=__in._M_t0;
 418         _M_t1=__in._M_t1;
 419         _M_t2=__in._M_t2;
 420         _M_t3=__in._M_t3;
 421         return *this;
 422       }
 423
 424       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3>
 425         tuple&
 426         operator=(const tuple<_Up0, _Up1, _Up2, _Up3>& __in)
 427         {
 428           _M_t0=__in._M_t0;
 429           _M_t1=__in._M_t1;
 430           _M_t2=__in._M_t2;
 431           _M_t3=__in._M_t3;
 432           return *this;
 433         }
 434
 435       template<int __i, typename _Up>
 436         friend class __get_helper;
 437       template<typename, typename, typename, typename, typename, typename,
 438                typename, typename, typename, typename>
 439         friend class tuple;
 440   };
 441
 442   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 443            typename _Tp4>
 444     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _NullClass, _NullClass,
 445                 _NullClass, _NullClass, _NullClass>
 446     {
 447       _Tp0 _M_t0;
 448       _Tp1 _M_t1;
 449       _Tp2 _M_t2;
 450       _Tp3 _M_t3;
 451       _Tp4 _M_t4;
 452
 453     public:
 454       tuple()
 455       { }
 456
 457       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 458                      typename __add_c_ref<_Tp1>::type __in1,
 459                      typename __add_c_ref<_Tp2>::type __in2,
 460                      typename __add_c_ref<_Tp3>::type __in3,
 461                      typename __add_c_ref<_Tp4>::type __in4):
 462         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4)
 463       { }
 464
 465       tuple(const tuple& __in):
 466         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 467         _M_t3(__in._M_t3), _M_t4(__in._M_t4)
 468       { }
 469
 470       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 471                typename _Up4>
 472         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4>& __in):
 473           _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 474           _M_t3(__in._M_t3), _M_t4(__in._M_t4)
 475         { }
 476
 477       tuple&
 478       operator=(const tuple& __in)
 479       {
 480         _M_t0=__in._M_t0;
 481         _M_t1=__in._M_t1;
 482         _M_t2=__in._M_t2;
 483         _M_t3=__in._M_t3;
 484         _M_t4=__in._M_t4;
 485         return *this;
 486       }
 487
 488       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 489                typename _Up4>
 490         tuple&
 491         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4>& __in)
 492         {
 493           _M_t0=__in._M_t0;
 494           _M_t1=__in._M_t1;
 495           _M_t2=__in._M_t2;
 496           _M_t3=__in._M_t3;
 497           _M_t4=__in._M_t4;
 498           return *this;
 499         }
 500
 501       template<int __i, typename _Up>
 502         friend class __get_helper;
 503       template<typename, typename, typename, typename, typename, typename,
 504                typename, typename, typename, typename>
 505         friend class tuple;
 506   };
 507
 508   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 509            typename _Tp4, typename _Tp5>
 510     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _NullClass, _NullClass,
 511                 _NullClass, _NullClass>
 512     {
 513       _Tp0 _M_t0;
 514       _Tp1 _M_t1;
 515       _Tp2 _M_t2;
 516       _Tp3 _M_t3;
 517       _Tp4 _M_t4;
 518       _Tp5 _M_t5;
 519
 520     public:
 521       tuple()
 522       { }
 523
 524       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 525                      typename __add_c_ref<_Tp1>::type __in1,
 526                      typename __add_c_ref<_Tp2>::type __in2,
 527                      typename __add_c_ref<_Tp3>::type __in3,
 528                      typename __add_c_ref<_Tp4>::type __in4,
 529                      typename __add_c_ref<_Tp5>::type __in5):
 530         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
 531         _M_t5(__in5)
 532       { }
 533
 534       tuple(const tuple& __in):
 535         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 536         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5)
 537       { }
 538
 539       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 540                typename _Up4, typename _Up5>
 541         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5>& __in):
 542           _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 543           _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5)
 544         { }
 545
 546       tuple&
 547       operator=(const tuple& __in)
 548       {
 549         _M_t0=__in._M_t0;
 550         _M_t1=__in._M_t1;
 551         _M_t2=__in._M_t2;
 552         _M_t3=__in._M_t3;
 553         _M_t4=__in._M_t4;
 554         _M_t5=__in._M_t5;
 555         return *this;
 556       }
 557
 558       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 559                typename _Up4, typename _Up5>
 560         tuple&
 561         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5>& __in)
 562         {
 563           _M_t0=__in._M_t0;
 564           _M_t1=__in._M_t1;
 565           _M_t2=__in._M_t2;
 566           _M_t3=__in._M_t3;
 567           _M_t4=__in._M_t4;
 568           _M_t5=__in._M_t5;
 569           return *this;
 570         }
 571
 572       template<int __i, typename _Up>
 573         friend class __get_helper;
 574       template<typename, typename, typename, typename, typename, typename,
 575                typename, typename, typename, typename>
 576         friend class tuple;
 577   };
 578
 579   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 580            typename _Tp4, typename _Tp5, typename _Tp6>
 581     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _NullClass,
 582                 _NullClass, _NullClass>
 583     {
 584       _Tp0 _M_t0;
 585       _Tp1 _M_t1;
 586       _Tp2 _M_t2;
 587       _Tp3 _M_t3;
 588       _Tp4 _M_t4;
 589       _Tp5 _M_t5;
 590       _Tp6 _M_t6;
 591
 592     public:
 593       tuple()
 594       { }
 595
 596       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 597                      typename __add_c_ref<_Tp1>::type __in1,
 598                      typename __add_c_ref<_Tp2>::type __in2,
 599                      typename __add_c_ref<_Tp3>::type __in3,
 600                      typename __add_c_ref<_Tp4>::type __in4,
 601                      typename __add_c_ref<_Tp5>::type __in5,
 602                      typename __add_c_ref<_Tp6>::type __in6):
 603         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
 604         _M_t5(__in5), _M_t6(__in6)
 605       { }
 606
 607       tuple(const tuple& __in):
 608         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 609         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
 610         _M_t6(__in._M_t6)
 611       { }
 612
 613       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 614                typename _Up4, typename _Up5, typename _Up6>
 615         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6>& __in):
 616           _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 617           _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
 618           _M_t6(__in._M_t6)
 619         { }
 620
 621       tuple&
 622       operator=(const tuple& __in)
 623       {
 624         _M_t0=__in._M_t0;
 625         _M_t1=__in._M_t1;
 626         _M_t2=__in._M_t2;
 627         _M_t3=__in._M_t3;
 628         _M_t4=__in._M_t4;
 629         _M_t5=__in._M_t5;
 630         _M_t6=__in._M_t6;
 631         return *this;
 632       }
 633
 634       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 635                typename _Up4, typename _Up5, typename _Up6>
 636         tuple&
 637         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5,
 638                               _Up6>& __in)
 639         {
 640           _M_t0=__in._M_t0;
 641           _M_t1=__in._M_t1;
 642           _M_t2=__in._M_t2;
 643           _M_t3=__in._M_t3;
 644           _M_t4=__in._M_t4;
 645           _M_t5=__in._M_t5;
 646           _M_t6=__in._M_t6;
 647           return *this;
 648         }
 649
 650       template<int __i, typename _Up>
 651         friend class __get_helper;
 652       template<typename, typename, typename, typename, typename, typename,
 653                typename, typename, typename, typename>
 654         friend class tuple;
 655   };
 656
 657   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 658            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
 659     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _NullClass,
 660                 _NullClass>
 661     {
 662       _Tp0 _M_t0;
 663       _Tp1 _M_t1;
 664       _Tp2 _M_t2;
 665       _Tp3 _M_t3;
 666       _Tp4 _M_t4;
 667       _Tp5 _M_t5;
 668       _Tp6 _M_t6;
 669       _Tp7 _M_t7;
 670
 671     public:
 672       tuple()
 673       { }
 674
 675       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 676                      typename __add_c_ref<_Tp1>::type __in1,
 677                      typename __add_c_ref<_Tp2>::type __in2,
 678                      typename __add_c_ref<_Tp3>::type __in3,
 679                      typename __add_c_ref<_Tp4>::type __in4,
 680                      typename __add_c_ref<_Tp5>::type __in5,
 681                      typename __add_c_ref<_Tp6>::type __in6,
 682                      typename __add_c_ref<_Tp7>::type __in7):
 683         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
 684         _M_t5(__in5), _M_t6(__in6), _M_t7(__in7)
 685       { }
 686
 687       tuple(const tuple& __in):
 688         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 689         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
 690         _M_t6(__in._M_t6), _M_t7(__in._M_t7)
 691       { }
 692
 693       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 694                typename _Up4, typename _Up5, typename _Up6, typename _Up7>
 695         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6,
 696                           _Up7>& __in):
 697           _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 698           _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
 699           _M_t6(__in._M_t6), _M_t7(__in._M_t7)
 700         { }
 701
 702       tuple&
 703       operator=(const tuple& __in)
 704       {
 705         _M_t0=__in._M_t0;
 706         _M_t1=__in._M_t1;
 707         _M_t2=__in._M_t2;
 708         _M_t3=__in._M_t3;
 709         _M_t4=__in._M_t4;
 710         _M_t5=__in._M_t5;
 711         _M_t6=__in._M_t6;
 712         _M_t7=__in._M_t7;
 713         return *this;
 714       }
 715
 716       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 717                typename _Up4, typename _Up5, typename _Up6, typename _Up7>
 718         tuple&
 719         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6,
 720                               _Up7>& __in)
 721         {
 722           _M_t0=__in._M_t0;
 723           _M_t1=__in._M_t1;
 724           _M_t2=__in._M_t2;
 725           _M_t3=__in._M_t3;
 726           _M_t4=__in._M_t4;
 727           _M_t5=__in._M_t5;
 728           _M_t6=__in._M_t6;
 729           _M_t7=__in._M_t7;
 730           return *this;
 731         }
 732
 733       template<int __i, typename _Up>
 734         friend class __get_helper;
 735       template<typename, typename, typename, typename, typename, typename,
 736                typename, typename, typename, typename>
 737         friend class tuple;
 738   };
 739
 740   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 741            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
 742            typename _Tp8>
 743     class tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
 744                 _NullClass>
 745     {
 746       _Tp0 _M_t0;
 747       _Tp1 _M_t1;
 748       _Tp2 _M_t2;
 749       _Tp3 _M_t3;
 750       _Tp4 _M_t4;
 751       _Tp5 _M_t5;
 752       _Tp6 _M_t6;
 753       _Tp7 _M_t7;
 754       _Tp8 _M_t8;
 755
 756     public:
 757       tuple()
 758       { }
 759
 760       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 761                      typename __add_c_ref<_Tp1>::type __in1,
 762                      typename __add_c_ref<_Tp2>::type __in2,
 763                      typename __add_c_ref<_Tp3>::type __in3,
 764                      typename __add_c_ref<_Tp4>::type __in4,
 765                      typename __add_c_ref<_Tp5>::type __in5,
 766                      typename __add_c_ref<_Tp6>::type __in6,
 767                      typename __add_c_ref<_Tp7>::type __in7,
 768                      typename __add_c_ref<_Tp8>::type __in8):
 769         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
 770         _M_t5(__in5), _M_t6(__in6), _M_t7(__in7), _M_t8(__in8)
 771       { }
 772
 773       tuple(const tuple& __in):
 774         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 775         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
 776         _M_t6(__in._M_t6), _M_t7(__in._M_t7), _M_t8(__in._M_t8)
 777       { }
 778
 779       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 780                typename _Up4, typename _Up5, typename _Up6, typename _Up7,
 781                typename _Up8>
 782         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7,
 783                           _Up8>& __in):
 784           _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 785           _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
 786           _M_t6(__in._M_t6), _M_t7(__in._M_t7), _M_t8(__in._M_t8)
 787         { }
 788
 789       tuple&
 790       operator=(const tuple& __in)
 791       {
 792         _M_t0=__in._M_t0;
 793         _M_t1=__in._M_t1;
 794         _M_t2=__in._M_t2;
 795         _M_t3=__in._M_t3;
 796         _M_t4=__in._M_t4;
 797         _M_t5=__in._M_t5;
 798         _M_t6=__in._M_t6;
 799         _M_t7=__in._M_t7;
 800         _M_t8=__in._M_t8;
 801         return *this;
 802       }
 803
 804       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 805                typename _Up4, typename _Up5, typename _Up6, typename _Up7,
 806                typename _Up8>
 807         tuple&
 808         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7,
 809                               _Up8>& __in)
 810         {
 811           _M_t0=__in._M_t0;
 812           _M_t1=__in._M_t1;
 813           _M_t2=__in._M_t2;
 814           _M_t3=__in._M_t3;
 815           _M_t4=__in._M_t4;
 816           _M_t5=__in._M_t5;
 817           _M_t6=__in._M_t6;
 818           _M_t7=__in._M_t7;
 819           _M_t8=__in._M_t8;
 820           return *this;
 821         }
 822
 823       template<int __i, typename _Up>
 824         friend class __get_helper;
 825       template<typename, typename, typename, typename, typename, typename,
 826                typename, typename, typename, typename>
 827         friend class tuple;
 828   };
 829
 830   /// @brief  Template class tuple
 831   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
 832            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
 833            typename _Tp8, typename _Tp9>
 834     class tuple
 835     {
 836       _Tp0 _M_t0;
 837       _Tp1 _M_t1;
 838       _Tp2 _M_t2;
 839       _Tp3 _M_t3;
 840       _Tp4 _M_t4;
 841       _Tp5 _M_t5;
 842       _Tp6 _M_t6;
 843       _Tp7 _M_t7;
 844       _Tp8 _M_t8;
 845       _Tp9 _M_t9;
 846
 847     public:
 848       tuple()
 849       { }
 850
 851       explicit tuple(typename __add_c_ref<_Tp0>::type __in0,
 852                      typename __add_c_ref<_Tp1>::type __in1,
 853                      typename __add_c_ref<_Tp2>::type __in2,
 854                      typename __add_c_ref<_Tp3>::type __in3,
 855                      typename __add_c_ref<_Tp4>::type __in4,
 856                      typename __add_c_ref<_Tp5>::type __in5,
 857                      typename __add_c_ref<_Tp6>::type __in6,
 858                      typename __add_c_ref<_Tp7>::type __in7,
 859                      typename __add_c_ref<_Tp8>::type __in8,
 860                      typename __add_c_ref<_Tp9>::type __in9):
 861         _M_t0(__in0), _M_t1(__in1), _M_t2(__in2), _M_t3(__in3), _M_t4(__in4),
 862         _M_t5(__in5), _M_t6(__in6), _M_t7(__in7), _M_t8(__in8), _M_t9(__in9)
 863       { }
 864
 865       tuple(const tuple& __in):
 866         _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 867         _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
 868         _M_t6(__in._M_t6), _M_t7(__in._M_t7), _M_t8(__in._M_t8),
 869         _M_t9(__in._M_t9)
 870       { }
 871
 872       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 873                typename _Up4, typename _Up5, typename _Up6, typename _Up7,
 874                typename _Up8, typename _Up9>
 875         tuple(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8,
 876                           _Up9>& __in):
 877           _M_t0(__in._M_t0), _M_t1(__in._M_t1), _M_t2(__in._M_t2),
 878           _M_t3(__in._M_t3), _M_t4(__in._M_t4), _M_t5(__in._M_t5),
 879           _M_t6(__in._M_t6), _M_t7(__in._M_t7), _M_t8(__in._M_t8),
 880           _M_t9(__in._M_t9)
 881         { }
 882
 883       tuple&
 884       operator=(const tuple& __in)
 885       {
 886         _M_t0=__in._M_t0;
 887         _M_t1=__in._M_t1;
 888         _M_t2=__in._M_t2;
 889         _M_t3=__in._M_t3;
 890         _M_t4=__in._M_t4;
 891         _M_t5=__in._M_t5;
 892         _M_t6=__in._M_t6;
 893         _M_t7=__in._M_t7;
 894         _M_t8=__in._M_t8;
 895         _M_t9=__in._M_t9;
 896         return *this;
 897       }
 898
 899       template<typename _Up0, typename _Up1, typename _Up2, typename _Up3,
 900                typename _Up4, typename _Up5, typename _Up6, typename _Up7,
 901                typename _Up8, typename _Up9>
 902         tuple&
 903         operator=(const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7,
 904                               _Up8, _Up9>& __in)
 905         {
 906           _M_t0=__in._M_t0;
 907           _M_t1=__in._M_t1;
 908           _M_t2=__in._M_t2;
 909           _M_t3=__in._M_t3;
 910           _M_t4=__in._M_t4;
 911           _M_t5=__in._M_t5;
 912           _M_t6=__in._M_t6;
 913           _M_t7=__in._M_t7;
 914           _M_t8=__in._M_t8;
 915           _M_t9=__in._M_t9;
 916           return *this;
 917         }
 918
 919       template<int __i, typename _Up>
 920         friend class __get_helper;
 921       template<typename, typename, typename, typename, typename, typename,
 922                typename, typename, typename, typename>
 923         friend class tuple;
 924   };
 925
 926   // Class used in the implementation of get
 927   template<int __i, typename _Tp>
 928     struct __get_helper;
 929
 930   template<typename _Tp>
 931     struct __get_helper<0, _Tp>
 932     {
 933       static typename __add_ref<typename tuple_element<0, _Tp>::type>::type
 934       get_value(_Tp& __in)
 935       { return __in._M_t0; }
 936
 937       static typename __add_c_ref<typename tuple_element<0, _Tp>::type>::type
 938       get_value(const _Tp& __in)
 939       { return __in._M_t0; }
 940     };
 941
 942   template<typename _Tp>
 943     struct __get_helper<1, _Tp>
 944     {
 945       static typename __add_ref<typename tuple_element<1, _Tp>::type>::type
 946       get_value(_Tp& __in)
 947       { return __in._M_t1; }
 948
 949       static typename __add_c_ref<typename tuple_element<1, _Tp>::type>::type
 950       get_value(const _Tp& __in)
 951       { return __in._M_t1; }
 952     };
 953
 954   template<typename _Tp>
 955     struct __get_helper<2, _Tp>
 956     {
 957       static typename __add_ref<typename tuple_element<2, _Tp>::type>::type
 958       get_value(_Tp& __in)
 959       { return __in._M_t2; }
 960
 961       static typename __add_c_ref<typename tuple_element<2, _Tp>::type>::type
 962       get_value(const _Tp& __in)
 963       { return __in._M_t2; }
 964     };
 965
 966   template<typename _Tp>
 967     struct __get_helper<3, _Tp>
 968     {
 969       static typename __add_ref<typename tuple_element<3, _Tp>::type>::type
 970       get_value(_Tp& __in)
 971       { return __in._M_t3; }
 972
 973       static typename __add_c_ref<typename tuple_element<3, _Tp>::type>::type
 974       get_value(const _Tp& __in)
 975       { return __in._M_t3; }
 976     };
 977
 978   template<typename _Tp>
 979     struct __get_helper<4, _Tp>
 980     {
 981       static typename __add_ref<typename tuple_element<4, _Tp>::type>::type
 982       get_value(_Tp& __in)
 983       { return __in._M_t4; }
 984
 985       static typename __add_c_ref<typename tuple_element<4, _Tp>::type>::type
 986       get_value(const _Tp& __in)
 987       { return __in._M_t4; }
 988     };
 989
 990   template<typename _Tp>
 991     struct __get_helper<5, _Tp>
 992     {
 993       static typename __add_ref<typename tuple_element<5, _Tp>::type>::type
 994       get_value(_Tp& __in)
 995       { return __in._M_t5; }
 996
 997       static typename __add_c_ref<typename tuple_element<5, _Tp>::type>::type
 998       get_value(const _Tp& __in)
 999       { return __in._M_t5; }
1000     };
1001
1002   template<typename _Tp>
1003     struct __get_helper<6, _Tp>
1004     {
1005       static typename __add_ref<typename tuple_element<6, _Tp>::type>::type
1006       get_value(_Tp& __in)
1007       { return __in._M_t6; }
1008
1009       static typename __add_c_ref<typename tuple_element<6, _Tp>::type>::type
1010       get_value(const _Tp& __in)
1011       { return __in._M_t6; }
1012     };
1013
1014   template<typename _Tp>
1015     struct __get_helper<7, _Tp>
1016     {
1017       static typename __add_ref<typename tuple_element<7, _Tp>::type>::type
1018       get_value(_Tp& __in)
1019       { return __in._M_t7; }
1020
1021       static typename __add_c_ref<typename tuple_element<7, _Tp>::type>::type
1022       get_value(const _Tp& __in)
1023       { return __in._M_t7; }
1024     };
1025
1026   template<typename _Tp>
1027     struct __get_helper<8, _Tp>
1028     {
1029       static typename __add_ref<typename tuple_element<8, _Tp>::type>::type
1030       get_value(_Tp& __in)
1031       { return __in._M_t8; }
1032
1033       static typename __add_c_ref<typename tuple_element<8, _Tp>::type>::type
1034       get_value(const _Tp& __in)
1035       { return __in._M_t8; }
1036     };
1037
1038   template<typename _Tp>
1039     struct __get_helper<9, _Tp>
1040     {
1041       static typename __add_ref<typename tuple_element<9, _Tp>::type>::type
1042       get_value(_Tp& __in)
1043       { return __in._M_t9; }
1044
1045       static typename __add_c_ref<typename tuple_element<9, _Tp>::type>::type
1046       get_value(const _Tp& __in)
1047       { return __in._M_t9; }
1048     };
1049
1050   // Returns a reference to the ith element of a tuple.
1051   // Any const or non-const ref elements are returned with their original type.
1052   template<int __i, typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1053                     typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1054                     typename _Tp8, typename _Tp9>
1055     typename __add_ref<typename tuple_element<__i, tuple<_Tp0, _Tp1, _Tp2,
1056                                                          _Tp3, _Tp4, _Tp5,
1057                                                          _Tp6, _Tp7, _Tp8,
1058                                                          _Tp9> >::type>::type
1059     get(tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
1060               _Tp9>& __t)
1061     {
1062       return __get_helper<__i, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
1063                                      _Tp7, _Tp8, _Tp9> >::get_value(__t);
1064     }
1065
1066   // Returns a const reference to the ith element of a tuple.
1067   // Any const or non-const ref elements are returned with their original type.
1068   template<int __i, typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1069                     typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1070                     typename _Tp8, typename _Tp9>
1071     typename __add_c_ref<typename tuple_element<__i, tuple<_Tp0, _Tp1, _Tp2,
1072                                                            _Tp3, _Tp4, _Tp5,
1073                                                            _Tp6, _Tp7, _Tp8,
1074                                                            _Tp9> >::type>::type
1075     get(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
1076                     _Tp9>& __t)
1077     {
1078       return __get_helper<__i, tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
1079                                      _Tp7, _Tp8, _Tp9> >::get_value(__t);
1080     }
1081
1082   // This class helps construct the various comparison operations on tuples
1083   template<int __check_equal_size, int __i, int __j, typename _Tp, typename _Up>
1084     struct __tuple_compare;
1085
1086   template<int __i, int __j, typename _Tp, typename _Up>
1087     struct __tuple_compare<0, __i, __j, _Tp, _Up>
1088     {
1089       static bool __eq(const _Tp& __t, const _Up& __u)
1090       {
1091         return get<__i>(__t) == get<__i>(__u) &&
1092            __tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u);
1093       }
1094       static bool __less(const _Tp& __t, const _Up& __u)
1095       {
1096         return (get<__i>(__t) < get<__i>(__u)) || !(get<__i>(__u) < get<__i>(__t)) &&
1097            __tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u);
1098       }
1099     };
1100
1101   template<int __i, typename _Tp, typename _Up>
1102     struct __tuple_compare<0, __i, __i, _Tp, _Up>
1103     {
1104       static bool __eq(const _Tp&, const _Up&)
1105       { return true; }
1106       static bool __less(const _Tp&, const _Up&)
1107       { return false; }
1108     };
1109
1110   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1111            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1112            typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
1113            typename _Up2, typename _Up3, typename _Up4, typename _Up5,
1114            typename _Up6, typename _Up7, typename _Up8, typename _Up9>
1115   bool
1116   operator==(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
1117              const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
1118   {
1119     typedef tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
1120                   _Tp9> _Tp;
1121     typedef tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8,
1122                   _Up9> _Up;
1123     return __tuple_compare<tuple_size<_Tp>::value -
1124      tuple_size<_Tp>::value, 0,
1125       tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u);
1126   }
1127
1128   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1129            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1130            typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
1131            typename _Up2, typename _Up3, typename _Up4, typename _Up5,
1132            typename _Up6, typename _Up7, typename _Up8, typename _Up9>
1133   bool
1134   operator<(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
1135             const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
1136   {
1137     typedef tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8,
1138                   _Tp9> _Tp;
1139     typedef tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8,
1140                   _Up9> _Up;
1141     return __tuple_compare<tuple_size<_Tp>::value -
1142      tuple_size<_Tp>::value, 0,
1143       tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u);
1144   }
1145
1146   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1147            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1148            typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
1149            typename _Up2, typename _Up3, typename _Up4, typename _Up5,
1150            typename _Up6, typename _Up7, typename _Up8, typename _Up9>
1151   bool
1152   operator!=(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
1153              const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
1154   {
1155       return !(__t == __u);
1156   }
1157   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1158            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1159            typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
1160            typename _Up2, typename _Up3, typename _Up4, typename _Up5,
1161            typename _Up6, typename _Up7, typename _Up8, typename _Up9>
1162   bool
1163   operator>(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
1164             const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
1165   {
1166       return __u < __t;
1167   }
1168   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1169            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1170            typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
1171            typename _Up2, typename _Up3, typename _Up4, typename _Up5,
1172            typename _Up6, typename _Up7, typename _Up8, typename _Up9>
1173   bool
1174   operator<=(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
1175              const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
1176   {
1177       return !(__u < __t);
1178   }
1179   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1180            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1181            typename _Tp8, typename _Tp9, typename _Up0, typename _Up1,
1182            typename _Up2, typename _Up3, typename _Up4, typename _Up5,
1183            typename _Up6, typename _Up7, typename _Up8, typename _Up9>
1184   bool
1185   operator>=(const tuple<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>& __t,
1186              const tuple<_Up0, _Up1, _Up2, _Up3, _Up4, _Up5, _Up6, _Up7, _Up8, _Up9>& __u)
1187   {
1188       return !(__t < __u);
1189   }
1190
1191   // Helper which adds a reference to a type when given a reference_wrapper
1192   template<typename _Tp>
1193     struct __strip_reference_wrapper
1194     {
1195         typedef _Tp __type;
1196     };
1197
1198   template<typename _Tp>
1199     struct __strip_reference_wrapper<reference_wrapper<_Tp> >
1200     {
1201       typedef _Tp& __type;
1202     };
1203
1204   template<typename _Tp>
1205     struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
1206     {
1207         typedef _Tp& __type;
1208     };
1209
1210   template<typename _Tp0 = _NullClass, typename _Tp1 = _NullClass,
1211            typename _Tp2 = _NullClass, typename _Tp3 = _NullClass,
1212            typename _Tp4 = _NullClass, typename _Tp5 = _NullClass,
1213            typename _Tp6 = _NullClass, typename _Tp7 = _NullClass,
1214            typename _Tp8 = _NullClass, typename _Tp9 = _NullClass>
1215     struct __stripped_tuple_type
1216     {
1217       typedef tuple<typename __strip_reference_wrapper<_Tp0>::__type,
1218                     typename __strip_reference_wrapper<_Tp1>::__type,
1219                     typename __strip_reference_wrapper<_Tp2>::__type,
1220                     typename __strip_reference_wrapper<_Tp3>::__type,
1221                     typename __strip_reference_wrapper<_Tp4>::__type,
1222                     typename __strip_reference_wrapper<_Tp5>::__type,
1223                     typename __strip_reference_wrapper<_Tp6>::__type,
1224                     typename __strip_reference_wrapper<_Tp7>::__type,
1225                     typename __strip_reference_wrapper<_Tp8>::__type,
1226                     typename __strip_reference_wrapper<_Tp9>::__type>      __type;
1227     };
1228
1229   tuple<>
1230   make_tuple()
1231   { return tuple<>(); }
1232
1233   template< typename _Tp0>
1234     typename __stripped_tuple_type< _Tp0>::__type
1235     make_tuple( _Tp0 __t0)
1236     {
1237       return typename  __stripped_tuple_type< _Tp0>::
1238         __type( __t0);
1239     }
1240
1241   template<typename _Tp0, typename _Tp1>
1242     typename __stripped_tuple_type<_Tp0, _Tp1>::__type
1243     make_tuple(_Tp0 __t0, _Tp1 __t1)
1244     {
1245       return typename  __stripped_tuple_type<_Tp0, _Tp1>::
1246         __type(__t0, __t1);
1247     }
1248
1249   template<typename _Tp0, typename _Tp1, typename _Tp2>
1250     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2>::__type
1251     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2)
1252     {
1253       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2>::
1254         __type(__t0, __t1, __t2);
1255     }
1256
1257   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
1258     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3>::__type
1259     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3)
1260     {
1261       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3>::
1262         __type(__t0, __t1, __t2, __t3);
1263     }
1264
1265   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1266            typename _Tp4>
1267     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4>::__type
1268     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4)
1269     {
1270       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4>::
1271         __type(__t0, __t1, __t2, __t3, __t4);
1272     }
1273
1274   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1275            typename _Tp4, typename _Tp5>
1276     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
1277                                    _Tp5>::__type
1278     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
1279                _Tp5 __t5)
1280     {
1281       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
1282                                              _Tp5>::
1283         __type(__t0, __t1, __t2, __t3, __t4, __t5);
1284     }
1285
1286   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1287            typename _Tp4, typename _Tp5, typename _Tp6>
1288     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5,
1289                                    _Tp6>::__type
1290     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
1291                _Tp5 __t5, _Tp6 __t6)
1292     {
1293       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
1294                                              _Tp5, _Tp6>::
1295         __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6);
1296     }
1297
1298   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1299            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
1300     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
1301                                    _Tp7>::__type
1302     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
1303                _Tp5 __t5, _Tp6 __t6, _Tp7 __t7)
1304     {
1305       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
1306                                              _Tp5, _Tp6, _Tp7>::
1307         __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7);
1308     }
1309
1310   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1311            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1312            typename _Tp8>
1313     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
1314                                    _Tp7, _Tp8>::__type
1315     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
1316                _Tp5 __t5, _Tp6 __t6, _Tp7 __t7, _Tp8 __t8)
1317     {
1318       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
1319                                              _Tp5, _Tp6, _Tp7, _Tp8>::
1320         __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7, __t8);
1321     }
1322
1323   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1324            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1325            typename _Tp8, typename _Tp9>
1326     typename __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4, _Tp5, _Tp6,
1327                                    _Tp7, _Tp8, _Tp9>::__type
1328     make_tuple(_Tp0 __t0, _Tp1 __t1, _Tp2 __t2, _Tp3 __t3, _Tp4 __t4,
1329                _Tp5 __t5, _Tp6 __t6, _Tp7 __t7, _Tp8 __t8, _Tp9 __t9)
1330     {
1331       return typename  __stripped_tuple_type<_Tp0, _Tp1, _Tp2, _Tp3, _Tp4,
1332                                              _Tp5, _Tp6, _Tp7, _Tp8, _Tp9>::
1333         __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7, __t8, __t9);
1334     }
1335
1336   // A class (and instance) which can be used in 'tie' when an element
1337   // of a tuple is not required
1338   struct swallow_assign
1339   {
1340     template<class T>
1341     swallow_assign&
1342       operator=(const T&)
1343       { return *this; }
1344   };
1345
1346   // TODO: Put this in some kind of shared file.
1347   namespace
1348   {
1349     swallow_assign ignore;
1350   };
1351
1352
1353   // Forms a tuple of references to a list of variables.
1354   template< typename _Tp0>
1355     tuple< _Tp0&>
1356     tie( _Tp0& __t0)
1357     {
1358       return make_tuple( ref(__t0));
1359     };
1360
1361   template<typename _Tp0, typename _Tp1>
1362     tuple<_Tp0&, _Tp1&>
1363     tie(_Tp0& __t0, _Tp1& __t1)
1364     {
1365       return make_tuple(ref(__t0), ref(__t1));
1366     };
1367
1368   template<typename _Tp0, typename _Tp1, typename _Tp2>
1369     tuple<_Tp0&, _Tp1&, _Tp2&>
1370     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2)
1371     {
1372       return make_tuple(ref(__t0), ref(__t1), ref(__t2));
1373     };
1374
1375   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
1376     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&>
1377     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3)
1378     {
1379       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3));
1380     };
1381
1382   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1383            typename _Tp4>
1384     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&>
1385     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4)
1386     {
1387       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3),
1388                         ref(__t4));
1389     };
1390
1391   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1392            typename _Tp4, typename _Tp5>
1393     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&>
1394     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4,
1395         _Tp5& __t5)
1396     {
1397       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
1398                         ref(__t5));
1399     };
1400
1401   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1402            typename _Tp4, typename _Tp5, typename _Tp6>
1403     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&, _Tp6&>
1404     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4, _Tp5& __t5,
1405         _Tp6& __t6)
1406     {
1407       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
1408                         ref(__t5), ref(__t6));
1409     };
1410
1411   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1412            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
1413     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&, _Tp6&, _Tp7&>
1414     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4, _Tp5& __t5,
1415         _Tp6& __t6, _Tp7& __t7)
1416     {
1417       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
1418                         ref(__t5), ref(__t6), ref(__t7));
1419     };
1420
1421   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1422            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1423            typename _Tp8>
1424     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&, _Tp6&, _Tp7&, _Tp8&>
1425     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4, _Tp5& __t5,
1426         _Tp6& __t6, _Tp7& __t7, _Tp8& __t8)
1427     {
1428       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
1429                         ref(__t5), ref(__t6), ref(__t7), ref(__t8));
1430     };
1431
1432   template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
1433            typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
1434            typename _Tp8, typename _Tp9>
1435     tuple<_Tp0&, _Tp1&, _Tp2&, _Tp3&, _Tp4&, _Tp5&, _Tp6&, _Tp7&, _Tp8&,
1436           _Tp9&>
1437     tie(_Tp0& __t0, _Tp1& __t1, _Tp2& __t2, _Tp3& __t3, _Tp4& __t4, _Tp5& __t5,
1438         _Tp6& __t6, _Tp7& __t7, _Tp8& __t8, _Tp9& __t9)
1439     {
1440       return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3), ref(__t4),
1441                         ref(__t5), ref(__t6), ref(__t7), ref(__t8),
1442                         ref(__t9));
1443     };
1444
1445 }
1446 }
1447
1448 #endif
1449