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