l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.6/include/std/tuple

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