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