l4/pkg/l4re-core/libstdc++-v3/contrib/libstdc++-v3-4.7/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 #include <bits/uses_allocator.h>
  40
  41 namespace std _GLIBCXX_VISIBILITY(default)
  42 {
  43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  44
  45   // Adds a const reference to a non-reference type.
  46   template<typename _Tp>
  47     struct __add_c_ref
  48     { typedef const _Tp& type; };
  49
  50   template<typename _Tp>
  51     struct __add_c_ref<_Tp&>
  52     { typedef _Tp& type; };
  53
  54   // Adds a reference to a non-reference type.
  55   template<typename _Tp>
  56     struct __add_ref
  57     { typedef _Tp& type; };
  58
  59   template<typename _Tp>
  60     struct __add_ref<_Tp&>
  61     { typedef _Tp& type; };
  62
  63   // Adds an rvalue reference to a non-reference type.
  64   template<typename _Tp>
  65     struct __add_r_ref
  66     { typedef _Tp&& type; };
  67
  68   template<typename _Tp>
  69     struct __add_r_ref<_Tp&>
  70     { typedef _Tp& type; };
  71
  72   template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
  73     struct _Head_base;
  74
  75   template<std::size_t _Idx, typename _Head>
  76     struct _Head_base<_Idx, _Head, true>
  77     : public _Head
  78     {
  79       constexpr _Head_base()
  80       : _Head() { }
  81
  82       constexpr _Head_base(const _Head& __h)
  83       : _Head(__h) { }
  84
  85       template<typename _UHead, typename = typename
  86                enable_if<!is_convertible<_UHead,
  87                                          __uses_alloc_base>::value>::type>
  88         constexpr _Head_base(_UHead&& __h)
  89         : _Head(std::forward<_UHead>(__h)) { }
  90
  91       _Head_base(__uses_alloc0)
  92       : _Head() { }
  93
  94       template<typename _Alloc>
  95         _Head_base(__uses_alloc1<_Alloc> __a)
  96         : _Head(allocator_arg, *__a._M_a) { }
  97
  98       template<typename _Alloc>
  99         _Head_base(__uses_alloc2<_Alloc> __a)
 100         : _Head(*__a._M_a) { }
 101
 102       template<typename _UHead>
 103         _Head_base(__uses_alloc0, _UHead&& __uhead)
 104         : _Head(std::forward<_UHead>(__uhead)) { }
 105
 106       template<typename _Alloc, typename _UHead>
 107         _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 108         : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
 109
 110       template<typename _Alloc, typename _UHead>
 111         _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 112         : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
 113
 114       static constexpr _Head&
 115       _M_head(_Head_base& __b) noexcept { return __b; }
 116
 117       static constexpr const _Head&
 118       _M_head(const _Head_base& __b) noexcept { return __b; }
 119     };
 120
 121   template<std::size_t _Idx, typename _Head>
 122     struct _Head_base<_Idx, _Head, false>
 123     {
 124       constexpr _Head_base()
 125       : _M_head_impl() { }
 126
 127       constexpr _Head_base(const _Head& __h)
 128       : _M_head_impl(__h) { }
 129
 130       template<typename _UHead, typename = typename
 131                enable_if<!is_convertible<_UHead,
 132                                          __uses_alloc_base>::value>::type>
 133         constexpr _Head_base(_UHead&& __h)
 134         : _M_head_impl(std::forward<_UHead>(__h)) { }
 135
 136       _Head_base(__uses_alloc0)
 137       : _M_head_impl() { }
 138
 139       template<typename _Alloc>
 140         _Head_base(__uses_alloc1<_Alloc> __a)
 141         : _M_head_impl(allocator_arg, *__a._M_a) { }
 142
 143       template<typename _Alloc>
 144         _Head_base(__uses_alloc2<_Alloc> __a)
 145         : _M_head_impl(*__a._M_a) { }
 146
 147       template<typename _UHead>
 148         _Head_base(__uses_alloc0, _UHead&& __uhead)
 149         : _M_head_impl(std::forward<_UHead>(__uhead)) { }
 150
 151       template<typename _Alloc, typename _UHead>
 152         _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 153         : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 154         { }
 155
 156       template<typename _Alloc, typename _UHead>
 157         _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 158         : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
 159
 160       static constexpr _Head&
 161       _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
 162
 163       static constexpr const _Head&
 164       _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
 165
 166       _Head _M_head_impl;
 167     };
 168
 169   /**
 170    * Contains the actual implementation of the @c tuple template, stored
 171    * as a recursive inheritance hierarchy from the first element (most
 172    * derived class) to the last (least derived class). The @c Idx
 173    * parameter gives the 0-based index of the element stored at this
 174    * point in the hierarchy; we use it to implement a constant-time
 175    * get() operation.
 176    */
 177   template<std::size_t _Idx, typename... _Elements>
 178     struct _Tuple_impl;
 179
 180   /**
 181    * Zero-element tuple implementation. This is the basis case for the
 182    * inheritance recursion.
 183    */
 184   template<std::size_t _Idx>
 185     struct _Tuple_impl<_Idx>
 186     {
 187       template<std::size_t, typename...> friend class _Tuple_impl;
 188
 189       _Tuple_impl() = default;
 190
 191       template<typename _Alloc>
 192         _Tuple_impl(allocator_arg_t, const _Alloc&) { }
 193
 194       template<typename _Alloc>
 195         _Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { }
 196
 197       template<typename _Alloc>
 198         _Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { }
 199
 200     protected:
 201       void _M_swap(_Tuple_impl&) noexcept { /* no-op */ }
 202     };
 203
 204   // Use the Empty Base-class Optimization for empty, non-final types.
 205   template<typename _Tp>
 206     using __empty_not_final
 207       = typename conditional<__is_final(_Tp), false_type, is_empty<_Tp>>::type;
 208
 209   /**
 210    * Recursive tuple implementation. Here we store the @c Head element
 211    * and derive from a @c Tuple_impl containing the remaining elements
 212    * (which contains the @c Tail).
 213    */
 214   template<std::size_t _Idx, typename _Head, typename... _Tail>
 215     struct _Tuple_impl<_Idx, _Head, _Tail...>
 216     : public _Tuple_impl<_Idx + 1, _Tail...>,
 217       private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
 218     {
 219       template<std::size_t, typename...> friend class _Tuple_impl;
 220
 221       typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
 222       typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
 223
 224       static constexpr _Head&
 225       _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 226
 227       static constexpr const _Head&
 228       _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 229
 230       static constexpr _Inherited&
 231       _M_tail(_Tuple_impl& __t) noexcept { return __t; }
 232
 233       static constexpr const _Inherited&
 234       _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
 235
 236       constexpr _Tuple_impl()
 237       : _Inherited(), _Base() { }
 238
 239       explicit
 240       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
 241       : _Inherited(__tail...), _Base(__head) { }
 242
 243       template<typename _UHead, typename... _UTail, typename = typename
 244                enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
 245         explicit
 246         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
 247         : _Inherited(std::forward<_UTail>(__tail)...),
 248           _Base(std::forward<_UHead>(__head)) { }
 249
 250       constexpr _Tuple_impl(const _Tuple_impl&) = default;
 251
 252       constexpr
 253       _Tuple_impl(_Tuple_impl&& __in)
 254       noexcept(__and_<is_nothrow_move_constructible<_Head>,
 255                       is_nothrow_move_constructible<_Inherited>>::value)
 256       : _Inherited(std::move(_M_tail(__in))),
 257         _Base(std::forward<_Head>(_M_head(__in))) { }
 258
 259       template<typename... _UElements>
 260         constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
 261         : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
 262           _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
 263
 264       template<typename _UHead, typename... _UTails>
 265         constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 266         : _Inherited(std::move
 267                      (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
 268           _Base(std::forward<_UHead>
 269                 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
 270
 271       template<typename _Alloc>
 272         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 273         : _Inherited(__tag, __a),
 274           _Base(__use_alloc<_Head>(__a)) { }
 275
 276       template<typename _Alloc>
 277         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 278                     const _Head& __head, const _Tail&... __tail)
 279         : _Inherited(__tag, __a, __tail...),
 280           _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
 281
 282       template<typename _Alloc, typename _UHead, typename... _UTail,
 283                typename = typename enable_if<sizeof...(_Tail)
 284                                              == sizeof...(_UTail)>::type>
 285         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 286                     _UHead&& __head, _UTail&&... __tail)
 287         : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
 288           _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 289                 std::forward<_UHead>(__head)) { }
 290
 291       template<typename _Alloc>
 292         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 293                     const _Tuple_impl& __in)
 294         : _Inherited(__tag, __a, _M_tail(__in)),
 295           _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
 296
 297       template<typename _Alloc>
 298         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 299                     _Tuple_impl&& __in)
 300         : _Inherited(__tag, __a, std::move(_M_tail(__in))),
 301           _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
 302                 std::forward<_Head>(_M_head(__in))) { }
 303
 304       template<typename _Alloc, typename... _UElements>
 305         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 306                     const _Tuple_impl<_Idx, _UElements...>& __in)
 307         : _Inherited(__tag, __a,
 308                      _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
 309           _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
 310                 _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
 311
 312       template<typename _Alloc, typename _UHead, typename... _UTails>
 313         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 314                     _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 315         : _Inherited(__tag, __a, std::move
 316                      (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
 317           _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 318                 std::forward<_UHead>
 319                 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
 320
 321       _Tuple_impl&
 322       operator=(const _Tuple_impl& __in)
 323       {
 324         _M_head(*this) = _M_head(__in);
 325         _M_tail(*this) = _M_tail(__in);
 326         return *this;
 327       }
 328
 329       _Tuple_impl&
 330       operator=(_Tuple_impl&& __in)
 331       noexcept(__and_<is_nothrow_move_assignable<_Head>,
 332                       is_nothrow_move_assignable<_Inherited>>::value)
 333       {
 334         _M_head(*this) = std::forward<_Head>(_M_head(__in));
 335         _M_tail(*this) = std::move(_M_tail(__in));
 336         return *this;
 337       }
 338
 339       template<typename... _UElements>
 340         _Tuple_impl&
 341         operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
 342         {
 343           _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
 344           _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
 345           return *this;
 346         }
 347
 348       template<typename _UHead, typename... _UTails>
 349         _Tuple_impl&
 350         operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 351         {
 352           _M_head(*this) = std::forward<_UHead>
 353             (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
 354           _M_tail(*this) = std::move
 355             (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
 356           return *this;
 357         }
 358
 359     protected:
 360       void
 361       _M_swap(_Tuple_impl& __in)
 362       noexcept(noexcept(swap(std::declval<_Head&>(),
 363                              std::declval<_Head&>()))
 364                && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
 365       {
 366         using std::swap;
 367         swap(_M_head(*this), _M_head(__in));
 368         _Inherited::_M_swap(_M_tail(__in));
 369       }
 370     };
 371
 372   /// Primary class template, tuple
 373   template<typename... _Elements>
 374     class tuple : public _Tuple_impl<0, _Elements...>
 375     {
 376       typedef _Tuple_impl<0, _Elements...> _Inherited;
 377
 378     public:
 379       constexpr tuple()
 380       : _Inherited() { }
 381
 382       explicit
 383       constexpr tuple(const _Elements&... __elements)
 384       : _Inherited(__elements...) { }
 385
 386       template<typename... _UElements, typename = typename
 387         enable_if<__and_<is_convertible<_UElements,
 388                                         _Elements>...>::value>::type>
 389         explicit
 390         constexpr tuple(_UElements&&... __elements)
 391         : _Inherited(std::forward<_UElements>(__elements)...) { }
 392
 393       constexpr tuple(const tuple&) = default;
 394
 395       constexpr tuple(tuple&&) = default;
 396
 397       template<typename... _UElements, typename = typename
 398         enable_if<__and_<is_convertible<const _UElements&,
 399                                         _Elements>...>::value>::type>
 400         constexpr tuple(const tuple<_UElements...>& __in)
 401         : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 402         { }
 403
 404       template<typename... _UElements, typename = typename
 405         enable_if<__and_<is_convertible<_UElements,
 406                                         _Elements>...>::value>::type>
 407         constexpr tuple(tuple<_UElements...>&& __in)
 408         : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
 409
 410       // Allocator-extended constructors.
 411
 412       template<typename _Alloc>
 413         tuple(allocator_arg_t __tag, const _Alloc& __a)
 414         : _Inherited(__tag, __a) { }
 415
 416       template<typename _Alloc>
 417         tuple(allocator_arg_t __tag, const _Alloc& __a,
 418               const _Elements&... __elements)
 419         : _Inherited(__tag, __a, __elements...) { }
 420
 421       template<typename _Alloc, typename... _UElements, typename = typename
 422                enable_if<sizeof...(_UElements)
 423                          == sizeof...(_Elements)>::type>
 424         tuple(allocator_arg_t __tag, const _Alloc& __a,
 425               _UElements&&... __elements)
 426         : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
 427         { }
 428
 429       template<typename _Alloc>
 430         tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
 431         : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
 432
 433       template<typename _Alloc>
 434         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
 435         : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
 436
 437       template<typename _Alloc, typename... _UElements, typename = typename
 438                enable_if<sizeof...(_UElements)
 439                          == sizeof...(_Elements)>::type>
 440         tuple(allocator_arg_t __tag, const _Alloc& __a,
 441               const tuple<_UElements...>& __in)
 442         : _Inherited(__tag, __a,
 443                      static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 444         { }
 445
 446       template<typename _Alloc, typename... _UElements, typename = typename
 447                enable_if<sizeof...(_UElements)
 448                          == sizeof...(_Elements)>::type>
 449         tuple(allocator_arg_t __tag, const _Alloc& __a,
 450               tuple<_UElements...>&& __in)
 451         : _Inherited(__tag, __a,
 452                      static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
 453         { }
 454
 455       tuple&
 456       operator=(const tuple& __in)
 457       {
 458         static_cast<_Inherited&>(*this) = __in;
 459         return *this;
 460       }
 461
 462       tuple&
 463       operator=(tuple&& __in)
 464       noexcept(is_nothrow_move_assignable<_Inherited>::value)
 465       {
 466         static_cast<_Inherited&>(*this) = std::move(__in);
 467         return *this;
 468       }
 469
 470       template<typename... _UElements, typename = typename
 471                enable_if<sizeof...(_UElements)
 472                          == sizeof...(_Elements)>::type>
 473         tuple&
 474         operator=(const tuple<_UElements...>& __in)
 475         {
 476           static_cast<_Inherited&>(*this) = __in;
 477           return *this;
 478         }
 479
 480       template<typename... _UElements, typename = typename
 481                enable_if<sizeof...(_UElements)
 482                          == sizeof...(_Elements)>::type>
 483         tuple&
 484         operator=(tuple<_UElements...>&& __in)
 485         {
 486           static_cast<_Inherited&>(*this) = std::move(__in);
 487           return *this;
 488         }
 489
 490       void
 491       swap(tuple& __in)
 492       noexcept(noexcept(__in._M_swap(__in)))
 493       { _Inherited::_M_swap(__in); }
 494     };
 495
 496   // Explicit specialization, zero-element tuple.
 497   template<>
 498     class tuple<>
 499     {
 500     public:
 501       void swap(tuple&) noexcept { /* no-op */ }
 502     };
 503
 504   /// Partial specialization, 2-element tuple.
 505   /// Includes construction and assignment from a pair.
 506   template<typename _T1, typename _T2>
 507     class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
 508     {
 509       typedef _Tuple_impl<0, _T1, _T2> _Inherited;
 510
 511     public:
 512       constexpr tuple()
 513       : _Inherited() { }
 514
 515       explicit
 516       constexpr tuple(const _T1& __a1, const _T2& __a2)
 517       : _Inherited(__a1, __a2) { }
 518
 519       template<typename _U1, typename _U2, typename = typename
 520                enable_if<__and_<is_convertible<_U1, _T1>,
 521                                 is_convertible<_U2, _T2>>::value>::type>
 522         explicit
 523         constexpr tuple(_U1&& __a1, _U2&& __a2)
 524         : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
 525
 526       constexpr tuple(const tuple&) = default;
 527
 528       constexpr tuple(tuple&&) = default;
 529
 530       template<typename _U1, typename _U2, typename = typename
 531         enable_if<__and_<is_convertible<const _U1&, _T1>,
 532                          is_convertible<const _U2&, _T2>>::value>::type>
 533         constexpr tuple(const tuple<_U1, _U2>& __in)
 534         : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
 535
 536       template<typename _U1, typename _U2, typename = typename
 537                enable_if<__and_<is_convertible<_U1, _T1>,
 538                                 is_convertible<_U2, _T2>>::value>::type>
 539         constexpr tuple(tuple<_U1, _U2>&& __in)
 540         : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
 541
 542       template<typename _U1, typename _U2, typename = typename
 543         enable_if<__and_<is_convertible<const _U1&, _T1>,
 544                          is_convertible<const _U2&, _T2>>::value>::type>
 545         constexpr tuple(const pair<_U1, _U2>& __in)
 546         : _Inherited(__in.first, __in.second) { }
 547
 548       template<typename _U1, typename _U2, typename = typename
 549                enable_if<__and_<is_convertible<_U1, _T1>,
 550                                 is_convertible<_U2, _T2>>::value>::type>
 551         constexpr tuple(pair<_U1, _U2>&& __in)
 552         : _Inherited(std::forward<_U1>(__in.first),
 553                      std::forward<_U2>(__in.second)) { }
 554
 555       // Allocator-extended constructors.
 556
 557       template<typename _Alloc>
 558         tuple(allocator_arg_t __tag, const _Alloc& __a)
 559         : _Inherited(__tag, __a) { }
 560
 561       template<typename _Alloc>
 562         tuple(allocator_arg_t __tag, const _Alloc& __a,
 563               const _T1& __a1, const _T2& __a2)
 564         : _Inherited(__tag, __a, __a1, __a2) { }
 565
 566       template<typename _Alloc, typename _U1, typename _U2>
 567         tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
 568         : _Inherited(__tag, __a, std::forward<_U1>(__a1),
 569                      std::forward<_U2>(__a2)) { }
 570
 571       template<typename _Alloc>
 572         tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
 573         : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
 574
 575       template<typename _Alloc>
 576         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
 577         : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
 578
 579       template<typename _Alloc, typename _U1, typename _U2>
 580         tuple(allocator_arg_t __tag, const _Alloc& __a,
 581               const tuple<_U1, _U2>& __in)
 582         : _Inherited(__tag, __a,
 583                      static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
 584         { }
 585
 586       template<typename _Alloc, typename _U1, typename _U2>
 587         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
 588         : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
 589         { }
 590
 591       template<typename _Alloc, typename _U1, typename _U2>
 592         tuple(allocator_arg_t __tag, const _Alloc& __a,
 593               const pair<_U1, _U2>& __in)
 594         : _Inherited(__tag, __a, __in.first, __in.second) { }
 595
 596       template<typename _Alloc, typename _U1, typename _U2>
 597         tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
 598         : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
 599                      std::forward<_U2>(__in.second)) { }
 600
 601       tuple&
 602       operator=(const tuple& __in)
 603       {
 604         static_cast<_Inherited&>(*this) = __in;
 605         return *this;
 606       }
 607
 608       tuple&
 609       operator=(tuple&& __in)
 610       noexcept(is_nothrow_move_assignable<_Inherited>::value)
 611       {
 612         static_cast<_Inherited&>(*this) = std::move(__in);
 613         return *this;
 614       }
 615
 616       template<typename _U1, typename _U2>
 617         tuple&
 618         operator=(const tuple<_U1, _U2>& __in)
 619         {
 620           static_cast<_Inherited&>(*this) = __in;
 621           return *this;
 622         }
 623
 624       template<typename _U1, typename _U2>
 625         tuple&
 626         operator=(tuple<_U1, _U2>&& __in)
 627         {
 628           static_cast<_Inherited&>(*this) = std::move(__in);
 629           return *this;
 630         }
 631
 632       template<typename _U1, typename _U2>
 633         tuple&
 634         operator=(const pair<_U1, _U2>& __in)
 635         {
 636           this->_M_head(*this) = __in.first;
 637           this->_M_tail(*this)._M_head(*this) = __in.second;
 638           return *this;
 639         }
 640
 641       template<typename _U1, typename _U2>
 642         tuple&
 643         operator=(pair<_U1, _U2>&& __in)
 644         {
 645           this->_M_head(*this) = std::forward<_U1>(__in.first);
 646           this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
 647           return *this;
 648         }
 649
 650       void
 651       swap(tuple& __in)
 652       noexcept(noexcept(__in._M_swap(__in)))
 653       { _Inherited::_M_swap(__in); }
 654     };
 655
 656
 657   /// Gives the type of the ith element of a given tuple type.
 658   template<std::size_t __i, typename _Tp>
 659     struct tuple_element;
 660
 661   /**
 662    * Recursive case for tuple_element: strip off the first element in
 663    * the tuple and retrieve the (i-1)th element of the remaining tuple.
 664    */
 665   template<std::size_t __i, typename _Head, typename... _Tail>
 666     struct tuple_element<__i, tuple<_Head, _Tail...> >
 667     : tuple_element<__i - 1, tuple<_Tail...> > { };
 668
 669   /**
 670    * Basis case for tuple_element: The first element is the one we're seeking.
 671    */
 672   template<typename _Head, typename... _Tail>
 673     struct tuple_element<0, tuple<_Head, _Tail...> >
 674     {
 675       typedef _Head type;
 676     };
 677
 678   template<std::size_t __i, typename _Tp>
 679     struct tuple_element<__i, const _Tp>
 680     {
 681       typedef typename
 682       add_const<typename tuple_element<__i, _Tp>::type>::type type;
 683     };
 684
 685   template<std::size_t __i, typename _Tp>
 686     struct tuple_element<__i, volatile _Tp>
 687     {
 688       typedef typename
 689       add_volatile<typename tuple_element<__i, _Tp>::type>::type type;
 690     };
 691
 692   template<std::size_t __i, typename _Tp>
 693     struct tuple_element<__i, const volatile _Tp>
 694     {
 695       typedef typename
 696       add_cv<typename tuple_element<__i, _Tp>::type>::type type;
 697     };
 698
 699   /// Finds the size of a given tuple type.
 700   template<typename _Tp>
 701     struct tuple_size;
 702
 703   template<typename _Tp>
 704     struct tuple_size<const _Tp>
 705     : public integral_constant<
 706              typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
 707              tuple_size<_Tp>::value> { };
 708
 709   template<typename _Tp>
 710     struct tuple_size<volatile _Tp>
 711     : public integral_constant<
 712              typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
 713              tuple_size<_Tp>::value> { };
 714
 715   template<typename _Tp>
 716     struct tuple_size<const volatile _Tp>
 717     : public integral_constant<
 718              typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
 719              tuple_size<_Tp>::value> { };
 720
 721   /// class tuple_size
 722   template<typename... _Elements>
 723     struct tuple_size<tuple<_Elements...>>
 724     : public integral_constant<std::size_t, sizeof...(_Elements)> { };
 725
 726   template<std::size_t __i, typename _Head, typename... _Tail>
 727     constexpr typename __add_ref<_Head>::type
 728     __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 729     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
 730
 731   template<std::size_t __i, typename _Head, typename... _Tail>
 732     constexpr typename __add_c_ref<_Head>::type
 733     __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 734     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
 735
 736   // Return a reference (const reference, rvalue reference) to the ith element
 737   // of a tuple.  Any const or non-const ref elements are returned with their
 738   // original type.
 739   template<std::size_t __i, typename... _Elements>
 740     constexpr typename __add_ref<
 741                       typename tuple_element<__i, tuple<_Elements...>>::type
 742                     >::type
 743     get(tuple<_Elements...>& __t) noexcept
 744     { return __get_helper<__i>(__t); }
 745
 746   template<std::size_t __i, typename... _Elements>
 747     constexpr typename __add_c_ref<
 748                       typename tuple_element<__i, tuple<_Elements...>>::type
 749                     >::type
 750     get(const tuple<_Elements...>& __t) noexcept
 751     { return __get_helper<__i>(__t); }
 752
 753   template<std::size_t __i, typename... _Elements>
 754     constexpr typename __add_r_ref<
 755                       typename tuple_element<__i, tuple<_Elements...>>::type
 756                     >::type
 757     get(tuple<_Elements...>&& __t) noexcept
 758     { return std::forward<typename tuple_element<__i,
 759         tuple<_Elements...>>::type&&>(get<__i>(__t)); }
 760
 761   // This class helps construct the various comparison operations on tuples
 762   template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j,
 763            typename _Tp, typename _Up>
 764     struct __tuple_compare;
 765
 766   template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up>
 767     struct __tuple_compare<0, __i, __j, _Tp, _Up>
 768     {
 769       static bool
 770       __eq(const _Tp& __t, const _Up& __u)
 771       {
 772         return (get<__i>(__t) == get<__i>(__u) &&
 773                 __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u));
 774       }
 775
 776       static bool
 777       __less(const _Tp& __t, const _Up& __u)
 778       {
 779         return ((get<__i>(__t) < get<__i>(__u))
 780                 || !(get<__i>(__u) < get<__i>(__t)) &&
 781                 __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u));
 782       }
 783     };
 784
 785   template<std::size_t __i, typename _Tp, typename _Up>
 786     struct __tuple_compare<0, __i, __i, _Tp, _Up>
 787     {
 788       static bool
 789       __eq(const _Tp&, const _Up&) { return true; }
 790
 791       static bool
 792       __less(const _Tp&, const _Up&) { return false; }
 793     };
 794
 795   template<typename... _TElements, typename... _UElements>
 796     bool
 797     operator==(const tuple<_TElements...>& __t,
 798                const tuple<_UElements...>& __u)
 799     {
 800       typedef tuple<_TElements...> _Tp;
 801       typedef tuple<_UElements...> _Up;
 802       return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
 803               0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
 804     }
 805
 806   template<typename... _TElements, typename... _UElements>
 807     bool
 808     operator<(const tuple<_TElements...>& __t,
 809               const tuple<_UElements...>& __u)
 810     {
 811       typedef tuple<_TElements...> _Tp;
 812       typedef tuple<_UElements...> _Up;
 813       return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
 814               0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
 815     }
 816
 817   template<typename... _TElements, typename... _UElements>
 818     inline bool
 819     operator!=(const tuple<_TElements...>& __t,
 820                const tuple<_UElements...>& __u)
 821     { return !(__t == __u); }
 822
 823   template<typename... _TElements, typename... _UElements>
 824     inline bool
 825     operator>(const tuple<_TElements...>& __t,
 826               const tuple<_UElements...>& __u)
 827     { return __u < __t; }
 828
 829   template<typename... _TElements, typename... _UElements>
 830     inline bool
 831     operator<=(const tuple<_TElements...>& __t,
 832                const tuple<_UElements...>& __u)
 833     { return !(__u < __t); }
 834
 835   template<typename... _TElements, typename... _UElements>
 836     inline bool
 837     operator>=(const tuple<_TElements...>& __t,
 838                const tuple<_UElements...>& __u)
 839     { return !(__t < __u); }
 840
 841   // NB: DR 705.
 842   template<typename... _Elements>
 843     constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
 844     make_tuple(_Elements&&... __args)
 845     {
 846       typedef tuple<typename __decay_and_strip<_Elements>::__type...>
 847         __result_type;
 848       return __result_type(std::forward<_Elements>(__args)...);
 849     }
 850
 851   template<typename... _Elements>
 852     constexpr tuple<_Elements&&...>
 853     forward_as_tuple(_Elements&&... __args) noexcept
 854     { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
 855
 856
 857   template<typename, std::size_t> struct array;
 858
 859   template<std::size_t _Int, typename _Tp, std::size_t _Nm>
 860     constexpr _Tp& get(array<_Tp, _Nm>&) noexcept;
 861
 862   template<std::size_t _Int, typename _Tp, std::size_t _Nm>
 863     constexpr _Tp&& get(array<_Tp, _Nm>&&) noexcept;
 864
 865   template<std::size_t _Int, typename _Tp, std::size_t _Nm>
 866     constexpr const _Tp& get(const array<_Tp, _Nm>&) noexcept;
 867
 868   template<typename>
 869     struct __is_tuple_like_impl : false_type
 870     { };
 871
 872   template<typename... _Tps>
 873     struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
 874     { };
 875
 876   template<typename _T1, typename _T2>
 877     struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
 878     { };
 879
 880   template<typename _Tp, std::size_t _Nm>
 881     struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
 882     { };
 883
 884   // Internal type trait that allows us to sfinae-protect tuple_cat.
 885   template<typename _Tp>
 886     struct __is_tuple_like
 887     : public __is_tuple_like_impl<typename std::remove_cv
 888             <typename std::remove_reference<_Tp>::type>::type>::type
 889     { };
 890
 891   // Stores a tuple of indices.  Also used by bind() to extract the elements
 892   // in a tuple.
 893   template<std::size_t... _Indexes>
 894     struct _Index_tuple
 895     {
 896       typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
 897     };
 898
 899   // Builds an _Index_tuple<0, 1, 2, ..., _Num-1>.
 900   template<std::size_t _Num>
 901     struct _Build_index_tuple
 902     {
 903       typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
 904     };
 905
 906   template<>
 907     struct _Build_index_tuple<0>
 908     {
 909       typedef _Index_tuple<> __type;
 910     };
 911
 912   template<std::size_t, typename, typename, std::size_t>
 913     struct __make_tuple_impl;
 914
 915   template<std::size_t _Idx, typename _Tuple, typename... _Tp,
 916            std::size_t _Nm>
 917     struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
 918     {
 919       typedef typename __make_tuple_impl<_Idx + 1, tuple<_Tp...,
 920         typename std::tuple_element<_Idx, _Tuple>::type>, _Tuple, _Nm>::__type
 921       __type;
 922     };
 923
 924   template<std::size_t _Nm, typename _Tuple, typename... _Tp>
 925     struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
 926     {
 927       typedef tuple<_Tp...> __type;
 928     };
 929
 930   template<typename _Tuple>
 931     struct __do_make_tuple
 932     : public __make_tuple_impl<0, tuple<>, _Tuple,
 933                                std::tuple_size<_Tuple>::value>
 934     { };
 935
 936   // Returns the std::tuple equivalent of a tuple-like type.
 937   template<typename _Tuple>
 938     struct __make_tuple
 939     : public __do_make_tuple<typename std::remove_cv
 940             <typename std::remove_reference<_Tuple>::type>::type>
 941     { };
 942
 943   // Combines several std::tuple's into a single one.
 944   template<typename...>
 945     struct __combine_tuples;
 946
 947   template<>
 948     struct __combine_tuples<>
 949     {
 950       typedef tuple<> __type;
 951     };
 952
 953   template<typename... _Ts>
 954     struct __combine_tuples<tuple<_Ts...>>
 955     {
 956       typedef tuple<_Ts...> __type;
 957     };
 958
 959   template<typename... _T1s, typename... _T2s, typename... _Rem>
 960     struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
 961     {
 962       typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
 963                                         _Rem...>::__type __type;
 964     };
 965
 966   // Computes the result type of tuple_cat given a set of tuple-like types.
 967   template<typename... _Tpls>
 968     struct __tuple_cat_result
 969     {
 970       typedef typename __combine_tuples
 971         <typename __make_tuple<_Tpls>::__type...>::__type __type;
 972     };
 973
 974   // Helper to determine the index set for the first tuple-like
 975   // type of a given set.
 976   template<typename...>
 977     struct __make_1st_indices;
 978
 979   template<>
 980     struct __make_1st_indices<>
 981     {
 982       typedef std::_Index_tuple<> __type;
 983     };
 984
 985   template<typename _Tp, typename... _Tpls>
 986     struct __make_1st_indices<_Tp, _Tpls...>
 987     {
 988       typedef typename std::_Build_index_tuple<std::tuple_size<
 989         typename std::remove_reference<_Tp>::type>::value>::__type __type;
 990     };
 991
 992   // Performs the actual concatenation by step-wise expanding tuple-like
 993   // objects into the elements,  which are finally forwarded into the
 994   // result tuple.
 995   template<typename _Ret, typename _Indices, typename... _Tpls>
 996     struct __tuple_concater;
 997
 998   template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
 999     struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
1000     {
1001       template<typename... _Us>
1002         static constexpr _Ret
1003         _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
1004         {
1005           typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1006           typedef __tuple_concater<_Ret, __idx, _Tpls...>      __next;
1007           return __next::_S_do(std::forward<_Tpls>(__tps)...,
1008                                std::forward<_Us>(__us)...,
1009                                std::get<_Is>(std::forward<_Tp>(__tp))...);
1010         }
1011     };
1012
1013   template<typename _Ret>
1014     struct __tuple_concater<_Ret, std::_Index_tuple<>>
1015     {
1016       template<typename... _Us>
1017         static constexpr _Ret
1018         _S_do(_Us&&... __us)
1019         {
1020           return _Ret(std::forward<_Us>(__us)...);
1021         }
1022     };
1023
1024   template<typename... _Tpls, typename = typename
1025            enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
1026     constexpr auto
1027     tuple_cat(_Tpls&&... __tpls)
1028     -> typename __tuple_cat_result<_Tpls...>::__type
1029     {
1030       typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
1031       typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1032       typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
1033       return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
1034     }
1035
1036   template<typename... _Elements>
1037     inline tuple<_Elements&...>
1038     tie(_Elements&... __args) noexcept
1039     { return tuple<_Elements&...>(__args...); }
1040
1041   template<typename... _Elements>
1042     inline void
1043     swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
1044     noexcept(noexcept(__x.swap(__y)))
1045     { __x.swap(__y); }
1046
1047   // A class (and instance) which can be used in 'tie' when an element
1048   // of a tuple is not required
1049   struct _Swallow_assign
1050   {
1051     template<class _Tp>
1052       const _Swallow_assign&
1053       operator=(const _Tp&) const
1054       { return *this; }
1055   };
1056
1057   const _Swallow_assign ignore{};
1058
1059   /// Partial specialization for tuples
1060   template<typename... _Types, typename _Alloc>
1061     struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
1062
1063   // See stl_pair.h...
1064   template<class _T1, class _T2>
1065     template<typename... _Args1, typename... _Args2>
1066       inline
1067       pair<_T1, _T2>::
1068       pair(piecewise_construct_t,
1069            tuple<_Args1...> __first, tuple<_Args2...> __second)
1070       : pair(__first, __second,
1071              typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
1072              typename _Build_index_tuple<sizeof...(_Args2)>::__type())
1073       { }
1074
1075   template<class _T1, class _T2>
1076     template<typename... _Args1, std::size_t... _Indexes1,
1077              typename... _Args2, std::size_t... _Indexes2>
1078       inline
1079       pair<_T1, _T2>::
1080       pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
1081            _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
1082       : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
1083         second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
1084       { }
1085
1086 _GLIBCXX_END_NAMESPACE_VERSION
1087 } // namespace
1088
1089 #endif // __GXX_EXPERIMENTAL_CXX0X__
1090
1091 #endif // _GLIBCXX_TUPLE