contrib/libc++/include/tuple

   1 // -*- C++ -*-
   2 //===--------------------------- tuple ------------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is distributed under the University of Illinois Open Source
   7 // License. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP_TUPLE
  12 #define _LIBCPP_TUPLE
  13
  14 /*
  15     tuple synopsis
  16
  17 namespace std
  18 {
  19
  20 template <class... T>
  21 class tuple {
  22 public:
  23     constexpr tuple();
  24     explicit tuple(const T&...);  // constexpr in C++14
  25     template <class... U>
  26         explicit tuple(U&&...);  // constexpr in C++14
  27     tuple(const tuple&) = default;
  28     tuple(tuple&&) = default;
  29     template <class... U>
  30         tuple(const tuple<U...>&);  // constexpr in C++14
  31     template <class... U>
  32         tuple(tuple<U...>&&);  // constexpr in C++14
  33     template <class U1, class U2>
  34         tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
  35     template <class U1, class U2>
  36         tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2  // constexpr in C++14
  37
  38     // allocator-extended constructors
  39     template <class Alloc>
  40         tuple(allocator_arg_t, const Alloc& a);
  41     template <class Alloc>
  42         tuple(allocator_arg_t, const Alloc& a, const T&...);
  43     template <class Alloc, class... U>
  44         tuple(allocator_arg_t, const Alloc& a, U&&...);
  45     template <class Alloc>
  46         tuple(allocator_arg_t, const Alloc& a, const tuple&);
  47     template <class Alloc>
  48         tuple(allocator_arg_t, const Alloc& a, tuple&&);
  49     template <class Alloc, class... U>
  50         tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
  51     template <class Alloc, class... U>
  52         tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
  53     template <class Alloc, class U1, class U2>
  54         tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
  55     template <class Alloc, class U1, class U2>
  56         tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
  57
  58     tuple& operator=(const tuple&);
  59     tuple&
  60         operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
  61     template <class... U>
  62         tuple& operator=(const tuple<U...>&);
  63     template <class... U>
  64         tuple& operator=(tuple<U...>&&);
  65     template <class U1, class U2>
  66         tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2
  67     template <class U1, class U2>
  68         tuple& operator=(pair<U1, U2>&&); //iffsizeof...(T) == 2
  69
  70     void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
  71 };
  72
  73 inline constexpr unspecified ignore;
  74
  75 template <class... T> tuple<V...>  make_tuple(T&&...); // constexpr in C++14
  76 template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
  77 template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14
  78 template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
  79
  80 // [tuple.apply], calling a function with a tuple of arguments:
  81 template <class F, class Tuple>
  82   constexpr decltype(auto) apply(F&& f, Tuple&& t); // C++17
  83 template <class T, class Tuple>
  84   constexpr T make_from_tuple(Tuple&& t); // C++17
  85
  86 // 20.4.1.4, tuple helper classes:
  87 template <class T> class tuple_size; // undefined
  88 template <class... T> class tuple_size<tuple<T...>>;
  89 template <class T>
  90  inline constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17
  91 template <size_t I, class T> class tuple_element; // undefined
  92 template <size_t I, class... T> class tuple_element<I, tuple<T...>>;
  93 template <size_t I, class T>
  94   using tuple_element_t = typename tuple_element <I, T>::type; // C++14
  95
  96 // 20.4.1.5, element access:
  97 template <size_t I, class... T>
  98     typename tuple_element<I, tuple<T...>>::type&
  99     get(tuple<T...>&) noexcept; // constexpr in C++14
 100 template <size_t I, class... T>
 101     const typename tuple_element<I, tuple<T...>>::type&
 102     get(const tuple<T...>&) noexcept; // constexpr in C++14
 103 template <size_t I, class... T>
 104     typename tuple_element<I, tuple<T...>>::type&&
 105     get(tuple<T...>&&) noexcept; // constexpr in C++14
 106 template <size_t I, class... T>
 107     const typename tuple_element<I, tuple<T...>>::type&&
 108     get(const tuple<T...>&&) noexcept; // constexpr in C++14
 109
 110 template <class T1, class... T>
 111     constexpr T1& get(tuple<T...>&) noexcept;  // C++14
 112 template <class T1, class... T>
 113     constexpr const T1& get(const tuple<T...>&) noexcept;   // C++14
 114 template <class T1, class... T>
 115     constexpr T1&& get(tuple<T...>&&) noexcept;   // C++14
 116 template <class T1, class... T>
 117     constexpr const T1&& get(const tuple<T...>&&) noexcept;   // C++14
 118
 119 // 20.4.1.6, relational operators:
 120 template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 121 template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14
 122 template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 123 template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14
 124 template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 125 template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 126
 127 template <class... Types, class Alloc>
 128   struct uses_allocator<tuple<Types...>, Alloc>;
 129
 130 template <class... Types>
 131   void
 132   swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
 133
 134 }  // std
 135
 136 */
 137
 138 #include <__config>
 139 #include <__tuple>
 140 #include <cstddef>
 141 #include <type_traits>
 142 #include <__functional_base>
 143 #include <utility>
 144
 145 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 146 #pragma GCC system_header
 147 #endif
 148
 149 _LIBCPP_BEGIN_NAMESPACE_STD
 150
 151 #ifndef _LIBCPP_CXX03_LANG
 152
 153
 154 // __tuple_leaf
 155
 156 template <size_t _Ip, class _Hp,
 157           bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value
 158          >
 159 class __tuple_leaf;
 160
 161 template <size_t _Ip, class _Hp, bool _Ep>
 162 inline _LIBCPP_INLINE_VISIBILITY
 163 void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
 164     _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
 165 {
 166     swap(__x.get(), __y.get());
 167 }
 168
 169 template <size_t _Ip, class _Hp, bool>
 170 class __tuple_leaf
 171 {
 172     _Hp __value_;
 173
 174     template <class _Tp>
 175     static constexpr bool __can_bind_reference() {
 176 #if __has_keyword(__reference_binds_to_temporary)
 177       return !__reference_binds_to_temporary(_Hp, _Tp);
 178 #else
 179       return true;
 180 #endif
 181     }
 182
 183     __tuple_leaf& operator=(const __tuple_leaf&);
 184 public:
 185     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
 186              _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
 187        {static_assert(!is_reference<_Hp>::value,
 188               "Attempted to default construct a reference element in a tuple");}
 189
 190     template <class _Alloc>
 191         _LIBCPP_INLINE_VISIBILITY
 192         __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
 193             : __value_()
 194         {static_assert(!is_reference<_Hp>::value,
 195               "Attempted to default construct a reference element in a tuple");}
 196
 197     template <class _Alloc>
 198         _LIBCPP_INLINE_VISIBILITY
 199         __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
 200             : __value_(allocator_arg_t(), __a)
 201         {static_assert(!is_reference<_Hp>::value,
 202               "Attempted to default construct a reference element in a tuple");}
 203
 204     template <class _Alloc>
 205         _LIBCPP_INLINE_VISIBILITY
 206         __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
 207             : __value_(__a)
 208         {static_assert(!is_reference<_Hp>::value,
 209               "Attempted to default construct a reference element in a tuple");}
 210
 211     template <class _Tp,
 212               class = typename enable_if<
 213                   __lazy_and<
 214                       __lazy_not<is_same<typename __uncvref<_Tp>::type, __tuple_leaf>>
 215                     , is_constructible<_Hp, _Tp>
 216                     >::value
 217                 >::type
 218             >
 219         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 220         explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
 221             : __value_(_VSTD::forward<_Tp>(__t))
 222         {static_assert(__can_bind_reference<_Tp&&>(),
 223        "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
 224
 225     template <class _Tp, class _Alloc>
 226         _LIBCPP_INLINE_VISIBILITY
 227         explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
 228             : __value_(_VSTD::forward<_Tp>(__t))
 229         {static_assert(__can_bind_reference<_Tp&&>(),
 230        "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
 231
 232     template <class _Tp, class _Alloc>
 233         _LIBCPP_INLINE_VISIBILITY
 234         explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
 235             : __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
 236         {static_assert(!is_reference<_Hp>::value,
 237             "Attempted to uses-allocator construct a reference element in a tuple");}
 238
 239     template <class _Tp, class _Alloc>
 240         _LIBCPP_INLINE_VISIBILITY
 241         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
 242             : __value_(_VSTD::forward<_Tp>(__t), __a)
 243         {static_assert(!is_reference<_Hp>::value,
 244            "Attempted to uses-allocator construct a reference element in a tuple");}
 245
 246     __tuple_leaf(const __tuple_leaf& __t) = default;
 247     __tuple_leaf(__tuple_leaf&& __t) = default;
 248
 249     template <class _Tp>
 250         _LIBCPP_INLINE_VISIBILITY
 251         __tuple_leaf&
 252         operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
 253         {
 254             __value_ = _VSTD::forward<_Tp>(__t);
 255             return *this;
 256         }
 257
 258     _LIBCPP_INLINE_VISIBILITY
 259     int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
 260     {
 261         _VSTD::swap(*this, __t);
 262         return 0;
 263     }
 264
 265     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return __value_;}
 266     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;}
 267 };
 268
 269 template <size_t _Ip, class _Hp>
 270 class __tuple_leaf<_Ip, _Hp, true>
 271     : private _Hp
 272 {
 273
 274     __tuple_leaf& operator=(const __tuple_leaf&);
 275 public:
 276     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
 277              _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
 278
 279     template <class _Alloc>
 280         _LIBCPP_INLINE_VISIBILITY
 281         __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
 282
 283     template <class _Alloc>
 284         _LIBCPP_INLINE_VISIBILITY
 285         __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
 286             : _Hp(allocator_arg_t(), __a) {}
 287
 288     template <class _Alloc>
 289         _LIBCPP_INLINE_VISIBILITY
 290         __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
 291             : _Hp(__a) {}
 292
 293     template <class _Tp,
 294               class = typename enable_if<
 295                   __lazy_and<
 296                         __lazy_not<is_same<typename __uncvref<_Tp>::type, __tuple_leaf>>
 297                       , is_constructible<_Hp, _Tp>
 298                     >::value
 299                 >::type
 300             >
 301         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 302         explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
 303             : _Hp(_VSTD::forward<_Tp>(__t)) {}
 304
 305     template <class _Tp, class _Alloc>
 306         _LIBCPP_INLINE_VISIBILITY
 307         explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
 308             : _Hp(_VSTD::forward<_Tp>(__t)) {}
 309
 310     template <class _Tp, class _Alloc>
 311         _LIBCPP_INLINE_VISIBILITY
 312         explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
 313             : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
 314
 315     template <class _Tp, class _Alloc>
 316         _LIBCPP_INLINE_VISIBILITY
 317         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
 318             : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
 319
 320     __tuple_leaf(__tuple_leaf const &) = default;
 321     __tuple_leaf(__tuple_leaf &&) = default;
 322
 323     template <class _Tp>
 324         _LIBCPP_INLINE_VISIBILITY
 325         __tuple_leaf&
 326         operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
 327         {
 328             _Hp::operator=(_VSTD::forward<_Tp>(__t));
 329             return *this;
 330         }
 331
 332     _LIBCPP_INLINE_VISIBILITY
 333     int
 334     swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
 335     {
 336         _VSTD::swap(*this, __t);
 337         return 0;
 338     }
 339
 340     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
 341     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
 342 };
 343
 344 template <class ..._Tp>
 345 _LIBCPP_INLINE_VISIBILITY
 346 void __swallow(_Tp&&...) _NOEXCEPT {}
 347
 348 template <class ..._Tp>
 349 struct __lazy_all : __all<_Tp::value...> {};
 350
 351 template <class _Tp>
 352 struct __all_default_constructible;
 353
 354 template <class ..._Tp>
 355 struct __all_default_constructible<__tuple_types<_Tp...>>
 356     : __all<is_default_constructible<_Tp>::value...>
 357 { };
 358
 359 // __tuple_impl
 360
 361 template<class _Indx, class ..._Tp> struct __tuple_impl;
 362
 363 template<size_t ..._Indx, class ..._Tp>
 364 struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
 365     : public __tuple_leaf<_Indx, _Tp>...
 366 {
 367     _LIBCPP_INLINE_VISIBILITY
 368     _LIBCPP_CONSTEXPR __tuple_impl()
 369         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 370
 371     template <size_t ..._Uf, class ..._Tf,
 372               size_t ..._Ul, class ..._Tl, class ..._Up>
 373         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 374         explicit
 375         __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
 376                      __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
 377                      _Up&&... __u)
 378                      _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
 379                                  __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
 380             __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
 381             __tuple_leaf<_Ul, _Tl>()...
 382             {}
 383
 384     template <class _Alloc, size_t ..._Uf, class ..._Tf,
 385               size_t ..._Ul, class ..._Tl, class ..._Up>
 386         _LIBCPP_INLINE_VISIBILITY
 387         explicit
 388         __tuple_impl(allocator_arg_t, const _Alloc& __a,
 389                      __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
 390                      __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
 391                      _Up&&... __u) :
 392             __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
 393             _VSTD::forward<_Up>(__u))...,
 394             __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
 395             {}
 396
 397     template <class _Tuple,
 398               class = typename enable_if
 399                       <
 400                          __tuple_constructible<_Tuple, tuple<_Tp...> >::value
 401                       >::type
 402              >
 403         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 404         __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
 405                                        typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
 406             : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
 407                                        typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
 408             {}
 409
 410     template <class _Alloc, class _Tuple,
 411               class = typename enable_if
 412                       <
 413                          __tuple_constructible<_Tuple, tuple<_Tp...> >::value
 414                       >::type
 415              >
 416         _LIBCPP_INLINE_VISIBILITY
 417         __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
 418             : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
 419                                        typename __make_tuple_types<_Tuple>::type>::type>(), __a,
 420                                        _VSTD::forward<typename tuple_element<_Indx,
 421                                        typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
 422             {}
 423
 424     template <class _Tuple>
 425         _LIBCPP_INLINE_VISIBILITY
 426         typename enable_if
 427         <
 428             __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
 429             __tuple_impl&
 430         >::type
 431         operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx,
 432                                        typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
 433         {
 434             __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
 435                                        typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
 436             return *this;
 437         }
 438
 439     __tuple_impl(const __tuple_impl&) = default;
 440     __tuple_impl(__tuple_impl&&) = default;
 441
 442     _LIBCPP_INLINE_VISIBILITY
 443     __tuple_impl&
 444     operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
 445     {
 446         __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
 447         return *this;
 448     }
 449
 450     _LIBCPP_INLINE_VISIBILITY
 451     __tuple_impl&
 452     operator=(__tuple_impl&& __t) _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
 453     {
 454         __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...);
 455         return *this;
 456     }
 457
 458     _LIBCPP_INLINE_VISIBILITY
 459     void swap(__tuple_impl& __t)
 460         _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
 461     {
 462         __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
 463     }
 464 };
 465
 466
 467
 468 template <class ..._Tp>
 469 class _LIBCPP_TEMPLATE_VIS tuple
 470 {
 471     typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
 472
 473     _BaseT __base_;
 474
 475 #if defined(_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION)
 476     static constexpr bool _EnableImplicitReducedArityExtension = true;
 477 #else
 478     static constexpr bool _EnableImplicitReducedArityExtension = false;
 479 #endif
 480
 481     template <class ..._Args>
 482     struct _PackExpandsToThisTuple : false_type {};
 483
 484     template <class _Arg>
 485     struct _PackExpandsToThisTuple<_Arg>
 486         : is_same<typename __uncvref<_Arg>::type, tuple> {};
 487
 488     template <bool _MaybeEnable, class _Dummy = void>
 489     struct _CheckArgsConstructor : __check_tuple_constructor_fail {};
 490
 491     template <class _Dummy>
 492     struct _CheckArgsConstructor<true, _Dummy>
 493     {
 494         template <class ..._Args>
 495         static constexpr bool __enable_default() {
 496             return __all<is_default_constructible<_Args>::value...>::value;
 497         }
 498
 499         template <class ..._Args>
 500         static constexpr bool __enable_explicit() {
 501             return
 502                 __tuple_constructible<
 503                     tuple<_Args...>,
 504                     typename __make_tuple_types<tuple,
 505                              sizeof...(_Args) < sizeof...(_Tp) ?
 506                                  sizeof...(_Args) :
 507                                  sizeof...(_Tp)>::type
 508                 >::value &&
 509                 !__tuple_convertible<
 510                     tuple<_Args...>,
 511                     typename __make_tuple_types<tuple,
 512                              sizeof...(_Args) < sizeof...(_Tp) ?
 513                                  sizeof...(_Args) :
 514                                  sizeof...(_Tp)>::type
 515                 >::value &&
 516                 __all_default_constructible<
 517                     typename __make_tuple_types<tuple, sizeof...(_Tp),
 518                              sizeof...(_Args) < sizeof...(_Tp) ?
 519                                  sizeof...(_Args) :
 520                                  sizeof...(_Tp)>::type
 521                 >::value;
 522         }
 523
 524         template <class ..._Args>
 525         static constexpr bool __enable_implicit() {
 526             return
 527                 __tuple_convertible<
 528                     tuple<_Args...>,
 529                     typename __make_tuple_types<tuple,
 530                              sizeof...(_Args) < sizeof...(_Tp) ?
 531                                  sizeof...(_Args) :
 532                                  sizeof...(_Tp)>::type
 533                 >::value &&
 534                 __all_default_constructible<
 535                     typename __make_tuple_types<tuple, sizeof...(_Tp),
 536                              sizeof...(_Args) < sizeof...(_Tp) ?
 537                                  sizeof...(_Args) :
 538                                  sizeof...(_Tp)>::type
 539                 >::value;
 540         }
 541     };
 542
 543     template <bool _MaybeEnable,
 544               bool = sizeof...(_Tp) == 1,
 545               class _Dummy = void>
 546     struct _CheckTupleLikeConstructor : __check_tuple_constructor_fail {};
 547
 548     template <class _Dummy>
 549     struct _CheckTupleLikeConstructor<true, false, _Dummy>
 550     {
 551         template <class _Tuple>
 552         static constexpr bool __enable_implicit() {
 553             return __tuple_convertible<_Tuple, tuple>::value;
 554         }
 555
 556         template <class _Tuple>
 557         static constexpr bool __enable_explicit() {
 558             return __tuple_constructible<_Tuple, tuple>::value
 559                && !__tuple_convertible<_Tuple, tuple>::value;
 560         }
 561     };
 562
 563     template <class _Dummy>
 564     struct _CheckTupleLikeConstructor<true, true, _Dummy>
 565     {
 566         // This trait is used to disable the tuple-like constructor when
 567         // the UTypes... constructor should be selected instead.
 568         // See LWG issue #2549.
 569         template <class _Tuple>
 570         using _PreferTupleLikeConstructor = __lazy_or<
 571             // Don't attempt the two checks below if the tuple we are given
 572             // has the same type as this tuple.
 573             is_same<typename __uncvref<_Tuple>::type, tuple>,
 574             __lazy_and<
 575                 __lazy_not<is_constructible<_Tp..., _Tuple>>,
 576                 __lazy_not<is_convertible<_Tuple, _Tp...>>
 577             >
 578         >;
 579
 580         template <class _Tuple>
 581         static constexpr bool __enable_implicit() {
 582             return __lazy_and<
 583                 __tuple_convertible<_Tuple, tuple>,
 584                 _PreferTupleLikeConstructor<_Tuple>
 585             >::value;
 586         }
 587
 588         template <class _Tuple>
 589         static constexpr bool __enable_explicit() {
 590             return __lazy_and<
 591                 __tuple_constructible<_Tuple, tuple>,
 592                 _PreferTupleLikeConstructor<_Tuple>,
 593                 __lazy_not<__tuple_convertible<_Tuple, tuple>>
 594             >::value;
 595         }
 596     };
 597
 598     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
 599         typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
 600     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
 601         const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
 602     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
 603         typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
 604     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
 605         const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
 606 public:
 607
 608     template <bool _Dummy = true, class = typename enable_if<
 609         _CheckArgsConstructor<_Dummy>::template __enable_default<_Tp...>()
 610     >::type>
 611     _LIBCPP_INLINE_VISIBILITY
 612     _LIBCPP_CONSTEXPR tuple()
 613         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 614
 615     tuple(tuple const&) = default;
 616     tuple(tuple&&) = default;
 617
 618     template <class _AllocArgT, class _Alloc, bool _Dummy = true, class = typename enable_if<
 619         __lazy_and<
 620             is_same<allocator_arg_t, _AllocArgT>,
 621             __lazy_all<__dependent_type<is_default_constructible<_Tp>, _Dummy>...>
 622        >::value
 623     >::type>
 624     _LIBCPP_INLINE_VISIBILITY
 625     tuple(_AllocArgT, _Alloc const& __a)
 626       : __base_(allocator_arg_t(), __a,
 627                     __tuple_indices<>(), __tuple_types<>(),
 628                     typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
 629                     __tuple_types<_Tp...>()) {}
 630
 631     template <bool _Dummy = true,
 632               typename enable_if
 633                       <
 634                          _CheckArgsConstructor<
 635                             _Dummy
 636                          >::template __enable_implicit<_Tp const&...>(),
 637                          bool
 638                       >::type = false
 639         >
 640     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 641     tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
 642         : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
 643                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
 644                 typename __make_tuple_indices<0>::type(),
 645                 typename __make_tuple_types<tuple, 0>::type(),
 646                 __t...
 647                ) {}
 648
 649     template <bool _Dummy = true,
 650               typename enable_if
 651                       <
 652                          _CheckArgsConstructor<
 653                             _Dummy
 654                          >::template __enable_explicit<_Tp const&...>(),
 655                          bool
 656                       >::type = false
 657         >
 658     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 659     explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
 660         : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
 661                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
 662                 typename __make_tuple_indices<0>::type(),
 663                 typename __make_tuple_types<tuple, 0>::type(),
 664                 __t...
 665                ) {}
 666
 667     template <class _Alloc, bool _Dummy = true,
 668               typename enable_if
 669                       <
 670                          _CheckArgsConstructor<
 671                             _Dummy
 672                          >::template __enable_implicit<_Tp const&...>(),
 673                          bool
 674                       >::type = false
 675         >
 676       _LIBCPP_INLINE_VISIBILITY
 677       tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
 678         : __base_(allocator_arg_t(), __a,
 679                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
 680                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
 681                 typename __make_tuple_indices<0>::type(),
 682                 typename __make_tuple_types<tuple, 0>::type(),
 683                 __t...
 684                ) {}
 685
 686     template <class _Alloc, bool _Dummy = true,
 687               typename enable_if
 688                       <
 689                          _CheckArgsConstructor<
 690                             _Dummy
 691                          >::template __enable_explicit<_Tp const&...>(),
 692                          bool
 693                       >::type = false
 694         >
 695       _LIBCPP_INLINE_VISIBILITY
 696       explicit
 697       tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
 698         : __base_(allocator_arg_t(), __a,
 699                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
 700                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
 701                 typename __make_tuple_indices<0>::type(),
 702                 typename __make_tuple_types<tuple, 0>::type(),
 703                 __t...
 704                ) {}
 705
 706     template <class ..._Up,
 707               bool _PackIsTuple = _PackExpandsToThisTuple<_Up...>::value,
 708               typename enable_if
 709                       <
 710                          _CheckArgsConstructor<
 711                              sizeof...(_Up) == sizeof...(_Tp)
 712                              && !_PackIsTuple
 713                          >::template __enable_implicit<_Up...>() ||
 714                         _CheckArgsConstructor<
 715                             _EnableImplicitReducedArityExtension
 716                             && sizeof...(_Up) < sizeof...(_Tp)
 717                             && !_PackIsTuple
 718                          >::template __enable_implicit<_Up...>(),
 719                          bool
 720                       >::type = false
 721              >
 722         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 723         tuple(_Up&&... __u)
 724             _NOEXCEPT_((
 725                 is_nothrow_constructible<_BaseT,
 726                     typename __make_tuple_indices<sizeof...(_Up)>::type,
 727                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
 728                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
 729                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
 730                     _Up...
 731                 >::value
 732             ))
 733             : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
 734                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
 735                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
 736                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
 737                     _VSTD::forward<_Up>(__u)...) {}
 738
 739     template <class ..._Up,
 740               typename enable_if
 741                       <
 742                          _CheckArgsConstructor<
 743                              sizeof...(_Up) <= sizeof...(_Tp)
 744                              && !_PackExpandsToThisTuple<_Up...>::value
 745                          >::template __enable_explicit<_Up...>() ||
 746                          _CheckArgsConstructor<
 747                             !_EnableImplicitReducedArityExtension
 748                             && sizeof...(_Up) < sizeof...(_Tp)
 749                             && !_PackExpandsToThisTuple<_Up...>::value
 750                          >::template __enable_implicit<_Up...>(),
 751                          bool
 752                       >::type = false
 753              >
 754         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 755         explicit
 756         tuple(_Up&&... __u)
 757             _NOEXCEPT_((
 758                 is_nothrow_constructible<_BaseT,
 759                     typename __make_tuple_indices<sizeof...(_Up)>::type,
 760                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
 761                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
 762                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
 763                     _Up...
 764                 >::value
 765             ))
 766             : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
 767                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
 768                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
 769                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
 770                     _VSTD::forward<_Up>(__u)...) {}
 771
 772     template <class _Alloc, class ..._Up,
 773               typename enable_if
 774                       <
 775                          _CheckArgsConstructor<
 776                              sizeof...(_Up) == sizeof...(_Tp) &&
 777                              !_PackExpandsToThisTuple<_Up...>::value
 778                          >::template __enable_implicit<_Up...>(),
 779                          bool
 780                       >::type = false
 781              >
 782         _LIBCPP_INLINE_VISIBILITY
 783         tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
 784             : __base_(allocator_arg_t(), __a,
 785                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
 786                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
 787                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
 788                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
 789                     _VSTD::forward<_Up>(__u)...) {}
 790
 791     template <class _Alloc, class ..._Up,
 792               typename enable_if
 793                       <
 794                          _CheckArgsConstructor<
 795                              sizeof...(_Up) == sizeof...(_Tp) &&
 796                              !_PackExpandsToThisTuple<_Up...>::value
 797                          >::template __enable_explicit<_Up...>(),
 798                          bool
 799                       >::type = false
 800              >
 801         _LIBCPP_INLINE_VISIBILITY
 802         explicit
 803         tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
 804             : __base_(allocator_arg_t(), __a,
 805                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
 806                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
 807                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
 808                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
 809                     _VSTD::forward<_Up>(__u)...) {}
 810
 811     template <class _Tuple,
 812               typename enable_if
 813                       <
 814                          _CheckTupleLikeConstructor<
 815                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
 816                              && !_PackExpandsToThisTuple<_Tuple>::value
 817                          >::template __enable_implicit<_Tuple>(),
 818                          bool
 819                       >::type = false
 820              >
 821         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 822         tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
 823             : __base_(_VSTD::forward<_Tuple>(__t)) {}
 824
 825     template <class _Tuple,
 826               typename enable_if
 827                       <
 828                          _CheckTupleLikeConstructor<
 829                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
 830                              && !_PackExpandsToThisTuple<_Tuple>::value
 831                          >::template __enable_explicit<_Tuple>(),
 832                          bool
 833                       >::type = false
 834              >
 835         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 836         explicit
 837         tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
 838             : __base_(_VSTD::forward<_Tuple>(__t)) {}
 839
 840     template <class _Alloc, class _Tuple,
 841               typename enable_if
 842                       <
 843                          _CheckTupleLikeConstructor<
 844                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
 845                          >::template __enable_implicit<_Tuple>(),
 846                          bool
 847                       >::type = false
 848              >
 849         _LIBCPP_INLINE_VISIBILITY
 850         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
 851             : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 852
 853     template <class _Alloc, class _Tuple,
 854               typename enable_if
 855                       <
 856                          _CheckTupleLikeConstructor<
 857                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
 858                          >::template __enable_explicit<_Tuple>(),
 859                          bool
 860                       >::type = false
 861              >
 862         _LIBCPP_INLINE_VISIBILITY
 863         explicit
 864         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
 865             : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 866
 867     using _CanCopyAssign = __all<is_copy_assignable<_Tp>::value...>;
 868     using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;
 869
 870     _LIBCPP_INLINE_VISIBILITY
 871     tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
 872         _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
 873     {
 874         __base_.operator=(__t.__base_);
 875         return *this;
 876     }
 877
 878     _LIBCPP_INLINE_VISIBILITY
 879     tuple& operator=(typename conditional<_CanMoveAssign::value, tuple, __nat>::type&& __t)
 880         _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
 881     {
 882         __base_.operator=(static_cast<_BaseT&&>(__t.__base_));
 883         return *this;
 884     }
 885
 886     template <class _Tuple,
 887               class = typename enable_if
 888                       <
 889                          __tuple_assignable<_Tuple, tuple>::value
 890                       >::type
 891              >
 892         _LIBCPP_INLINE_VISIBILITY
 893         tuple&
 894         operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<_BaseT&, _Tuple>::value))
 895         {
 896             __base_.operator=(_VSTD::forward<_Tuple>(__t));
 897             return *this;
 898         }
 899
 900     _LIBCPP_INLINE_VISIBILITY
 901     void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
 902         {__base_.swap(__t.__base_);}
 903 };
 904
 905 template <>
 906 class _LIBCPP_TEMPLATE_VIS tuple<>
 907 {
 908 public:
 909     _LIBCPP_INLINE_VISIBILITY
 910     _LIBCPP_CONSTEXPR tuple() _NOEXCEPT {}
 911     template <class _Alloc>
 912     _LIBCPP_INLINE_VISIBILITY
 913         tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
 914     template <class _Alloc>
 915     _LIBCPP_INLINE_VISIBILITY
 916         tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
 917     template <class _Up>
 918     _LIBCPP_INLINE_VISIBILITY
 919         tuple(array<_Up, 0>) _NOEXCEPT {}
 920     template <class _Alloc, class _Up>
 921     _LIBCPP_INLINE_VISIBILITY
 922         tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
 923     _LIBCPP_INLINE_VISIBILITY
 924     void swap(tuple&) _NOEXCEPT {}
 925 };
 926
 927 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 928 // NOTE: These are not yet standardized, but are required to simulate the
 929 // implicit deduction guide that should be generated had libc++ declared the
 930 // tuple-like constructors "correctly"
 931 template <class _Alloc, class ..._Args>
 932 tuple(allocator_arg_t, const _Alloc&, tuple<_Args...> const&) -> tuple<_Args...>;
 933 template <class _Alloc, class ..._Args>
 934 tuple(allocator_arg_t, const _Alloc&, tuple<_Args...>&&) -> tuple<_Args...>;
 935 #endif
 936
 937 template <class ..._Tp>
 938 inline _LIBCPP_INLINE_VISIBILITY
 939 typename enable_if
 940 <
 941     __all<__is_swappable<_Tp>::value...>::value,
 942     void
 943 >::type
 944 swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
 945                  _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
 946     {__t.swap(__u);}
 947
 948 // get
 949
 950 template <size_t _Ip, class ..._Tp>
 951 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 952 typename tuple_element<_Ip, tuple<_Tp...> >::type&
 953 get(tuple<_Tp...>& __t) _NOEXCEPT
 954 {
 955     typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
 956     return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
 957 }
 958
 959 template <size_t _Ip, class ..._Tp>
 960 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 961 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
 962 get(const tuple<_Tp...>& __t) _NOEXCEPT
 963 {
 964     typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
 965     return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
 966 }
 967
 968 template <size_t _Ip, class ..._Tp>
 969 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 970 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 971 get(tuple<_Tp...>&& __t) _NOEXCEPT
 972 {
 973     typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
 974     return static_cast<type&&>(
 975              static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
 976 }
 977
 978 template <size_t _Ip, class ..._Tp>
 979 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 980 const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 981 get(const tuple<_Tp...>&& __t) _NOEXCEPT
 982 {
 983     typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
 984     return static_cast<const type&&>(
 985              static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
 986 }
 987
 988 #if _LIBCPP_STD_VER > 11
 989
 990 namespace __find_detail {
 991
 992 static constexpr size_t __not_found = -1;
 993 static constexpr size_t __ambiguous = __not_found - 1;
 994
 995 inline _LIBCPP_INLINE_VISIBILITY
 996 constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
 997     return !__matches ? __res :
 998         (__res == __not_found ? __curr_i : __ambiguous);
 999 }
1000
1001 template <size_t _Nx>
1002 inline _LIBCPP_INLINE_VISIBILITY
1003 constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
1004   return __i == _Nx ? __not_found :
1005       __find_idx_return(__i, __find_idx(__i + 1, __matches), __matches[__i]);
1006 }
1007
1008 template <class _T1, class ..._Args>
1009 struct __find_exactly_one_checked {
1010     static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
1011     static constexpr size_t value = __find_detail::__find_idx(0, __matches);
1012     static_assert(value != __not_found, "type not found in type list" );
1013     static_assert(value != __ambiguous, "type occurs more than once in type list");
1014 };
1015
1016 template <class _T1>
1017 struct __find_exactly_one_checked<_T1> {
1018     static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
1019 };
1020
1021 } // namespace __find_detail;
1022
1023 template <typename _T1, typename... _Args>
1024 struct __find_exactly_one_t
1025     : public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
1026 };
1027
1028 template <class _T1, class... _Args>
1029 inline _LIBCPP_INLINE_VISIBILITY
1030 constexpr _T1& get(tuple<_Args...>& __tup) noexcept
1031 {
1032     return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
1033 }
1034
1035 template <class _T1, class... _Args>
1036 inline _LIBCPP_INLINE_VISIBILITY
1037 constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
1038 {
1039     return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
1040 }
1041
1042 template <class _T1, class... _Args>
1043 inline _LIBCPP_INLINE_VISIBILITY
1044 constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
1045 {
1046     return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
1047 }
1048
1049 template <class _T1, class... _Args>
1050 inline _LIBCPP_INLINE_VISIBILITY
1051 constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
1052 {
1053     return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
1054 }
1055
1056 #endif
1057
1058 // tie
1059
1060 template <class ..._Tp>
1061 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1062 tuple<_Tp&...>
1063 tie(_Tp&... __t) _NOEXCEPT
1064 {
1065     return tuple<_Tp&...>(__t...);
1066 }
1067
1068 template <class _Up>
1069 struct __ignore_t
1070 {
1071     template <class _Tp>
1072     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1073     const __ignore_t& operator=(_Tp&&) const {return *this;}
1074 };
1075
1076 namespace {
1077   _LIBCPP_INLINE_VAR constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
1078 }
1079
1080 template <class _Tp>
1081 struct __make_tuple_return_impl
1082 {
1083     typedef _Tp type;
1084 };
1085
1086 template <class _Tp>
1087 struct __make_tuple_return_impl<reference_wrapper<_Tp> >
1088 {
1089     typedef _Tp& type;
1090 };
1091
1092 template <class _Tp>
1093 struct __make_tuple_return
1094 {
1095     typedef typename __make_tuple_return_impl<typename decay<_Tp>::type>::type type;
1096 };
1097
1098 template <class... _Tp>
1099 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1100 tuple<typename __make_tuple_return<_Tp>::type...>
1101 make_tuple(_Tp&&... __t)
1102 {
1103     return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
1104 }
1105
1106 template <class... _Tp>
1107 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1108 tuple<_Tp&&...>
1109 forward_as_tuple(_Tp&&... __t) _NOEXCEPT
1110 {
1111     return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
1112 }
1113
1114 template <size_t _Ip>
1115 struct __tuple_equal
1116 {
1117     template <class _Tp, class _Up>
1118     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1119     bool operator()(const _Tp& __x, const _Up& __y)
1120     {
1121         return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y);
1122     }
1123 };
1124
1125 template <>
1126 struct __tuple_equal<0>
1127 {
1128     template <class _Tp, class _Up>
1129     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1130     bool operator()(const _Tp&, const _Up&)
1131     {
1132         return true;
1133     }
1134 };
1135
1136 template <class ..._Tp, class ..._Up>
1137 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1138 bool
1139 operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1140 {
1141     return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
1142 }
1143
1144 template <class ..._Tp, class ..._Up>
1145 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1146 bool
1147 operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1148 {
1149     return !(__x == __y);
1150 }
1151
1152 template <size_t _Ip>
1153 struct __tuple_less
1154 {
1155     template <class _Tp, class _Up>
1156     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1157     bool operator()(const _Tp& __x, const _Up& __y)
1158     {
1159         const size_t __idx = tuple_size<_Tp>::value - _Ip;
1160         if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y))
1161             return true;
1162         if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x))
1163             return false;
1164         return __tuple_less<_Ip-1>()(__x, __y);
1165     }
1166 };
1167
1168 template <>
1169 struct __tuple_less<0>
1170 {
1171     template <class _Tp, class _Up>
1172     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1173     bool operator()(const _Tp&, const _Up&)
1174     {
1175         return false;
1176     }
1177 };
1178
1179 template <class ..._Tp, class ..._Up>
1180 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1181 bool
1182 operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1183 {
1184     return __tuple_less<sizeof...(_Tp)>()(__x, __y);
1185 }
1186
1187 template <class ..._Tp, class ..._Up>
1188 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1189 bool
1190 operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1191 {
1192     return __y < __x;
1193 }
1194
1195 template <class ..._Tp, class ..._Up>
1196 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1197 bool
1198 operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1199 {
1200     return !(__x < __y);
1201 }
1202
1203 template <class ..._Tp, class ..._Up>
1204 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1205 bool
1206 operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1207 {
1208     return !(__y < __x);
1209 }
1210
1211 // tuple_cat
1212
1213 template <class _Tp, class _Up> struct __tuple_cat_type;
1214
1215 template <class ..._Ttypes, class ..._Utypes>
1216 struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
1217 {
1218     typedef tuple<_Ttypes..., _Utypes...> type;
1219 };
1220
1221 template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
1222 struct __tuple_cat_return_1
1223 {
1224 };
1225
1226 template <class ..._Types, class _Tuple0>
1227 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
1228 {
1229     typedef typename __tuple_cat_type<tuple<_Types...>,
1230             typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
1231                                                                            type;
1232 };
1233
1234 template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
1235 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
1236     : public __tuple_cat_return_1<
1237                  typename __tuple_cat_type<
1238                      tuple<_Types...>,
1239                      typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
1240                  >::type,
1241                  __tuple_like<typename remove_reference<_Tuple1>::type>::value,
1242                  _Tuple1, _Tuples...>
1243 {
1244 };
1245
1246 template <class ..._Tuples> struct __tuple_cat_return;
1247
1248 template <class _Tuple0, class ..._Tuples>
1249 struct __tuple_cat_return<_Tuple0, _Tuples...>
1250     : public __tuple_cat_return_1<tuple<>,
1251          __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
1252                                                                      _Tuples...>
1253 {
1254 };
1255
1256 template <>
1257 struct __tuple_cat_return<>
1258 {
1259     typedef tuple<> type;
1260 };
1261
1262 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1263 tuple<>
1264 tuple_cat()
1265 {
1266     return tuple<>();
1267 }
1268
1269 template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
1270 struct __tuple_cat_return_ref_imp;
1271
1272 template <class ..._Types, size_t ..._I0, class _Tuple0>
1273 struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
1274 {
1275     typedef typename remove_reference<_Tuple0>::type _T0;
1276     typedef tuple<_Types..., typename __apply_cv<_Tuple0,
1277                           typename tuple_element<_I0, _T0>::type>::type&&...> type;
1278 };
1279
1280 template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
1281 struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
1282                                   _Tuple0, _Tuple1, _Tuples...>
1283     : public __tuple_cat_return_ref_imp<
1284          tuple<_Types..., typename __apply_cv<_Tuple0,
1285                typename tuple_element<_I0,
1286                   typename remove_reference<_Tuple0>::type>::type>::type&&...>,
1287          typename __make_tuple_indices<tuple_size<typename
1288                                  remove_reference<_Tuple1>::type>::value>::type,
1289          _Tuple1, _Tuples...>
1290 {
1291 };
1292
1293 template <class _Tuple0, class ..._Tuples>
1294 struct __tuple_cat_return_ref
1295     : public __tuple_cat_return_ref_imp<tuple<>,
1296                typename __make_tuple_indices<
1297                         tuple_size<typename remove_reference<_Tuple0>::type>::value
1298                >::type, _Tuple0, _Tuples...>
1299 {
1300 };
1301
1302 template <class _Types, class _I0, class _J0>
1303 struct __tuple_cat;
1304
1305 template <class ..._Types, size_t ..._I0, size_t ..._J0>
1306 struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
1307 {
1308     template <class _Tuple0>
1309     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1310     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
1311     operator()(tuple<_Types...> __t, _Tuple0&& __t0)
1312     {
1313         return forward_as_tuple(_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
1314                                       _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
1315     }
1316
1317     template <class _Tuple0, class _Tuple1, class ..._Tuples>
1318     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1319     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
1320     operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
1321     {
1322         typedef typename remove_reference<_Tuple0>::type _T0;
1323         typedef typename remove_reference<_Tuple1>::type _T1;
1324         return __tuple_cat<
1325            tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
1326            typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
1327            typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
1328                            (forward_as_tuple(
1329                               _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
1330                               _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
1331                             ),
1332                             _VSTD::forward<_Tuple1>(__t1),
1333                             _VSTD::forward<_Tuples>(__tpls)...);
1334     }
1335 };
1336
1337 template <class _Tuple0, class... _Tuples>
1338 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1339 typename __tuple_cat_return<_Tuple0, _Tuples...>::type
1340 tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
1341 {
1342     typedef typename remove_reference<_Tuple0>::type _T0;
1343     return __tuple_cat<tuple<>, __tuple_indices<>,
1344                   typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
1345                   (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
1346                                             _VSTD::forward<_Tuples>(__tpls)...);
1347 }
1348
1349 template <class ..._Tp, class _Alloc>
1350 struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
1351     : true_type {};
1352
1353 template <class _T1, class _T2>
1354 template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
1355 inline _LIBCPP_INLINE_VISIBILITY
1356 pair<_T1, _T2>::pair(piecewise_construct_t,
1357                      tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
1358                      __tuple_indices<_I1...>, __tuple_indices<_I2...>)
1359     :  first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
1360       second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
1361 {
1362 }
1363
1364 #if _LIBCPP_STD_VER > 14
1365 template <class _Tp>
1366 _LIBCPP_INLINE_VAR constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
1367
1368 #define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
1369
1370 template <class _Fn, class _Tuple, size_t ..._Id>
1371 inline _LIBCPP_INLINE_VISIBILITY
1372 constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
1373                                             __tuple_indices<_Id...>)
1374 _LIBCPP_NOEXCEPT_RETURN(
1375     _VSTD::__invoke_constexpr(
1376         _VSTD::forward<_Fn>(__f),
1377         _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
1378 )
1379
1380 template <class _Fn, class _Tuple>
1381 inline _LIBCPP_INLINE_VISIBILITY
1382 constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
1383 _LIBCPP_NOEXCEPT_RETURN(
1384     _VSTD::__apply_tuple_impl(
1385         _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
1386         typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
1387 )
1388
1389 template <class _Tp, class _Tuple, size_t... _Idx>
1390 inline _LIBCPP_INLINE_VISIBILITY
1391 constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
1392 _LIBCPP_NOEXCEPT_RETURN(
1393     _Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
1394 )
1395
1396 template <class _Tp, class _Tuple>
1397 inline _LIBCPP_INLINE_VISIBILITY
1398 constexpr _Tp make_from_tuple(_Tuple&& __t)
1399 _LIBCPP_NOEXCEPT_RETURN(
1400     _VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
1401         typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
1402 )
1403
1404 #undef _LIBCPP_NOEXCEPT_RETURN
1405
1406 #endif // _LIBCPP_STD_VER > 14
1407
1408 #endif // !defined(_LIBCPP_CXX03_LANG)
1409
1410 _LIBCPP_END_NAMESPACE_STD
1411
1412 #endif  // _LIBCPP_TUPLE