libstdc++-v3/include/std/tuple

   1 // <tuple> -*- C++ -*-
   2
   3 // Copyright (C) 2007-2016 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 #if __cplusplus < 201103L
  35 # include <bits/c++0x_warning.h>
  36 #else
  37
  38 #include <utility>
  39 #include <array>
  40 #include <bits/uses_allocator.h>
  41
  42 namespace std _GLIBCXX_VISIBILITY(default)
  43 {
  44 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  45
  46   /**
  47    *  @addtogroup utilities
  48    *  @{
  49    */
  50
  51   template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
  52     struct _Head_base;
  53
  54   template<std::size_t _Idx, typename _Head>
  55     struct _Head_base<_Idx, _Head, true>
  56     : public _Head
  57     {
  58       constexpr _Head_base()
  59       : _Head() { }
  60
  61       constexpr _Head_base(const _Head& __h)
  62       : _Head(__h) { }
  63
  64       constexpr _Head_base(const _Head_base&) = default;
  65       constexpr _Head_base(_Head_base&&) = default;
  66
  67       template<typename _UHead>
  68         constexpr _Head_base(_UHead&& __h)
  69         : _Head(std::forward<_UHead>(__h)) { }
  70
  71       _Head_base(allocator_arg_t, __uses_alloc0)
  72       : _Head() { }
  73
  74       template<typename _Alloc>
  75         _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
  76         : _Head(allocator_arg, *__a._M_a) { }
  77
  78       template<typename _Alloc>
  79         _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
  80         : _Head(*__a._M_a) { }
  81
  82       template<typename _UHead>
  83         _Head_base(__uses_alloc0, _UHead&& __uhead)
  84         : _Head(std::forward<_UHead>(__uhead)) { }
  85
  86       template<typename _Alloc, typename _UHead>
  87         _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
  88         : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
  89
  90       template<typename _Alloc, typename _UHead>
  91         _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
  92         : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
  93
  94       static constexpr _Head&
  95       _M_head(_Head_base& __b) noexcept { return __b; }
  96
  97       static constexpr const _Head&
  98       _M_head(const _Head_base& __b) noexcept { return __b; }
  99     };
 100
 101   template<std::size_t _Idx, typename _Head>
 102     struct _Head_base<_Idx, _Head, false>
 103     {
 104       constexpr _Head_base()
 105       : _M_head_impl() { }
 106
 107       constexpr _Head_base(const _Head& __h)
 108       : _M_head_impl(__h) { }
 109
 110       constexpr _Head_base(const _Head_base&) = default;
 111       constexpr _Head_base(_Head_base&&) = default;
 112
 113       template<typename _UHead>
 114         constexpr _Head_base(_UHead&& __h)
 115         : _M_head_impl(std::forward<_UHead>(__h)) { }
 116
 117       _Head_base(allocator_arg_t, __uses_alloc0)
 118       : _M_head_impl() { }
 119
 120       template<typename _Alloc>
 121         _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 122         : _M_head_impl(allocator_arg, *__a._M_a) { }
 123
 124       template<typename _Alloc>
 125         _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 126         : _M_head_impl(*__a._M_a) { }
 127
 128       template<typename _UHead>
 129         _Head_base(__uses_alloc0, _UHead&& __uhead)
 130         : _M_head_impl(std::forward<_UHead>(__uhead)) { }
 131
 132       template<typename _Alloc, typename _UHead>
 133         _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 134         : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 135         { }
 136
 137       template<typename _Alloc, typename _UHead>
 138         _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 139         : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
 140
 141       static constexpr _Head&
 142       _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
 143
 144       static constexpr const _Head&
 145       _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
 146
 147       _Head _M_head_impl;
 148     };
 149
 150   /**
 151    * Contains the actual implementation of the @c tuple template, stored
 152    * as a recursive inheritance hierarchy from the first element (most
 153    * derived class) to the last (least derived class). The @c Idx
 154    * parameter gives the 0-based index of the element stored at this
 155    * point in the hierarchy; we use it to implement a constant-time
 156    * get() operation.
 157    */
 158   template<std::size_t _Idx, typename... _Elements>
 159     struct _Tuple_impl;
 160
 161   template<typename _Tp>
 162     struct __is_empty_non_tuple : is_empty<_Tp> { };
 163
 164   // Using EBO for elements that are tuples causes ambiguous base errors.
 165   template<typename _El0, typename... _El>
 166     struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
 167
 168   // Use the Empty Base-class Optimization for empty, non-final types.
 169   template<typename _Tp>
 170     using __empty_not_final
 171     = typename conditional<__is_final(_Tp), false_type,
 172                            __is_empty_non_tuple<_Tp>>::type;
 173
 174   /**
 175    * Recursive tuple implementation. Here we store the @c Head element
 176    * and derive from a @c Tuple_impl containing the remaining elements
 177    * (which contains the @c Tail).
 178    */
 179   template<std::size_t _Idx, typename _Head, typename... _Tail>
 180     struct _Tuple_impl<_Idx, _Head, _Tail...>
 181     : public _Tuple_impl<_Idx + 1, _Tail...>,
 182       private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
 183     {
 184       template<std::size_t, typename...> friend class _Tuple_impl;
 185
 186       typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
 187       typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
 188
 189       static constexpr _Head&
 190       _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 191
 192       static constexpr const _Head&
 193       _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 194
 195       static constexpr _Inherited&
 196       _M_tail(_Tuple_impl& __t) noexcept { return __t; }
 197
 198       static constexpr const _Inherited&
 199       _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
 200
 201       constexpr _Tuple_impl()
 202       : _Inherited(), _Base() { }
 203
 204       explicit
 205       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
 206       : _Inherited(__tail...), _Base(__head) { }
 207
 208       template<typename _UHead, typename... _UTail, typename = typename
 209                enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
 210         explicit
 211         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
 212         : _Inherited(std::forward<_UTail>(__tail)...),
 213           _Base(std::forward<_UHead>(__head)) { }
 214
 215       constexpr _Tuple_impl(const _Tuple_impl&) = default;
 216
 217       constexpr
 218       _Tuple_impl(_Tuple_impl&& __in)
 219       noexcept(__and_<is_nothrow_move_constructible<_Head>,
 220                       is_nothrow_move_constructible<_Inherited>>::value)
 221       : _Inherited(std::move(_M_tail(__in))),
 222         _Base(std::forward<_Head>(_M_head(__in))) { }
 223
 224       template<typename... _UElements>
 225         constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
 226         : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
 227           _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
 228
 229       template<typename _UHead, typename... _UTails>
 230         constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 231         : _Inherited(std::move
 232                      (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
 233           _Base(std::forward<_UHead>
 234                 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
 235
 236       template<typename _Alloc>
 237         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 238         : _Inherited(__tag, __a),
 239           _Base(__tag, __use_alloc<_Head>(__a)) { }
 240
 241       template<typename _Alloc>
 242         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 243                     const _Head& __head, const _Tail&... __tail)
 244         : _Inherited(__tag, __a, __tail...),
 245           _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
 246
 247       template<typename _Alloc, typename _UHead, typename... _UTail,
 248                typename = typename enable_if<sizeof...(_Tail)
 249                                              == sizeof...(_UTail)>::type>
 250         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 251                     _UHead&& __head, _UTail&&... __tail)
 252         : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
 253           _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 254                 std::forward<_UHead>(__head)) { }
 255
 256       template<typename _Alloc>
 257         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 258                     const _Tuple_impl& __in)
 259         : _Inherited(__tag, __a, _M_tail(__in)),
 260           _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
 261
 262       template<typename _Alloc>
 263         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 264                     _Tuple_impl&& __in)
 265         : _Inherited(__tag, __a, std::move(_M_tail(__in))),
 266           _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
 267                 std::forward<_Head>(_M_head(__in))) { }
 268
 269       template<typename _Alloc, typename... _UElements>
 270         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 271                     const _Tuple_impl<_Idx, _UElements...>& __in)
 272         : _Inherited(__tag, __a,
 273                      _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
 274           _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
 275                 _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
 276
 277       template<typename _Alloc, typename _UHead, typename... _UTails>
 278         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 279                     _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 280         : _Inherited(__tag, __a, std::move
 281                      (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
 282           _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 283                 std::forward<_UHead>
 284                 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
 285
 286       _Tuple_impl&
 287       operator=(const _Tuple_impl& __in)
 288       {
 289         _M_head(*this) = _M_head(__in);
 290         _M_tail(*this) = _M_tail(__in);
 291         return *this;
 292       }
 293
 294       _Tuple_impl&
 295       operator=(_Tuple_impl&& __in)
 296       noexcept(__and_<is_nothrow_move_assignable<_Head>,
 297                       is_nothrow_move_assignable<_Inherited>>::value)
 298       {
 299         _M_head(*this) = std::forward<_Head>(_M_head(__in));
 300         _M_tail(*this) = std::move(_M_tail(__in));
 301         return *this;
 302       }
 303
 304       template<typename... _UElements>
 305         _Tuple_impl&
 306         operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
 307         {
 308           _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
 309           _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
 310           return *this;
 311         }
 312
 313       template<typename _UHead, typename... _UTails>
 314         _Tuple_impl&
 315         operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 316         {
 317           _M_head(*this) = std::forward<_UHead>
 318             (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
 319           _M_tail(*this) = std::move
 320             (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
 321           return *this;
 322         }
 323
 324     protected:
 325       void
 326       _M_swap(_Tuple_impl& __in)
 327       noexcept(__is_nothrow_swappable<_Head>::value
 328                && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
 329       {
 330         using std::swap;
 331         swap(_M_head(*this), _M_head(__in));
 332         _Inherited::_M_swap(_M_tail(__in));
 333       }
 334     };
 335
 336   // Basis case of inheritance recursion.
 337   template<std::size_t _Idx, typename _Head>
 338     struct _Tuple_impl<_Idx, _Head>
 339     : private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
 340     {
 341       template<std::size_t, typename...> friend class _Tuple_impl;
 342
 343       typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
 344
 345       static constexpr _Head&
 346       _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 347
 348       static constexpr const _Head&
 349       _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 350
 351       constexpr _Tuple_impl()
 352       : _Base() { }
 353
 354       explicit
 355       constexpr _Tuple_impl(const _Head& __head)
 356       : _Base(__head) { }
 357
 358       template<typename _UHead>
 359         explicit
 360         constexpr _Tuple_impl(_UHead&& __head)
 361         : _Base(std::forward<_UHead>(__head)) { }
 362
 363       constexpr _Tuple_impl(const _Tuple_impl&) = default;
 364
 365       constexpr
 366       _Tuple_impl(_Tuple_impl&& __in)
 367       noexcept(is_nothrow_move_constructible<_Head>::value)
 368       : _Base(std::forward<_Head>(_M_head(__in))) { }
 369
 370       template<typename _UHead>
 371         constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
 372         : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
 373
 374       template<typename _UHead>
 375         constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
 376         : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 377         { }
 378
 379       template<typename _Alloc>
 380         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 381         : _Base(__tag, __use_alloc<_Head>(__a)) { }
 382
 383       template<typename _Alloc>
 384         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 385                     const _Head& __head)
 386         : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
 387
 388       template<typename _Alloc, typename _UHead>
 389         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 390                     _UHead&& __head)
 391         : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 392                 std::forward<_UHead>(__head)) { }
 393
 394       template<typename _Alloc>
 395         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 396                     const _Tuple_impl& __in)
 397         : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
 398
 399       template<typename _Alloc>
 400         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 401                     _Tuple_impl&& __in)
 402         : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
 403                 std::forward<_Head>(_M_head(__in))) { }
 404
 405       template<typename _Alloc, typename _UHead>
 406         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 407                     const _Tuple_impl<_Idx, _UHead>& __in)
 408         : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
 409                 _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
 410
 411       template<typename _Alloc, typename _UHead>
 412         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 413                     _Tuple_impl<_Idx, _UHead>&& __in)
 414         : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 415                 std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 416         { }
 417
 418       _Tuple_impl&
 419       operator=(const _Tuple_impl& __in)
 420       {
 421         _M_head(*this) = _M_head(__in);
 422         return *this;
 423       }
 424
 425       _Tuple_impl&
 426       operator=(_Tuple_impl&& __in)
 427       noexcept(is_nothrow_move_assignable<_Head>::value)
 428       {
 429         _M_head(*this) = std::forward<_Head>(_M_head(__in));
 430         return *this;
 431       }
 432
 433       template<typename _UHead>
 434         _Tuple_impl&
 435         operator=(const _Tuple_impl<_Idx, _UHead>& __in)
 436         {
 437           _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
 438           return *this;
 439         }
 440
 441       template<typename _UHead>
 442         _Tuple_impl&
 443         operator=(_Tuple_impl<_Idx, _UHead>&& __in)
 444         {
 445           _M_head(*this)
 446             = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
 447           return *this;
 448         }
 449
 450     protected:
 451       void
 452       _M_swap(_Tuple_impl& __in)
 453       noexcept(__is_nothrow_swappable<_Head>::value)
 454       {
 455         using std::swap;
 456         swap(_M_head(*this), _M_head(__in));
 457       }
 458     };
 459
 460   template<typename... _Elements>
 461     class tuple;
 462
 463   // Concept utility functions, reused in conditionally-explicit
 464   // constructors.
 465   template<bool, typename... _Elements>
 466   struct _TC
 467   {
 468     template<typename... _UElements>
 469     static constexpr bool _ConstructibleTuple()
 470     {
 471       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
 472     }
 473
 474     template<typename... _UElements>
 475     static constexpr bool _ImplicitlyConvertibleTuple()
 476     {
 477       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
 478     }
 479
 480     template<typename... _UElements>
 481     static constexpr bool _MoveConstructibleTuple()
 482     {
 483       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
 484     }
 485
 486     template<typename... _UElements>
 487     static constexpr bool _ImplicitlyMoveConvertibleTuple()
 488     {
 489       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
 490     }
 491
 492     template<typename _SrcTuple>
 493     static constexpr bool _NonNestedTuple()
 494     {
 495       return  __and_<__not_<is_same<tuple<_Elements...>,
 496                                    typename remove_cv<
 497                                      typename remove_reference<_SrcTuple>::type
 498                                    >::type>>,
 499                      __not_<is_convertible<_SrcTuple, _Elements...>>,
 500                      __not_<is_constructible<_Elements..., _SrcTuple>>
 501               >::value;
 502     }
 503     template<typename... _UElements>
 504     static constexpr bool _NotSameTuple()
 505     {
 506       return  __not_<is_same<tuple<_Elements...>,
 507                              typename remove_const<
 508                                typename remove_reference<_UElements...>::type
 509                                >::type>>::value;
 510     }
 511   };
 512
 513   template<typename... _Elements>
 514   struct _TC<false, _Elements...>
 515   {
 516     template<typename... _UElements>
 517     static constexpr bool _ConstructibleTuple()
 518     {
 519       return false;
 520     }
 521
 522     template<typename... _UElements>
 523     static constexpr bool _ImplicitlyConvertibleTuple()
 524     {
 525       return false;
 526     }
 527
 528     template<typename... _UElements>
 529     static constexpr bool _MoveConstructibleTuple()
 530     {
 531       return false;
 532     }
 533
 534     template<typename... _UElements>
 535     static constexpr bool _ImplicitlyMoveConvertibleTuple()
 536     {
 537       return false;
 538     }
 539
 540     template<typename... _UElements>
 541     static constexpr bool _NonNestedTuple()
 542     {
 543       return true;
 544     }
 545     template<typename... _UElements>
 546     static constexpr bool _NotSameTuple()
 547     {
 548       return  true;
 549     }
 550   };
 551
 552   /// Primary class template, tuple
 553   template<typename... _Elements>
 554     class tuple : public _Tuple_impl<0, _Elements...>
 555     {
 556       typedef _Tuple_impl<0, _Elements...> _Inherited;
 557
 558       // Used for constraining the default constructor so
 559       // that it becomes dependent on the constraints.
 560       template<typename _Dummy>
 561       struct _TC2
 562       {
 563         static constexpr bool _DefaultConstructibleTuple()
 564         {
 565           return __and_<is_default_constructible<_Elements>...>::value;
 566         }
 567         static constexpr bool _ImplicitlyDefaultConstructibleTuple()
 568         {
 569           return __and_<__is_implicitly_default_constructible<_Elements>...>
 570             ::value;
 571         }
 572       };
 573
 574     public:
 575       template<typename _Dummy = void,
 576                typename enable_if<_TC2<_Dummy>::
 577                                     _ImplicitlyDefaultConstructibleTuple(),
 578                                   bool>::type = true>
 579       constexpr tuple()
 580       : _Inherited() { }
 581
 582       template<typename _Dummy = void,
 583                typename enable_if<_TC2<_Dummy>::
 584                                     _DefaultConstructibleTuple()
 585                                   &&
 586                                   !_TC2<_Dummy>::
 587                                     _ImplicitlyDefaultConstructibleTuple(),
 588                                   bool>::type = false>
 589       explicit constexpr tuple()
 590       : _Inherited() { }
 591
 592       // Shortcut for the cases where constructors taking _Elements...
 593       // need to be constrained.
 594       template<typename _Dummy> using _TCC =
 595         _TC<is_same<_Dummy, void>::value,
 596             _Elements...>;
 597
 598       template<typename _Dummy = void,
 599                typename enable_if<
 600                  _TCC<_Dummy>::template
 601                    _ConstructibleTuple<_Elements...>()
 602                  && _TCC<_Dummy>::template
 603                    _ImplicitlyConvertibleTuple<_Elements...>()
 604                  && (sizeof...(_Elements) >= 1),
 605                bool>::type=true>
 606         constexpr tuple(const _Elements&... __elements)
 607       : _Inherited(__elements...) { }
 608
 609       template<typename _Dummy = void,
 610                typename enable_if<
 611                  _TCC<_Dummy>::template
 612                    _ConstructibleTuple<_Elements...>()
 613                  && !_TCC<_Dummy>::template
 614                    _ImplicitlyConvertibleTuple<_Elements...>()
 615                  && (sizeof...(_Elements) >= 1),
 616                bool>::type=false>
 617       explicit constexpr tuple(const _Elements&... __elements)
 618       : _Inherited(__elements...) { }
 619
 620       // Shortcut for the cases where constructors taking _UElements...
 621       // need to be constrained.
 622       template<typename... _UElements> using _TMC =
 623                   _TC<(sizeof...(_Elements) == sizeof...(_UElements)),
 624                       _Elements...>;
 625
 626       template<typename... _UElements, typename
 627                enable_if<
 628                   _TC<sizeof...(_UElements) == 1, _Elements...>::template
 629                     _NotSameTuple<_UElements...>()
 630                   && _TMC<_UElements...>::template
 631                     _MoveConstructibleTuple<_UElements...>()
 632                   && _TMC<_UElements...>::template
 633                     _ImplicitlyMoveConvertibleTuple<_UElements...>()
 634                   && (sizeof...(_Elements) >= 1),
 635         bool>::type=true>
 636         constexpr tuple(_UElements&&... __elements)
 637         : _Inherited(std::forward<_UElements>(__elements)...) { }
 638
 639       template<typename... _UElements, typename
 640         enable_if<
 641                   _TC<sizeof...(_UElements) == 1, _Elements...>::template
 642                     _NotSameTuple<_UElements...>()
 643                   && _TMC<_UElements...>::template
 644                     _MoveConstructibleTuple<_UElements...>()
 645                   && !_TMC<_UElements...>::template
 646                     _ImplicitlyMoveConvertibleTuple<_UElements...>()
 647                   && (sizeof...(_Elements) >= 1),
 648         bool>::type=false>
 649         explicit constexpr tuple(_UElements&&... __elements)
 650         : _Inherited(std::forward<_UElements>(__elements)...) { }
 651
 652       constexpr tuple(const tuple&) = default;
 653
 654       constexpr tuple(tuple&&) = default;
 655
 656       // Shortcut for the cases where constructors taking tuples
 657       // must avoid creating temporaries.
 658       template<typename _Dummy> using _TNTC =
 659         _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
 660             _Elements...>;
 661
 662       template<typename... _UElements, typename _Dummy = void, typename
 663         enable_if<_TMC<_UElements...>::template
 664                     _ConstructibleTuple<_UElements...>()
 665                   && _TMC<_UElements...>::template
 666                     _ImplicitlyConvertibleTuple<_UElements...>()
 667                   && _TNTC<_Dummy>::template
 668                     _NonNestedTuple<const tuple<_UElements...>&>(),
 669         bool>::type=true>
 670         constexpr tuple(const tuple<_UElements...>& __in)
 671         : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 672         { }
 673
 674       template<typename... _UElements, typename _Dummy = void, typename
 675         enable_if<_TMC<_UElements...>::template
 676                     _ConstructibleTuple<_UElements...>()
 677                   && !_TMC<_UElements...>::template
 678                     _ImplicitlyConvertibleTuple<_UElements...>()
 679                   && _TNTC<_Dummy>::template
 680                     _NonNestedTuple<const tuple<_UElements...>&>(),
 681         bool>::type=false>
 682         explicit constexpr tuple(const tuple<_UElements...>& __in)
 683         : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 684         { }
 685
 686       template<typename... _UElements, typename _Dummy = void, typename
 687         enable_if<_TMC<_UElements...>::template
 688                     _MoveConstructibleTuple<_UElements...>()
 689                   && _TMC<_UElements...>::template
 690                     _ImplicitlyMoveConvertibleTuple<_UElements...>()
 691                   && _TNTC<_Dummy>::template
 692                     _NonNestedTuple<tuple<_UElements...>&&>(),
 693         bool>::type=true>
 694         constexpr tuple(tuple<_UElements...>&& __in)
 695         : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
 696
 697       template<typename... _UElements, typename _Dummy = void, typename
 698         enable_if<_TMC<_UElements...>::template
 699                     _MoveConstructibleTuple<_UElements...>()
 700                   && !_TMC<_UElements...>::template
 701                     _ImplicitlyMoveConvertibleTuple<_UElements...>()
 702                   && _TNTC<_Dummy>::template
 703                     _NonNestedTuple<tuple<_UElements...>&&>(),
 704         bool>::type=false>
 705         explicit constexpr tuple(tuple<_UElements...>&& __in)
 706         : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
 707
 708       // Allocator-extended constructors.
 709
 710       template<typename _Alloc>
 711         tuple(allocator_arg_t __tag, const _Alloc& __a)
 712         : _Inherited(__tag, __a) { }
 713
 714       template<typename _Alloc, typename _Dummy = void,
 715                typename enable_if<
 716                  _TCC<_Dummy>::template
 717                    _ConstructibleTuple<_Elements...>()
 718                  && _TCC<_Dummy>::template
 719                    _ImplicitlyConvertibleTuple<_Elements...>(),
 720                bool>::type=true>
 721         tuple(allocator_arg_t __tag, const _Alloc& __a,
 722               const _Elements&... __elements)
 723         : _Inherited(__tag, __a, __elements...) { }
 724
 725       template<typename _Alloc, typename _Dummy = void,
 726                typename enable_if<
 727                  _TCC<_Dummy>::template
 728                    _ConstructibleTuple<_Elements...>()
 729                  && !_TCC<_Dummy>::template
 730                    _ImplicitlyConvertibleTuple<_Elements...>(),
 731                bool>::type=false>
 732         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
 733                        const _Elements&... __elements)
 734         : _Inherited(__tag, __a, __elements...) { }
 735
 736       template<typename _Alloc, typename... _UElements, typename
 737         enable_if<_TMC<_UElements...>::template
 738                     _MoveConstructibleTuple<_UElements...>()
 739                   && _TMC<_UElements...>::template
 740                     _ImplicitlyMoveConvertibleTuple<_UElements...>(),
 741         bool>::type=true>
 742         tuple(allocator_arg_t __tag, const _Alloc& __a,
 743               _UElements&&... __elements)
 744         : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
 745         { }
 746
 747       template<typename _Alloc, typename... _UElements, typename
 748         enable_if<_TMC<_UElements...>::template
 749                     _MoveConstructibleTuple<_UElements...>()
 750                   && !_TMC<_UElements...>::template
 751                     _ImplicitlyMoveConvertibleTuple<_UElements...>(),
 752         bool>::type=false>
 753         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
 754               _UElements&&... __elements)
 755         : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
 756         { }
 757
 758       template<typename _Alloc>
 759         tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
 760         : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
 761
 762       template<typename _Alloc>
 763         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
 764         : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
 765
 766       template<typename _Alloc, typename... _UElements, typename
 767         enable_if<_TMC<_UElements...>::template
 768                     _ConstructibleTuple<_UElements...>()
 769                   && _TMC<_UElements...>::template
 770                     _ImplicitlyConvertibleTuple<_UElements...>(),
 771         bool>::type=true>
 772         tuple(allocator_arg_t __tag, const _Alloc& __a,
 773               const tuple<_UElements...>& __in)
 774         : _Inherited(__tag, __a,
 775                      static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 776         { }
 777
 778       template<typename _Alloc, typename... _UElements, typename
 779         enable_if<_TMC<_UElements...>::template
 780                     _ConstructibleTuple<_UElements...>()
 781                   && !_TMC<_UElements...>::template
 782                     _ImplicitlyConvertibleTuple<_UElements...>(),
 783         bool>::type=false>
 784         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
 785               const tuple<_UElements...>& __in)
 786         : _Inherited(__tag, __a,
 787                      static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 788         { }
 789
 790       template<typename _Alloc, typename... _UElements, typename
 791         enable_if<_TMC<_UElements...>::template
 792                     _MoveConstructibleTuple<_UElements...>()
 793                   && _TMC<_UElements...>::template
 794                     _ImplicitlyMoveConvertibleTuple<_UElements...>(),
 795         bool>::type=true>
 796         tuple(allocator_arg_t __tag, const _Alloc& __a,
 797               tuple<_UElements...>&& __in)
 798         : _Inherited(__tag, __a,
 799                      static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
 800         { }
 801
 802       template<typename _Alloc, typename... _UElements, typename
 803         enable_if<_TMC<_UElements...>::template
 804                     _MoveConstructibleTuple<_UElements...>()
 805                   && !_TMC<_UElements...>::template
 806                     _ImplicitlyMoveConvertibleTuple<_UElements...>(),
 807         bool>::type=false>
 808         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
 809               tuple<_UElements...>&& __in)
 810         : _Inherited(__tag, __a,
 811                      static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
 812         { }
 813
 814       tuple&
 815       operator=(const tuple& __in)
 816       {
 817         static_cast<_Inherited&>(*this) = __in;
 818         return *this;
 819       }
 820
 821       tuple&
 822       operator=(tuple&& __in)
 823       noexcept(is_nothrow_move_assignable<_Inherited>::value)
 824       {
 825         static_cast<_Inherited&>(*this) = std::move(__in);
 826         return *this;
 827       }
 828
 829       template<typename... _UElements, typename = typename
 830                enable_if<sizeof...(_UElements)
 831                          == sizeof...(_Elements)>::type>
 832         tuple&
 833         operator=(const tuple<_UElements...>& __in)
 834         {
 835           static_cast<_Inherited&>(*this) = __in;
 836           return *this;
 837         }
 838
 839       template<typename... _UElements, typename = typename
 840                enable_if<sizeof...(_UElements)
 841                          == sizeof...(_Elements)>::type>
 842         tuple&
 843         operator=(tuple<_UElements...>&& __in)
 844         {
 845           static_cast<_Inherited&>(*this) = std::move(__in);
 846           return *this;
 847         }
 848
 849       void
 850       swap(tuple& __in)
 851       noexcept(noexcept(__in._M_swap(__in)))
 852       { _Inherited::_M_swap(__in); }
 853     };
 854
 855   // Explicit specialization, zero-element tuple.
 856   template<>
 857     class tuple<>
 858     {
 859     public:
 860       void swap(tuple&) noexcept { /* no-op */ }
 861     };
 862
 863   /// Partial specialization, 2-element tuple.
 864   /// Includes construction and assignment from a pair.
 865   template<typename _T1, typename _T2>
 866     class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
 867     {
 868       typedef _Tuple_impl<0, _T1, _T2> _Inherited;
 869
 870     public:
 871       template <typename _U1 = _T1,
 872                 typename _U2 = _T2,
 873                 typename enable_if<__and_<
 874                                      __is_implicitly_default_constructible<_U1>,
 875                                      __is_implicitly_default_constructible<_U2>>
 876                                    ::value, bool>::type = true>
 877
 878       constexpr tuple()
 879       : _Inherited() { }
 880
 881       template <typename _U1 = _T1,
 882                 typename _U2 = _T2,
 883                 typename enable_if<
 884                   __and_<
 885                     is_default_constructible<_U1>,
 886                     is_default_constructible<_U2>,
 887                     __not_<
 888                       __and_<__is_implicitly_default_constructible<_U1>,
 889                              __is_implicitly_default_constructible<_U2>>>>
 890                   ::value, bool>::type = false>
 891
 892       explicit constexpr tuple()
 893       : _Inherited() { }
 894
 895       // Shortcut for the cases where constructors taking _T1, _T2
 896       // need to be constrained.
 897       template<typename _Dummy> using _TCC =
 898         _TC<is_same<_Dummy, void>::value, _T1, _T2>;
 899
 900       template<typename _Dummy = void, typename
 901                enable_if<_TCC<_Dummy>::template
 902                            _ConstructibleTuple<_T1, _T2>()
 903                          && _TCC<_Dummy>::template
 904                            _ImplicitlyConvertibleTuple<_T1, _T2>(),
 905         bool>::type = true>
 906         constexpr tuple(const _T1& __a1, const _T2& __a2)
 907         : _Inherited(__a1, __a2) { }
 908
 909       template<typename _Dummy = void, typename
 910                enable_if<_TCC<_Dummy>::template
 911                            _ConstructibleTuple<_T1, _T2>()
 912                          && !_TCC<_Dummy>::template
 913                            _ImplicitlyConvertibleTuple<_T1, _T2>(),
 914         bool>::type = false>
 915         explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
 916         : _Inherited(__a1, __a2) { }
 917
 918       // Shortcut for the cases where constructors taking _U1, _U2
 919       // need to be constrained.
 920       using _TMC = _TC<true, _T1, _T2>;
 921
 922       template<typename _U1, typename _U2, typename
 923         enable_if<_TMC::template
 924                     _MoveConstructibleTuple<_U1, _U2>()
 925                   && _TMC::template
 926                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
 927         bool>::type = true>
 928         constexpr tuple(_U1&& __a1, _U2&& __a2)
 929         : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
 930
 931       template<typename _U1, typename _U2, typename
 932         enable_if<_TMC::template
 933                     _MoveConstructibleTuple<_U1, _U2>()
 934                   && !_TMC::template
 935                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
 936         bool>::type = false>
 937         explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
 938         : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
 939
 940       constexpr tuple(const tuple&) = default;
 941
 942       constexpr tuple(tuple&&) = default;
 943
 944       template<typename _U1, typename _U2, typename
 945         enable_if<_TMC::template
 946                     _ConstructibleTuple<_U1, _U2>()
 947                   && _TMC::template
 948                     _ImplicitlyConvertibleTuple<_U1, _U2>(),
 949         bool>::type = true>
 950         constexpr tuple(const tuple<_U1, _U2>& __in)
 951         : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
 952
 953       template<typename _U1, typename _U2, typename
 954         enable_if<_TMC::template
 955                     _ConstructibleTuple<_U1, _U2>()
 956                   && !_TMC::template
 957                     _ImplicitlyConvertibleTuple<_U1, _U2>(),
 958         bool>::type = false>
 959         explicit constexpr tuple(const tuple<_U1, _U2>& __in)
 960         : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
 961
 962       template<typename _U1, typename _U2, typename
 963         enable_if<_TMC::template
 964                     _MoveConstructibleTuple<_U1, _U2>()
 965                   && _TMC::template
 966                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
 967         bool>::type = true>
 968         constexpr tuple(tuple<_U1, _U2>&& __in)
 969         : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
 970
 971       template<typename _U1, typename _U2, typename
 972         enable_if<_TMC::template
 973                     _MoveConstructibleTuple<_U1, _U2>()
 974                   && !_TMC::template
 975                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
 976         bool>::type = false>
 977         explicit constexpr tuple(tuple<_U1, _U2>&& __in)
 978         : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
 979
 980       template<typename _U1, typename _U2, typename
 981         enable_if<_TMC::template
 982                     _ConstructibleTuple<_U1, _U2>()
 983                   && _TMC::template
 984                     _ImplicitlyConvertibleTuple<_U1, _U2>(),
 985         bool>::type = true>
 986         constexpr tuple(const pair<_U1, _U2>& __in)
 987         : _Inherited(__in.first, __in.second) { }
 988
 989       template<typename _U1, typename _U2, typename
 990         enable_if<_TMC::template
 991                     _ConstructibleTuple<_U1, _U2>()
 992                   && !_TMC::template
 993                     _ImplicitlyConvertibleTuple<_U1, _U2>(),
 994         bool>::type = false>
 995         explicit constexpr tuple(const pair<_U1, _U2>& __in)
 996         : _Inherited(__in.first, __in.second) { }
 997
 998       template<typename _U1, typename _U2, typename
 999         enable_if<_TMC::template
1000                     _MoveConstructibleTuple<_U1, _U2>()
1001                   && _TMC::template
1002                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1003         bool>::type = true>
1004         constexpr tuple(pair<_U1, _U2>&& __in)
1005         : _Inherited(std::forward<_U1>(__in.first),
1006                      std::forward<_U2>(__in.second)) { }
1007
1008       template<typename _U1, typename _U2, typename
1009         enable_if<_TMC::template
1010                     _MoveConstructibleTuple<_U1, _U2>()
1011                   && !_TMC::template
1012                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1013         bool>::type = false>
1014         explicit constexpr tuple(pair<_U1, _U2>&& __in)
1015         : _Inherited(std::forward<_U1>(__in.first),
1016                      std::forward<_U2>(__in.second)) { }
1017
1018       // Allocator-extended constructors.
1019
1020       template<typename _Alloc>
1021         tuple(allocator_arg_t __tag, const _Alloc& __a)
1022         : _Inherited(__tag, __a) { }
1023
1024       template<typename _Alloc, typename _Dummy = void,
1025                typename enable_if<
1026                  _TCC<_Dummy>::template
1027                    _ConstructibleTuple<_T1, _T2>()
1028                  && _TCC<_Dummy>::template
1029                    _ImplicitlyConvertibleTuple<_T1, _T2>(),
1030                bool>::type=true>
1031
1032         tuple(allocator_arg_t __tag, const _Alloc& __a,
1033               const _T1& __a1, const _T2& __a2)
1034         : _Inherited(__tag, __a, __a1, __a2) { }
1035
1036       template<typename _Alloc, typename _Dummy = void,
1037                typename enable_if<
1038                  _TCC<_Dummy>::template
1039                    _ConstructibleTuple<_T1, _T2>()
1040                  && !_TCC<_Dummy>::template
1041                    _ImplicitlyConvertibleTuple<_T1, _T2>(),
1042                bool>::type=false>
1043
1044         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1045               const _T1& __a1, const _T2& __a2)
1046         : _Inherited(__tag, __a, __a1, __a2) { }
1047
1048       template<typename _Alloc, typename _U1, typename _U2, typename
1049         enable_if<_TMC::template
1050                     _MoveConstructibleTuple<_U1, _U2>()
1051                   && _TMC::template
1052                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1053         bool>::type = true>
1054         tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
1055         : _Inherited(__tag, __a, std::forward<_U1>(__a1),
1056                      std::forward<_U2>(__a2)) { }
1057
1058       template<typename _Alloc, typename _U1, typename _U2, typename
1059         enable_if<_TMC::template
1060                     _MoveConstructibleTuple<_U1, _U2>()
1061                   && !_TMC::template
1062                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1063         bool>::type = false>
1064         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1065                        _U1&& __a1, _U2&& __a2)
1066         : _Inherited(__tag, __a, std::forward<_U1>(__a1),
1067                      std::forward<_U2>(__a2)) { }
1068
1069       template<typename _Alloc>
1070         tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
1071         : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
1072
1073       template<typename _Alloc>
1074         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
1075         : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
1076
1077       template<typename _Alloc, typename _U1, typename _U2, typename
1078         enable_if<_TMC::template
1079                     _ConstructibleTuple<_U1, _U2>()
1080                   && _TMC::template
1081                     _ImplicitlyConvertibleTuple<_U1, _U2>(),
1082         bool>::type = true>
1083         tuple(allocator_arg_t __tag, const _Alloc& __a,
1084               const tuple<_U1, _U2>& __in)
1085         : _Inherited(__tag, __a,
1086                      static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1087         { }
1088
1089       template<typename _Alloc, typename _U1, typename _U2, typename
1090         enable_if<_TMC::template
1091                     _ConstructibleTuple<_U1, _U2>()
1092                   && !_TMC::template
1093                     _ImplicitlyConvertibleTuple<_U1, _U2>(),
1094         bool>::type = false>
1095         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1096               const tuple<_U1, _U2>& __in)
1097         : _Inherited(__tag, __a,
1098                      static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1099         { }
1100
1101       template<typename _Alloc, typename _U1, typename _U2, typename
1102         enable_if<_TMC::template
1103                     _MoveConstructibleTuple<_U1, _U2>()
1104                   && _TMC::template
1105                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1106         bool>::type = true>
1107         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
1108         : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1109         { }
1110
1111       template<typename _Alloc, typename _U1, typename _U2, typename
1112         enable_if<_TMC::template
1113                     _MoveConstructibleTuple<_U1, _U2>()
1114                   && !_TMC::template
1115                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1116         bool>::type = false>
1117         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1118                        tuple<_U1, _U2>&& __in)
1119         : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1120         { }
1121
1122       template<typename _Alloc, typename _U1, typename _U2, typename
1123         enable_if<_TMC::template
1124                     _ConstructibleTuple<_U1, _U2>()
1125                   && _TMC::template
1126                     _ImplicitlyConvertibleTuple<_U1, _U2>(),
1127         bool>::type = true>
1128         tuple(allocator_arg_t __tag, const _Alloc& __a,
1129               const pair<_U1, _U2>& __in)
1130         : _Inherited(__tag, __a, __in.first, __in.second) { }
1131
1132       template<typename _Alloc, typename _U1, typename _U2, typename
1133         enable_if<_TMC::template
1134                     _ConstructibleTuple<_U1, _U2>()
1135                   && !_TMC::template
1136                     _ImplicitlyConvertibleTuple<_U1, _U2>(),
1137         bool>::type = false>
1138         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1139               const pair<_U1, _U2>& __in)
1140         : _Inherited(__tag, __a, __in.first, __in.second) { }
1141
1142       template<typename _Alloc, typename _U1, typename _U2, typename
1143         enable_if<_TMC::template
1144                     _MoveConstructibleTuple<_U1, _U2>()
1145                   && _TMC::template
1146                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1147         bool>::type = true>
1148         tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
1149         : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1150                      std::forward<_U2>(__in.second)) { }
1151
1152       template<typename _Alloc, typename _U1, typename _U2, typename
1153         enable_if<_TMC::template
1154                     _MoveConstructibleTuple<_U1, _U2>()
1155                   && !_TMC::template
1156                     _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1157         bool>::type = false>
1158         explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1159                        pair<_U1, _U2>&& __in)
1160         : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1161                      std::forward<_U2>(__in.second)) { }
1162
1163       tuple&
1164       operator=(const tuple& __in)
1165       {
1166         static_cast<_Inherited&>(*this) = __in;
1167         return *this;
1168       }
1169
1170       tuple&
1171       operator=(tuple&& __in)
1172       noexcept(is_nothrow_move_assignable<_Inherited>::value)
1173       {
1174         static_cast<_Inherited&>(*this) = std::move(__in);
1175         return *this;
1176       }
1177
1178       template<typename _U1, typename _U2>
1179         tuple&
1180         operator=(const tuple<_U1, _U2>& __in)
1181         {
1182           static_cast<_Inherited&>(*this) = __in;
1183           return *this;
1184         }
1185
1186       template<typename _U1, typename _U2>
1187         tuple&
1188         operator=(tuple<_U1, _U2>&& __in)
1189         {
1190           static_cast<_Inherited&>(*this) = std::move(__in);
1191           return *this;
1192         }
1193
1194       template<typename _U1, typename _U2>
1195         tuple&
1196         operator=(const pair<_U1, _U2>& __in)
1197         {
1198           this->_M_head(*this) = __in.first;
1199           this->_M_tail(*this)._M_head(*this) = __in.second;
1200           return *this;
1201         }
1202
1203       template<typename _U1, typename _U2>
1204         tuple&
1205         operator=(pair<_U1, _U2>&& __in)
1206         {
1207           this->_M_head(*this) = std::forward<_U1>(__in.first);
1208           this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
1209           return *this;
1210         }
1211
1212       void
1213       swap(tuple& __in)
1214       noexcept(noexcept(__in._M_swap(__in)))
1215       { _Inherited::_M_swap(__in); }
1216     };
1217
1218
1219   /**
1220    * Recursive case for tuple_element: strip off the first element in
1221    * the tuple and retrieve the (i-1)th element of the remaining tuple.
1222    */
1223   template<std::size_t __i, typename _Head, typename... _Tail>
1224     struct tuple_element<__i, tuple<_Head, _Tail...> >
1225     : tuple_element<__i - 1, tuple<_Tail...> > { };
1226
1227   /**
1228    * Basis case for tuple_element: The first element is the one we're seeking.
1229    */
1230   template<typename _Head, typename... _Tail>
1231     struct tuple_element<0, tuple<_Head, _Tail...> >
1232     {
1233       typedef _Head type;
1234     };
1235
1236   /// class tuple_size
1237   template<typename... _Elements>
1238     struct tuple_size<tuple<_Elements...>>
1239     : public integral_constant<std::size_t, sizeof...(_Elements)> { };
1240
1241   template<std::size_t __i, typename _Head, typename... _Tail>
1242     constexpr _Head&
1243     __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1244     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1245
1246   template<std::size_t __i, typename _Head, typename... _Tail>
1247     constexpr const _Head&
1248     __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1249     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1250
1251   /// Return a reference to the ith element of a tuple.
1252   template<std::size_t __i, typename... _Elements>
1253     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1254     get(tuple<_Elements...>& __t) noexcept
1255     { return std::__get_helper<__i>(__t); }
1256
1257   /// Return a const reference to the ith element of a const tuple.
1258   template<std::size_t __i, typename... _Elements>
1259     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1260     get(const tuple<_Elements...>& __t) noexcept
1261     { return std::__get_helper<__i>(__t); }
1262
1263   /// Return an rvalue reference to the ith element of a tuple rvalue.
1264   template<std::size_t __i, typename... _Elements>
1265     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1266     get(tuple<_Elements...>&& __t) noexcept
1267     {
1268       typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
1269       return std::forward<__element_type&&>(std::get<__i>(__t));
1270     }
1271
1272 #if __cplusplus > 201103L
1273
1274 #define __cpp_lib_tuples_by_type 201304
1275
1276   template<typename _Head, size_t __i, typename... _Tail>
1277     constexpr _Head&
1278     __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1279     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1280
1281   template<typename _Head, size_t __i, typename... _Tail>
1282     constexpr const _Head&
1283     __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1284     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1285
1286   /// Return a reference to the unique element of type _Tp of a tuple.
1287   template <typename _Tp, typename... _Types>
1288     constexpr _Tp&
1289     get(tuple<_Types...>& __t) noexcept
1290     { return std::__get_helper2<_Tp>(__t); }
1291
1292   /// Return a reference to the unique element of type _Tp of a tuple rvalue.
1293   template <typename _Tp, typename... _Types>
1294     constexpr _Tp&&
1295     get(tuple<_Types...>&& __t) noexcept
1296     { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
1297
1298   /// Return a const reference to the unique element of type _Tp of a tuple.
1299   template <typename _Tp, typename... _Types>
1300     constexpr const _Tp&
1301     get(const tuple<_Types...>& __t) noexcept
1302     { return std::__get_helper2<_Tp>(__t); }
1303 #endif
1304
1305   // This class performs the comparison operations on tuples
1306   template<typename _Tp, typename _Up, size_t __i, size_t __size>
1307     struct __tuple_compare
1308     {
1309       static constexpr bool
1310       __eq(const _Tp& __t, const _Up& __u)
1311       {
1312         return bool(std::get<__i>(__t) == std::get<__i>(__u))
1313           && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
1314       }
1315
1316       static constexpr bool
1317       __less(const _Tp& __t, const _Up& __u)
1318       {
1319         return bool(std::get<__i>(__t) < std::get<__i>(__u))
1320           || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
1321               && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
1322       }
1323     };
1324
1325   template<typename _Tp, typename _Up, size_t __size>
1326     struct __tuple_compare<_Tp, _Up, __size, __size>
1327     {
1328       static constexpr bool
1329       __eq(const _Tp&, const _Up&) { return true; }
1330
1331       static constexpr bool
1332       __less(const _Tp&, const _Up&) { return false; }
1333     };
1334
1335   template<typename... _TElements, typename... _UElements>
1336     constexpr bool
1337     operator==(const tuple<_TElements...>& __t,
1338                const tuple<_UElements...>& __u)
1339     {
1340       static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1341           "tuple objects can only be compared if they have equal sizes.");
1342       using __compare = __tuple_compare<tuple<_TElements...>,
1343                                         tuple<_UElements...>,
1344                                         0, sizeof...(_TElements)>;
1345       return __compare::__eq(__t, __u);
1346     }
1347
1348   template<typename... _TElements, typename... _UElements>
1349     constexpr bool
1350     operator<(const tuple<_TElements...>& __t,
1351               const tuple<_UElements...>& __u)
1352     {
1353       static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1354           "tuple objects can only be compared if they have equal sizes.");
1355       using __compare = __tuple_compare<tuple<_TElements...>,
1356                                         tuple<_UElements...>,
1357                                         0, sizeof...(_TElements)>;
1358       return __compare::__less(__t, __u);
1359     }
1360
1361   template<typename... _TElements, typename... _UElements>
1362     constexpr bool
1363     operator!=(const tuple<_TElements...>& __t,
1364                const tuple<_UElements...>& __u)
1365     { return !(__t == __u); }
1366
1367   template<typename... _TElements, typename... _UElements>
1368     constexpr bool
1369     operator>(const tuple<_TElements...>& __t,
1370               const tuple<_UElements...>& __u)
1371     { return __u < __t; }
1372
1373   template<typename... _TElements, typename... _UElements>
1374     constexpr bool
1375     operator<=(const tuple<_TElements...>& __t,
1376                const tuple<_UElements...>& __u)
1377     { return !(__u < __t); }
1378
1379   template<typename... _TElements, typename... _UElements>
1380     constexpr bool
1381     operator>=(const tuple<_TElements...>& __t,
1382                const tuple<_UElements...>& __u)
1383     { return !(__t < __u); }
1384
1385   // NB: DR 705.
1386   template<typename... _Elements>
1387     constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
1388     make_tuple(_Elements&&... __args)
1389     {
1390       typedef tuple<typename __decay_and_strip<_Elements>::__type...>
1391         __result_type;
1392       return __result_type(std::forward<_Elements>(__args)...);
1393     }
1394
1395   // _GLIBCXX_RESOLVE_LIB_DEFECTS
1396   // 2275. Why is forward_as_tuple not constexpr?
1397   template<typename... _Elements>
1398     constexpr tuple<_Elements&&...>
1399     forward_as_tuple(_Elements&&... __args) noexcept
1400     { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
1401
1402   template<typename... _Tps>
1403     struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
1404     { };
1405
1406   // Internal type trait that allows us to sfinae-protect tuple_cat.
1407   template<typename _Tp>
1408     struct __is_tuple_like
1409     : public __is_tuple_like_impl<typename std::remove_cv
1410             <typename std::remove_reference<_Tp>::type>::type>::type
1411     { };
1412
1413   template<size_t, typename, typename, size_t>
1414     struct __make_tuple_impl;
1415
1416   template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
1417     struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
1418     : __make_tuple_impl<_Idx + 1,
1419                         tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
1420                         _Tuple, _Nm>
1421     { };
1422
1423   template<std::size_t _Nm, typename _Tuple, typename... _Tp>
1424     struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
1425     {
1426       typedef tuple<_Tp...> __type;
1427     };
1428
1429   template<typename _Tuple>
1430     struct __do_make_tuple
1431     : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
1432     { };
1433
1434   // Returns the std::tuple equivalent of a tuple-like type.
1435   template<typename _Tuple>
1436     struct __make_tuple
1437     : public __do_make_tuple<typename std::remove_cv
1438             <typename std::remove_reference<_Tuple>::type>::type>
1439     { };
1440
1441   // Combines several std::tuple's into a single one.
1442   template<typename...>
1443     struct __combine_tuples;
1444
1445   template<>
1446     struct __combine_tuples<>
1447     {
1448       typedef tuple<> __type;
1449     };
1450
1451   template<typename... _Ts>
1452     struct __combine_tuples<tuple<_Ts...>>
1453     {
1454       typedef tuple<_Ts...> __type;
1455     };
1456
1457   template<typename... _T1s, typename... _T2s, typename... _Rem>
1458     struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
1459     {
1460       typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
1461                                         _Rem...>::__type __type;
1462     };
1463
1464   // Computes the result type of tuple_cat given a set of tuple-like types.
1465   template<typename... _Tpls>
1466     struct __tuple_cat_result
1467     {
1468       typedef typename __combine_tuples
1469         <typename __make_tuple<_Tpls>::__type...>::__type __type;
1470     };
1471
1472   // Helper to determine the index set for the first tuple-like
1473   // type of a given set.
1474   template<typename...>
1475     struct __make_1st_indices;
1476
1477   template<>
1478     struct __make_1st_indices<>
1479     {
1480       typedef std::_Index_tuple<> __type;
1481     };
1482
1483   template<typename _Tp, typename... _Tpls>
1484     struct __make_1st_indices<_Tp, _Tpls...>
1485     {
1486       typedef typename std::_Build_index_tuple<std::tuple_size<
1487         typename std::remove_reference<_Tp>::type>::value>::__type __type;
1488     };
1489
1490   // Performs the actual concatenation by step-wise expanding tuple-like
1491   // objects into the elements,  which are finally forwarded into the
1492   // result tuple.
1493   template<typename _Ret, typename _Indices, typename... _Tpls>
1494     struct __tuple_concater;
1495
1496   template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
1497     struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
1498     {
1499       template<typename... _Us>
1500         static constexpr _Ret
1501         _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
1502         {
1503           typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1504           typedef __tuple_concater<_Ret, __idx, _Tpls...>      __next;
1505           return __next::_S_do(std::forward<_Tpls>(__tps)...,
1506                                std::forward<_Us>(__us)...,
1507                                std::get<_Is>(std::forward<_Tp>(__tp))...);
1508         }
1509     };
1510
1511   template<typename _Ret>
1512     struct __tuple_concater<_Ret, std::_Index_tuple<>>
1513     {
1514       template<typename... _Us>
1515         static constexpr _Ret
1516         _S_do(_Us&&... __us)
1517         {
1518           return _Ret(std::forward<_Us>(__us)...);
1519         }
1520     };
1521
1522   /// tuple_cat
1523   template<typename... _Tpls, typename = typename
1524            enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
1525     constexpr auto
1526     tuple_cat(_Tpls&&... __tpls)
1527     -> typename __tuple_cat_result<_Tpls...>::__type
1528     {
1529       typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
1530       typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1531       typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
1532       return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
1533     }
1534
1535   // _GLIBCXX_RESOLVE_LIB_DEFECTS
1536   // 2301. Why is tie not constexpr?
1537   /// tie
1538   template<typename... _Elements>
1539     constexpr tuple<_Elements&...>
1540     tie(_Elements&... __args) noexcept
1541     { return tuple<_Elements&...>(__args...); }
1542
1543   /// swap
1544   template<typename... _Elements>
1545     inline void
1546     swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
1547     noexcept(noexcept(__x.swap(__y)))
1548     { __x.swap(__y); }
1549
1550   // A class (and instance) which can be used in 'tie' when an element
1551   // of a tuple is not required
1552   struct _Swallow_assign
1553   {
1554     template<class _Tp>
1555       const _Swallow_assign&
1556       operator=(const _Tp&) const
1557       { return *this; }
1558   };
1559
1560   const _Swallow_assign ignore{};
1561
1562   /// Partial specialization for tuples
1563   template<typename... _Types, typename _Alloc>
1564     struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
1565
1566   // See stl_pair.h...
1567   template<class _T1, class _T2>
1568     template<typename... _Args1, typename... _Args2>
1569       inline
1570       pair<_T1, _T2>::
1571       pair(piecewise_construct_t,
1572            tuple<_Args1...> __first, tuple<_Args2...> __second)
1573       : pair(__first, __second,
1574              typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
1575              typename _Build_index_tuple<sizeof...(_Args2)>::__type())
1576       { }
1577
1578   template<class _T1, class _T2>
1579     template<typename... _Args1, std::size_t... _Indexes1,
1580              typename... _Args2, std::size_t... _Indexes2>
1581       inline
1582       pair<_T1, _T2>::
1583       pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
1584            _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
1585       : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
1586         second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
1587       { }
1588
1589   /// @}
1590
1591 _GLIBCXX_END_NAMESPACE_VERSION
1592 } // namespace std
1593
1594 #endif // C++11
1595
1596 #endif // _GLIBCXX_TUPLE