contrib/gcc-4.4/libstdc++-v3/include/std/tuple

   1 // <tuple> -*- C++ -*-
   2
   3 // Copyright (C) 2007, 2008, 2009 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 3, 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 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file include/tuple
  26  *  This is a Standard C++ Library header.
  27  */
  28
  29 #ifndef _GLIBCXX_TUPLE
  30 #define _GLIBCXX_TUPLE 1
  31
  32 #pragma GCC system_header
  33
  34 #ifndef __GXX_EXPERIMENTAL_CXX0X__
  35 # include <c++0x_warning.h>
  36 #else
  37
  38 #include <utility>
  39
  40 namespace std
  41 {
  42   // Adds a const reference to a non-reference type.
  43   template<typename _Tp>
  44     struct __add_c_ref
  45     { typedef const _Tp& type; };
  46
  47   template<typename _Tp>
  48     struct __add_c_ref<_Tp&>
  49     { typedef _Tp& type; };
  50
  51   // Adds a reference to a non-reference type.
  52   template<typename _Tp>
  53     struct __add_ref
  54     { typedef _Tp& type; };
  55
  56   template<typename _Tp>
  57     struct __add_ref<_Tp&>
  58     { typedef _Tp& type; };
  59
  60   template<std::size_t _Idx, typename _Head, bool _IsEmpty>
  61     struct _Head_base;
  62
  63   template<std::size_t _Idx, typename _Head>
  64     struct _Head_base<_Idx, _Head, true>
  65     : public _Head
  66     {
  67       _Head_base()
  68       : _Head() { }
  69
  70       _Head_base(const _Head& __h)
  71       : _Head(__h) { }
  72
  73       template<typename _UHead>
  74         _Head_base(_UHead&& __h)
  75         : _Head(std::forward<_UHead>(__h)) { }
  76
  77       _Head&       _M_head()       { return *this; }
  78       const _Head& _M_head() const { return *this; }
  79
  80       void _M_swap_impl(_Head&&) { /* no-op */ }
  81     };
  82
  83   template<std::size_t _Idx, typename _Head>
  84     struct _Head_base<_Idx, _Head, false>
  85     {
  86       _Head_base()
  87       : _M_head_impl() { }
  88
  89       _Head_base(const _Head& __h)
  90       : _M_head_impl(__h) { }
  91
  92       template<typename _UHead>
  93         _Head_base(_UHead&& __h)
  94         : _M_head_impl(std::forward<_UHead>(__h)) { }
  95
  96       _Head&       _M_head()       { return _M_head_impl; }
  97       const _Head& _M_head() const { return _M_head_impl; }
  98
  99       void
 100       _M_swap_impl(_Head&& __h)
 101       {
 102         using std::swap;
 103         swap(__h, _M_head_impl);
 104       }
 105
 106       _Head _M_head_impl;
 107     };
 108
 109   /**
 110    * Contains the actual implementation of the @c tuple template, stored
 111    * as a recursive inheritance hierarchy from the first element (most
 112    * derived class) to the last (least derived class). The @c Idx
 113    * parameter gives the 0-based index of the element stored at this
 114    * point in the hierarchy; we use it to implement a constant-time
 115    * get() operation.
 116    */
 117   template<std::size_t _Idx, typename... _Elements>
 118     struct _Tuple_impl;
 119
 120   /**
 121    * Zero-element tuple implementation. This is the basis case for the
 122    * inheritance recursion.
 123    */
 124   template<std::size_t _Idx>
 125     struct _Tuple_impl<_Idx>
 126     {
 127     protected:
 128       void _M_swap_impl(_Tuple_impl&&) { /* no-op */ }
 129     };
 130
 131   /**
 132    * Recursive tuple implementation. Here we store the @c Head element
 133    * and derive from a @c Tuple_impl containing the remaining elements
 134    * (which contains the @c Tail).
 135    */
 136   template<std::size_t _Idx, typename _Head, typename... _Tail>
 137     struct _Tuple_impl<_Idx, _Head, _Tail...>
 138     : public _Tuple_impl<_Idx + 1, _Tail...>,
 139       private _Head_base<_Idx, _Head, std::is_empty<_Head>::value>
 140     {
 141       typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
 142       typedef _Head_base<_Idx, _Head, std::is_empty<_Head>::value> _Base;
 143
 144       _Head&            _M_head()       { return _Base::_M_head(); }
 145       const _Head&      _M_head() const { return _Base::_M_head(); }
 146
 147       _Inherited&       _M_tail()       { return *this; }
 148       const _Inherited& _M_tail() const { return *this; }
 149
 150       _Tuple_impl()
 151       : _Inherited(), _Base() { }
 152
 153       explicit
 154       _Tuple_impl(const _Head& __head, const _Tail&... __tail)
 155       : _Inherited(__tail...), _Base(__head) { }
 156
 157       template<typename _UHead, typename... _UTail>
 158         explicit
 159         _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
 160         : _Inherited(std::forward<_UTail>(__tail)...),
 161           _Base(std::forward<_UHead>(__head)) { }
 162
 163       _Tuple_impl(const _Tuple_impl& __in)
 164       : _Inherited(__in._M_tail()), _Base(__in._M_head()) { }
 165
 166       _Tuple_impl(_Tuple_impl&& __in)
 167       : _Inherited(std::move<_Inherited&&>(__in._M_tail())),
 168         _Base(std::forward<_Head>(__in._M_head())) { }
 169
 170       template<typename... _UElements>
 171         _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
 172         : _Inherited(__in._M_tail()), _Base(__in._M_head()) { }
 173
 174       template<typename... _UElements>
 175         _Tuple_impl(_Tuple_impl<_Idx, _UElements...>&& __in)
 176         : _Inherited(std::move<typename _Tuple_impl<_Idx, _UElements...>::
 177                      _Inherited&&>(__in._M_tail())),
 178           _Base(std::forward<typename _Tuple_impl<_Idx, _UElements...>::
 179                 _Base>(__in._M_head())) { }
 180
 181       _Tuple_impl&
 182       operator=(const _Tuple_impl& __in)
 183       {
 184         _M_head() = __in._M_head();
 185         _M_tail() = __in._M_tail();
 186         return *this;
 187       }
 188
 189       _Tuple_impl&
 190       operator=(_Tuple_impl&& __in)
 191       {
 192         _M_head() = std::move(__in._M_head());
 193         _M_tail() = std::move(__in._M_tail());
 194         return *this;
 195       }
 196
 197       template<typename... _UElements>
 198         _Tuple_impl&
 199         operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
 200         {
 201           _M_head() = __in._M_head();
 202           _M_tail() = __in._M_tail();
 203           return *this;
 204         }
 205
 206       template<typename... _UElements>
 207         _Tuple_impl&
 208         operator=(_Tuple_impl<_Idx, _UElements...>&& __in)
 209         {
 210           _M_head() = std::move(__in._M_head());
 211           _M_tail() = std::move(__in._M_tail());
 212           return *this;
 213         }
 214
 215     protected:
 216       void
 217       _M_swap_impl(_Tuple_impl&& __in)
 218       {
 219         _Base::_M_swap_impl(__in._M_head());
 220         _Inherited::_M_swap_impl(__in._M_tail());
 221       }
 222     };
 223
 224   /// tuple
 225   template<typename... _Elements>
 226     class tuple : public _Tuple_impl<0, _Elements...>
 227     {
 228       typedef _Tuple_impl<0, _Elements...> _Inherited;
 229
 230     public:
 231       tuple()
 232       : _Inherited() { }
 233
 234       explicit
 235       tuple(const _Elements&... __elements)
 236       : _Inherited(__elements...) { }
 237
 238       template<typename... _UElements>
 239         explicit
 240         tuple(_UElements&&... __elements)
 241         : _Inherited(std::forward<_UElements>(__elements)...) { }
 242
 243       tuple(const tuple& __in)
 244       : _Inherited(static_cast<const _Inherited&>(__in)) { }
 245
 246       tuple(tuple&& __in)
 247       : _Inherited(std::move<_Inherited>(__in)) { }
 248
 249       template<typename... _UElements>
 250         tuple(const tuple<_UElements...>& __in)
 251         : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 252         { }
 253
 254       template<typename... _UElements>
 255         tuple(tuple<_UElements...>&& __in)
 256         : _Inherited(std::move<_Tuple_impl<0, _UElements...> >(__in)) { }
 257
 258       // XXX http://gcc.gnu.org/ml/libstdc++/2008-02/msg00047.html
 259       template<typename... _UElements>
 260         tuple(tuple<_UElements...>& __in)
 261         : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 262         { }
 263
 264       tuple&
 265       operator=(const tuple& __in)
 266       {
 267         static_cast<_Inherited&>(*this) = __in;
 268         return *this;
 269       }
 270
 271       tuple&
 272       operator=(tuple&& __in)
 273       {
 274         static_cast<_Inherited&>(*this) = std::move(__in);
 275         return *this;
 276       }
 277
 278       template<typename... _UElements>
 279         tuple&
 280         operator=(const tuple<_UElements...>& __in)
 281         {
 282           static_cast<_Inherited&>(*this) = __in;
 283           return *this;
 284         }
 285
 286       template<typename... _UElements>
 287         tuple&
 288         operator=(tuple<_UElements...>&& __in)
 289         {
 290           static_cast<_Inherited&>(*this) = std::move(__in);
 291           return *this;
 292         }
 293
 294       void
 295       swap(tuple&& __in)
 296       { _Inherited::_M_swap_impl(__in); }
 297     };
 298
 299
 300   template<>
 301     class tuple<>
 302     {
 303     public:
 304       void swap(tuple&&) { /* no-op */ }
 305     };
 306
 307   /// tuple (2-element), with construction and assignment from a pair.
 308   template<typename _T1, typename _T2>
 309     class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
 310     {
 311       typedef _Tuple_impl<0, _T1, _T2> _Inherited;
 312
 313     public:
 314       tuple()
 315       : _Inherited() { }
 316
 317       explicit
 318       tuple(const _T1& __a1, const _T2& __a2)
 319       : _Inherited(__a1, __a2) { }
 320
 321       template<typename _U1, typename _U2>
 322         explicit
 323         tuple(_U1&& __a1, _U2&& __a2)
 324         : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
 325
 326       tuple(const tuple& __in)
 327       : _Inherited(static_cast<const _Inherited&>(__in)) { }
 328
 329       tuple(tuple&& __in)
 330       : _Inherited(std::move<_Inherited>(__in)) { }
 331
 332       template<typename _U1, typename _U2>
 333         tuple(const tuple<_U1, _U2>& __in)
 334         : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
 335
 336       template<typename _U1, typename _U2>
 337         tuple(tuple<_U1, _U2>&& __in)
 338         : _Inherited(std::move<_Tuple_impl<0, _U1, _U2> >(__in)) { }
 339
 340       template<typename _U1, typename _U2>
 341         tuple(const pair<_U1, _U2>& __in)
 342         : _Inherited(__in.first, __in.second) { }
 343
 344       template<typename _U1, typename _U2>
 345         tuple(pair<_U1, _U2>&& __in)
 346         : _Inherited(std::move(__in.first), std::move(__in.second)) { }
 347
 348       tuple&
 349       operator=(const tuple& __in)
 350       {
 351         static_cast<_Inherited&>(*this) = __in;
 352         return *this;
 353       }
 354
 355       tuple&
 356       operator=(tuple&& __in)
 357       {
 358         static_cast<_Inherited&>(*this) = std::move(__in);
 359         return *this;
 360       }
 361
 362       template<typename _U1, typename _U2>
 363         tuple&
 364         operator=(const tuple<_U1, _U2>& __in)
 365         {
 366           static_cast<_Inherited&>(*this) = __in;
 367           return *this;
 368         }
 369
 370       template<typename _U1, typename _U2>
 371         tuple&
 372         operator=(tuple<_U1, _U2>&& __in)
 373         {
 374           static_cast<_Inherited&>(*this) = std::move(__in);
 375           return *this;
 376         }
 377
 378       template<typename _U1, typename _U2>
 379         tuple&
 380         operator=(const pair<_U1, _U2>& __in)
 381         {
 382           this->_M_head() = __in.first;
 383           this->_M_tail()._M_head() = __in.second;
 384           return *this;
 385         }
 386
 387       template<typename _U1, typename _U2>
 388         tuple&
 389         operator=(pair<_U1, _U2>&& __in)
 390         {
 391           this->_M_head() = std::move(__in.first);
 392           this->_M_tail()._M_head() = std::move(__in.second);
 393           return *this;
 394         }
 395
 396       void
 397       swap(tuple&& __in)
 398       {
 399         using std::swap;
 400         swap(this->_M_head(), __in._M_head());
 401         swap(this->_M_tail()._M_head(), __in._M_tail()._M_head());
 402       }
 403     };
 404
 405
 406   /// Gives the type of the ith element of a given tuple type.
 407   template<std::size_t __i, typename _Tp>
 408     struct tuple_element;
 409
 410   /**
 411    * Recursive case for tuple_element: strip off the first element in
 412    * the tuple and retrieve the (i-1)th element of the remaining tuple.
 413    */
 414   template<std::size_t __i, typename _Head, typename... _Tail>
 415     struct tuple_element<__i, tuple<_Head, _Tail...> >
 416     : tuple_element<__i - 1, tuple<_Tail...> > { };
 417
 418   /**
 419    * Basis case for tuple_element: The first element is the one we're seeking.
 420    */
 421   template<typename _Head, typename... _Tail>
 422     struct tuple_element<0, tuple<_Head, _Tail...> >
 423     {
 424       typedef _Head type;
 425     };
 426
 427   /// Finds the size of a given tuple type.
 428   template<typename _Tp>
 429     struct tuple_size;
 430
 431   /// class tuple_size
 432   template<typename... _Elements>
 433     struct tuple_size<tuple<_Elements...> >
 434     {
 435       static const std::size_t value = sizeof...(_Elements);
 436     };
 437
 438   template<typename... _Elements>
 439     const std::size_t tuple_size<tuple<_Elements...> >::value;
 440
 441   template<std::size_t __i, typename _Head, typename... _Tail>
 442     inline typename __add_ref<_Head>::type
 443     __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
 444     { return __t._M_head(); }
 445
 446   template<std::size_t __i, typename _Head, typename... _Tail>
 447     inline typename __add_c_ref<_Head>::type
 448     __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
 449     { return __t._M_head(); }
 450
 451   // Return a reference (const reference) to the ith element of a tuple.
 452   // Any const or non-const ref elements are returned with their original type.
 453   template<std::size_t __i, typename... _Elements>
 454     inline typename __add_ref<
 455                       typename tuple_element<__i, tuple<_Elements...> >::type
 456                     >::type
 457     get(tuple<_Elements...>& __t)
 458     { return __get_helper<__i>(__t); }
 459
 460   template<std::size_t __i, typename... _Elements>
 461     inline typename __add_c_ref<
 462                       typename tuple_element<__i, tuple<_Elements...> >::type
 463                     >::type
 464     get(const tuple<_Elements...>& __t)
 465     { return __get_helper<__i>(__t); }
 466
 467   // This class helps construct the various comparison operations on tuples
 468   template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j,
 469            typename _Tp, typename _Up>
 470     struct __tuple_compare;
 471
 472   template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up>
 473     struct __tuple_compare<0, __i, __j, _Tp, _Up>
 474     {
 475       static bool __eq(const _Tp& __t, const _Up& __u)
 476       {
 477         return (get<__i>(__t) == get<__i>(__u) &&
 478                 __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u));
 479       }
 480
 481       static bool __less(const _Tp& __t, const _Up& __u)
 482       {
 483         return ((get<__i>(__t) < get<__i>(__u))
 484                 || !(get<__i>(__u) < get<__i>(__t)) &&
 485                 __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u));
 486       }
 487     };
 488
 489   template<std::size_t __i, typename _Tp, typename _Up>
 490     struct __tuple_compare<0, __i, __i, _Tp, _Up>
 491     {
 492       static bool __eq(const _Tp&, const _Up&)
 493       { return true; }
 494
 495       static bool __less(const _Tp&, const _Up&)
 496       { return false; }
 497     };
 498
 499   template<typename... _TElements, typename... _UElements>
 500     bool
 501     operator==(const tuple<_TElements...>& __t,
 502                const tuple<_UElements...>& __u)
 503     {
 504       typedef tuple<_TElements...> _Tp;
 505       typedef tuple<_UElements...> _Up;
 506       return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
 507               0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
 508     }
 509
 510   template<typename... _TElements, typename... _UElements>
 511     bool
 512     operator<(const tuple<_TElements...>& __t,
 513               const tuple<_UElements...>& __u)
 514     {
 515       typedef tuple<_TElements...> _Tp;
 516       typedef tuple<_UElements...> _Up;
 517       return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
 518               0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
 519     }
 520
 521   template<typename... _TElements, typename... _UElements>
 522     inline bool
 523     operator!=(const tuple<_TElements...>& __t,
 524                const tuple<_UElements...>& __u)
 525     { return !(__t == __u); }
 526
 527   template<typename... _TElements, typename... _UElements>
 528     inline bool
 529     operator>(const tuple<_TElements...>& __t,
 530               const tuple<_UElements...>& __u)
 531     { return __u < __t; }
 532
 533   template<typename... _TElements, typename... _UElements>
 534     inline bool
 535     operator<=(const tuple<_TElements...>& __t,
 536                const tuple<_UElements...>& __u)
 537     { return !(__u < __t); }
 538
 539   template<typename... _TElements, typename... _UElements>
 540     inline bool
 541     operator>=(const tuple<_TElements...>& __t,
 542                const tuple<_UElements...>& __u)
 543     { return !(__t < __u); }
 544
 545   // NB: DR 705.
 546   template<typename... _Elements>
 547     inline tuple<typename __decay_and_strip<_Elements>::__type...>
 548     make_tuple(_Elements&&... __args)
 549     {
 550       typedef tuple<typename __decay_and_strip<_Elements>::__type...>
 551         __result_type;
 552       return __result_type(std::forward<_Elements>(__args)...);
 553     }
 554
 555   template<std::size_t...> struct __index_holder { };
 556
 557   template<std::size_t __i, typename _IdxHolder, typename... _Elements>
 558     struct __index_holder_impl;
 559
 560   template<std::size_t __i, std::size_t... _Indexes, typename _IdxHolder,
 561            typename... _Elements>
 562     struct __index_holder_impl<__i, __index_holder<_Indexes...>,
 563                                _IdxHolder, _Elements...>
 564     {
 565       typedef typename __index_holder_impl<__i + 1,
 566                                            __index_holder<_Indexes..., __i>,
 567                                            _Elements...>::type type;
 568     };
 569
 570   template<std::size_t __i, std::size_t... _Indexes>
 571     struct __index_holder_impl<__i, __index_holder<_Indexes...> >
 572     { typedef __index_holder<_Indexes...> type; };
 573
 574   template<typename... _Elements>
 575     struct __make_index_holder
 576     : __index_holder_impl<0, __index_holder<>, _Elements...> { };
 577
 578   template<typename... _TElements, std::size_t... _TIdx,
 579            typename... _UElements, std::size_t... _UIdx>
 580     inline tuple<_TElements..., _UElements...>
 581     __tuple_cat_helper(const tuple<_TElements...>& __t,
 582                        const __index_holder<_TIdx...>&,
 583                        const tuple<_UElements...>& __u,
 584                        const __index_holder<_UIdx...>&)
 585     { return tuple<_TElements..., _UElements...>(get<_TIdx>(__t)...,
 586                                                  get<_UIdx>(__u)...); }
 587
 588   template<typename... _TElements, std::size_t... _TIdx,
 589            typename... _UElements, std::size_t... _UIdx>
 590     inline tuple<_TElements..., _UElements...>
 591     __tuple_cat_helper(tuple<_TElements...>&& __t,
 592                        const __index_holder<_TIdx...>&,
 593                        const tuple<_UElements...>& __u,
 594                        const __index_holder<_UIdx...>&)
 595     { return tuple<_TElements..., _UElements...>
 596         (std::move(get<_TIdx>(__t))..., get<_UIdx>(__u)...); }
 597
 598   template<typename... _TElements, std::size_t... _TIdx,
 599            typename... _UElements, std::size_t... _UIdx>
 600     inline tuple<_TElements..., _UElements...>
 601     __tuple_cat_helper(const tuple<_TElements...>& __t,
 602                        const __index_holder<_TIdx...>&,
 603                        tuple<_UElements...>&& __u,
 604                        const __index_holder<_UIdx...>&)
 605     { return tuple<_TElements..., _UElements...>
 606         (get<_TIdx>(__t)..., std::move(get<_UIdx>(__u))...); }
 607
 608   template<typename... _TElements, std::size_t... _TIdx,
 609            typename... _UElements, std::size_t... _UIdx>
 610     inline tuple<_TElements..., _UElements...>
 611     __tuple_cat_helper(tuple<_TElements...>&& __t,
 612                        const __index_holder<_TIdx...>&,
 613                        tuple<_UElements...>&& __u,
 614                        const __index_holder<_UIdx...>&)
 615     { return tuple<_TElements..., _UElements...>
 616         (std::move(get<_TIdx>(__t))..., std::move(get<_UIdx>(__u))...); }
 617
 618   template<typename... _TElements, typename... _UElements>
 619     inline tuple<_TElements..., _UElements...>
 620     tuple_cat(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u)
 621     {
 622       return __tuple_cat_helper(__t, typename
 623                                 __make_index_holder<_TElements...>::type(),
 624                                 __u, typename
 625                                 __make_index_holder<_UElements...>::type());
 626     }
 627
 628   template<typename... _TElements, typename... _UElements>
 629     inline tuple<_TElements..., _UElements...>
 630     tuple_cat(tuple<_TElements...>&& __t, const tuple<_UElements...>& __u)
 631     {
 632       return __tuple_cat_helper(std::move(__t), typename
 633                                  __make_index_holder<_TElements...>::type(),
 634                                  __u, typename
 635                                  __make_index_holder<_UElements...>::type());
 636     }
 637
 638   template<typename... _TElements, typename... _UElements>
 639     inline tuple<_TElements..., _UElements...>
 640     tuple_cat(const tuple<_TElements...>& __t, tuple<_UElements...>&& __u)
 641     {
 642       return __tuple_cat_helper(__t, typename
 643                                 __make_index_holder<_TElements...>::type(),
 644                                 std::move(__u), typename
 645                                 __make_index_holder<_UElements...>::type());
 646     }
 647
 648   template<typename... _TElements, typename... _UElements>
 649     inline tuple<_TElements..., _UElements...>
 650     tuple_cat(tuple<_TElements...>&& __t, tuple<_UElements...>&& __u)
 651     {
 652       return __tuple_cat_helper(std::move(__t), typename
 653                                 __make_index_holder<_TElements...>::type(),
 654                                 std::move(__u), typename
 655                                 __make_index_holder<_UElements...>::type());
 656     }
 657
 658   template<typename... _Elements>
 659     inline tuple<_Elements&...>
 660     tie(_Elements&... __args)
 661     { return tuple<_Elements&...>(__args...); }
 662
 663   template<typename... _Elements>
 664     inline void
 665     swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
 666     { __x.swap(__y); }
 667
 668   template<typename... _Elements>
 669     inline void
 670     swap(tuple<_Elements...>&& __x, tuple<_Elements...>& __y)
 671     { __x.swap(__y); }
 672
 673   template<typename... _Elements>
 674     inline void
 675     swap(tuple<_Elements...>& __x, tuple<_Elements...>&& __y)
 676     { __x.swap(__y); }
 677
 678   // A class (and instance) which can be used in 'tie' when an element
 679   // of a tuple is not required
 680   struct _Swallow_assign
 681   {
 682     template<class _Tp>
 683       _Swallow_assign&
 684       operator=(const _Tp&)
 685       { return *this; }
 686   };
 687
 688   // TODO: Put this in some kind of shared file.
 689   namespace
 690   {
 691     _Swallow_assign ignore;
 692   }; // anonymous namespace
 693 }
 694
 695 #endif // __GXX_EXPERIMENTAL_CXX0X__
 696
 697 #endif // _GLIBCXX_TUPLE