include/__tuple

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is dual licensed under the MIT and the University of Illinois Open
   7 // Source Licenses. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP___TUPLE
  12 #define _LIBCPP___TUPLE
  13
  14 #include <__config>
  15 #include <cstddef>
  16 #include <type_traits>
  17
  18 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  19 #pragma GCC system_header
  20 #endif
  21
  22
  23 _LIBCPP_BEGIN_NAMESPACE_STD
  24
  25 template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size {};
  26
  27 template <class _Tp>
  28 class _LIBCPP_TYPE_VIS_ONLY tuple_size<const _Tp>
  29     : public tuple_size<_Tp> {};
  30
  31 template <class _Tp>
  32 class _LIBCPP_TYPE_VIS_ONLY tuple_size<volatile _Tp>
  33     : public tuple_size<_Tp> {};
  34
  35 template <class _Tp>
  36 class _LIBCPP_TYPE_VIS_ONLY tuple_size<const volatile _Tp>
  37     : public tuple_size<_Tp> {};
  38
  39 template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element;
  40
  41 template <size_t _Ip, class _Tp>
  42 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const _Tp>
  43 {
  44 public:
  45     typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
  46 };
  47
  48 template <size_t _Ip, class _Tp>
  49 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, volatile _Tp>
  50 {
  51 public:
  52     typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
  53 };
  54
  55 template <size_t _Ip, class _Tp>
  56 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const volatile _Tp>
  57 {
  58 public:
  59     typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
  60 };
  61
  62 template <class _Tp> struct __tuple_like : false_type {};
  63
  64 template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
  65 template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
  66 template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
  67
  68 // tuple specializations
  69
  70 #if !defined(_LIBCPP_HAS_NO_VARIADICS)
  71
  72 template <size_t...> struct __tuple_indices {};
  73
  74 template <class _IdxType, _IdxType... _Values>
  75 struct __integer_sequence {
  76   template <template <class _OIdxType, _OIdxType...> class _ToIndexSeq, class _ToIndexType>
  77   using __convert = _ToIndexSeq<_ToIndexType, _Values...>;
  78
  79   template <size_t _Sp>
  80   using __to_tuple_indices = __tuple_indices<(_Values + _Sp)...>;
  81 };
  82
  83 #if !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
  84 namespace __detail {
  85
  86 template<typename _Tp, size_t ..._Extra> struct __repeat;
  87 template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<__integer_sequence<_Tp, _Np...>, _Extra...> {
  88   typedef __integer_sequence<_Tp,
  89                            _Np...,
  90                            sizeof...(_Np) + _Np...,
  91                            2 * sizeof...(_Np) + _Np...,
  92                            3 * sizeof...(_Np) + _Np...,
  93                            4 * sizeof...(_Np) + _Np...,
  94                            5 * sizeof...(_Np) + _Np...,
  95                            6 * sizeof...(_Np) + _Np...,
  96                            7 * sizeof...(_Np) + _Np...,
  97                            _Extra...> type;
  98 };
  99
 100 template<size_t _Np> struct __parity;
 101 template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
 102
 103 template<> struct __make<0> { typedef __integer_sequence<size_t> type; };
 104 template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; };
 105 template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; };
 106 template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; };
 107 template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; };
 108 template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
 109 template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
 110 template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
 111
 112 template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
 113 template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
 114 template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
 115 template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
 116 template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
 117 template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
 118 template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
 119 template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
 120
 121 } // namespace detail
 122
 123 #endif  // !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
 124
 125 #if __has_builtin(__make_integer_seq)
 126 template <size_t _Ep, size_t _Sp>
 127 using __make_indices_imp =
 128     typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template
 129     __to_tuple_indices<_Sp>;
 130 #else
 131 template <size_t _Ep, size_t _Sp>
 132 using __make_indices_imp =
 133     typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
 134
 135 #endif
 136
 137 template <size_t _Ep, size_t _Sp = 0>
 138 struct __make_tuple_indices
 139 {
 140     static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
 141     typedef __make_indices_imp<_Ep, _Sp> type;
 142 };
 143
 144
 145 template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple;
 146
 147 template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
 148
 149 template <class ..._Tp>
 150 class _LIBCPP_TYPE_VIS_ONLY tuple_size<tuple<_Tp...> >
 151     : public integral_constant<size_t, sizeof...(_Tp)>
 152 {
 153 };
 154
 155 template <size_t _Ip, class ..._Tp>
 156 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 157 typename tuple_element<_Ip, tuple<_Tp...> >::type&
 158 get(tuple<_Tp...>&) _NOEXCEPT;
 159
 160 template <size_t _Ip, class ..._Tp>
 161 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 162 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
 163 get(const tuple<_Tp...>&) _NOEXCEPT;
 164
 165 template <size_t _Ip, class ..._Tp>
 166 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 167 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 168 get(tuple<_Tp...>&&) _NOEXCEPT;
 169
 170 template <size_t _Ip, class ..._Tp>
 171 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 172 const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 173 get(const tuple<_Tp...>&&) _NOEXCEPT;
 174 #endif
 175
 176 // pair specializations
 177
 178 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
 179
 180 template <size_t _Ip, class _T1, class _T2>
 181 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 182 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 183 get(pair<_T1, _T2>&) _NOEXCEPT;
 184
 185 template <size_t _Ip, class _T1, class _T2>
 186 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 187 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 188 get(const pair<_T1, _T2>&) _NOEXCEPT;
 189
 190 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
 191 template <size_t _Ip, class _T1, class _T2>
 192 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 193 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 194 get(pair<_T1, _T2>&&) _NOEXCEPT;
 195
 196 template <size_t _Ip, class _T1, class _T2>
 197 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 198 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 199 get(const pair<_T1, _T2>&&) _NOEXCEPT;
 200 #endif
 201
 202 // array specializations
 203
 204 template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array;
 205
 206 template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
 207
 208 template <size_t _Ip, class _Tp, size_t _Size>
 209 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 210 _Tp&
 211 get(array<_Tp, _Size>&) _NOEXCEPT;
 212
 213 template <size_t _Ip, class _Tp, size_t _Size>
 214 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 215 const _Tp&
 216 get(const array<_Tp, _Size>&) _NOEXCEPT;
 217
 218 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
 219 template <size_t _Ip, class _Tp, size_t _Size>
 220 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 221 _Tp&&
 222 get(array<_Tp, _Size>&&) _NOEXCEPT;
 223
 224 template <size_t _Ip, class _Tp, size_t _Size>
 225 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 226 const _Tp&&
 227 get(const array<_Tp, _Size>&&) _NOEXCEPT;
 228 #endif
 229
 230 #if !defined(_LIBCPP_HAS_NO_VARIADICS)
 231
 232
 233 // __tuple_types
 234
 235 template <class ..._Tp> struct __tuple_types {};
 236
 237 #if !__has_builtin(__type_pack_element)
 238
 239 namespace __indexer_detail {
 240
 241 template <size_t _Idx, class _Tp>
 242 struct __indexed { using type = _Tp; };
 243
 244 template <class _Types, class _Indexes> struct __indexer;
 245
 246 template <class ..._Types, size_t ..._Idx>
 247 struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>>
 248     : __indexed<_Idx, _Types>...
 249 {};
 250
 251 template <size_t _Idx, class _Tp>
 252 __indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
 253
 254 } // namespace __indexer_detail
 255
 256 template <size_t _Idx, class ..._Types>
 257 using __type_pack_element = typename decltype(
 258     __indexer_detail::__at_index<_Idx>(
 259         __indexer_detail::__indexer<
 260             __tuple_types<_Types...>,
 261             typename __make_tuple_indices<sizeof...(_Types)>::type
 262         >{})
 263   )::type;
 264 #endif
 265
 266 template <size_t _Ip, class ..._Types>
 267 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Types...>>
 268 {
 269 public:
 270     static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
 271     typedef __type_pack_element<_Ip, _Types...> type;
 272 };
 273
 274
 275 template <class ..._Tp>
 276 class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> >
 277     : public integral_constant<size_t, sizeof...(_Tp)>
 278 {
 279 };
 280
 281 template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
 282
 283 template <bool _ApplyLV, bool _ApplyConst, bool _ApplyVolatile>
 284 struct __apply_cv_mf;
 285 template <>
 286 struct __apply_cv_mf<false, false, false> {
 287   template <class _Tp> using __apply = _Tp;
 288 };
 289 template <>
 290 struct __apply_cv_mf<false, true, false> {
 291   template <class _Tp> using __apply = const _Tp;
 292 };
 293 template <>
 294 struct __apply_cv_mf<false, false, true> {
 295   template <class _Tp> using __apply = volatile _Tp;
 296 };
 297 template <>
 298 struct __apply_cv_mf<false, true, true> {
 299   template <class _Tp> using __apply = const volatile _Tp;
 300 };
 301 template <>
 302 struct __apply_cv_mf<true, false, false> {
 303   template <class _Tp> using __apply = _Tp&;
 304 };
 305 template <>
 306 struct __apply_cv_mf<true, true, false> {
 307   template <class _Tp> using __apply = const _Tp&;
 308 };
 309 template <>
 310 struct __apply_cv_mf<true, false, true> {
 311   template <class _Tp> using __apply = volatile _Tp&;
 312 };
 313 template <>
 314 struct __apply_cv_mf<true, true, true> {
 315   template <class _Tp> using __apply = const volatile _Tp&;
 316 };
 317 template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type>
 318 using __apply_cv_t = __apply_cv_mf<
 319     is_lvalue_reference<_Tp>::value,
 320     is_const<_RawTp>::value,
 321     is_volatile<_RawTp>::value>;
 322
 323 // __make_tuple_types
 324
 325 // __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a
 326 // __tuple_types<_Types...> using only those _Types in the range [_Sp, _Ep).
 327 // _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>.  If _Tuple is a
 328 // lvalue_reference type, then __tuple_types<_Types&...> is the result.
 329
 330 template <class _TupleTypes, class _TupleIndices>
 331 struct __make_tuple_types_flat;
 332
 333 template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx>
 334 struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>> {
 335   // Specialization for pair, tuple, and __tuple_types
 336   template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
 337   using __apply_quals = __tuple_types<
 338       typename _ApplyFn::template __apply<__type_pack_element<_Idx, _Types...>>...
 339     >;
 340 };
 341
 342 template <class _Vt, size_t _Np, size_t ..._Idx>
 343 struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
 344   template <size_t>
 345   using __value_type = _Vt;
 346   template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
 347   using __apply_quals = __tuple_types<
 348       typename _ApplyFn::template __apply<__value_type<_Idx>>...
 349     >;
 350 };
 351
 352 template <class _Tp, size_t _Ep = tuple_size<typename remove_reference<_Tp>::type>::value,
 353           size_t _Sp = 0,
 354           bool _SameSize = (_Ep == tuple_size<typename remove_reference<_Tp>::type>::value)>
 355 struct __make_tuple_types
 356 {
 357     static_assert(_Sp <= _Ep, "__make_tuple_types input error");
 358     using _RawTp = typename remove_cv<typename remove_reference<_Tp>::type>::type;
 359     using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
 360     using type = typename _Maker::template __apply_quals<_Tp>;
 361 };
 362
 363 template <class ..._Types, size_t _Ep>
 364 struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
 365   typedef __tuple_types<_Types...> type;
 366 };
 367
 368 template <class ..._Types, size_t _Ep>
 369 struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
 370   typedef __tuple_types<_Types...> type;
 371 };
 372
 373 template <bool ..._Preds>
 374 struct __all_dummy;
 375
 376 template <bool ..._Pred>
 377 using __all = is_same<__all_dummy<_Pred...>, __all_dummy<((void)_Pred, true)...>>;
 378
 379 struct __tuple_sfinae_base {
 380   template <template <class, class...> class _Trait,
 381             class ..._LArgs, class ..._RArgs>
 382   static auto __do_test(__tuple_types<_LArgs...>, __tuple_types<_RArgs...>)
 383     -> __all<typename enable_if<_Trait<_LArgs, _RArgs>::value, bool>::type{true}...>;
 384   template <template <class...> class>
 385   static auto __do_test(...) -> false_type;
 386
 387   template <class _FromArgs, class _ToArgs>
 388   using __constructible = decltype(__do_test<is_constructible>(_ToArgs{}, _FromArgs{}));
 389   template <class _FromArgs, class _ToArgs>
 390   using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{}));
 391   template <class _FromArgs, class _ToArgs>
 392   using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{}));
 393 };
 394
 395 // __tuple_convertible
 396
 397 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
 398                                 bool = __tuple_like<_Up>::value>
 399 struct __tuple_convertible
 400     : public false_type {};
 401
 402 template <class _Tp, class _Up>
 403 struct __tuple_convertible<_Tp, _Up, true, true>
 404     : public __tuple_sfinae_base::__convertible<
 405       typename __make_tuple_types<_Tp>::type
 406     , typename __make_tuple_types<_Up>::type
 407     >
 408 {};
 409
 410 // __tuple_constructible
 411
 412 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
 413                                 bool = __tuple_like<_Up>::value>
 414 struct __tuple_constructible
 415     : public false_type {};
 416
 417 template <class _Tp, class _Up>
 418 struct __tuple_constructible<_Tp, _Up, true, true>
 419     : public __tuple_sfinae_base::__constructible<
 420       typename __make_tuple_types<_Tp>::type
 421     , typename __make_tuple_types<_Up>::type
 422     >
 423 {};
 424
 425 // __tuple_assignable
 426
 427 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
 428                                 bool = __tuple_like<_Up>::value>
 429 struct __tuple_assignable
 430     : public false_type {};
 431
 432 template <class _Tp, class _Up>
 433 struct __tuple_assignable<_Tp, _Up, true, true>
 434     : public __tuple_sfinae_base::__assignable<
 435       typename __make_tuple_types<_Tp>::type
 436     , typename __make_tuple_types<_Up&>::type
 437     >
 438 {};
 439
 440
 441 template <size_t _Ip, class ..._Tp>
 442 class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, tuple<_Tp...> >
 443 {
 444 public:
 445     typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
 446 };
 447
 448 #if _LIBCPP_STD_VER > 11
 449 template <size_t _Ip, class ..._Tp>
 450 using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type;
 451 #endif
 452
 453 #endif  // _LIBCPP_HAS_NO_VARIADICS
 454
 455 #ifndef _LIBCPP_CXX03_LANG
 456 template <bool _IsTuple, class _SizeTrait, size_t _Expected>
 457 struct __tuple_like_with_size_imp : false_type {};
 458
 459 template <class _SizeTrait, size_t _Expected>
 460 struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected>
 461     : integral_constant<bool, _SizeTrait::value == _Expected> {};
 462
 463 template <class _Tuple, size_t _ExpectedSize,
 464           class _RawTuple = typename __uncvref<_Tuple>::type>
 465 using __tuple_like_with_size = __tuple_like_with_size_imp<
 466                                    __tuple_like<_RawTuple>::value,
 467                                    tuple_size<_RawTuple>, _ExpectedSize
 468                               >;
 469
 470 struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
 471     template <class ...>
 472     static constexpr bool __enable_default() { return false; }
 473     template <class ...>
 474     static constexpr bool __enable_explicit() { return false; }
 475     template <class ...>
 476     static constexpr bool __enable_implicit() { return false; }
 477     template <class ...>
 478     static constexpr bool __enable_assign() { return false; }
 479 };
 480 #endif
 481
 482 #if _LIBCPP_STD_VER > 14
 483
 484 template <bool _CanCopy, bool _CanMove>
 485 struct __sfinae_ctor_base {};
 486 template <>
 487 struct __sfinae_ctor_base<false, false> {
 488   __sfinae_ctor_base() = default;
 489   __sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
 490   __sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
 491   __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
 492   __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
 493 };
 494 template <>
 495 struct __sfinae_ctor_base<true, false> {
 496   __sfinae_ctor_base() = default;
 497   __sfinae_ctor_base(__sfinae_ctor_base const&) = default;
 498   __sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
 499   __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
 500   __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
 501 };
 502 template <>
 503 struct __sfinae_ctor_base<false, true> {
 504   __sfinae_ctor_base() = default;
 505   __sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
 506   __sfinae_ctor_base(__sfinae_ctor_base &&) = default;
 507   __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
 508   __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
 509 };
 510
 511 template <bool _CanCopy, bool _CanMove>
 512 struct __sfinae_assign_base {};
 513 template <>
 514 struct __sfinae_assign_base<false, false> {
 515   __sfinae_assign_base() = default;
 516   __sfinae_assign_base(__sfinae_assign_base const&) = default;
 517   __sfinae_assign_base(__sfinae_assign_base &&) = default;
 518   __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
 519   __sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
 520 };
 521 template <>
 522 struct __sfinae_assign_base<true, false> {
 523   __sfinae_assign_base() = default;
 524   __sfinae_assign_base(__sfinae_assign_base const&) = default;
 525   __sfinae_assign_base(__sfinae_assign_base &&) = default;
 526   __sfinae_assign_base& operator=(__sfinae_assign_base const&) = default;
 527   __sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
 528 };
 529 template <>
 530 struct __sfinae_assign_base<false, true> {
 531   __sfinae_assign_base() = default;
 532   __sfinae_assign_base(__sfinae_assign_base const&) = default;
 533   __sfinae_assign_base(__sfinae_assign_base &&) = default;
 534   __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
 535   __sfinae_assign_base& operator=(__sfinae_assign_base&&) = default;
 536 };
 537 #endif // _LIBCPP_STD_VER > 14
 538
 539 _LIBCPP_END_NAMESPACE_STD
 540
 541 #endif  // _LIBCPP___TUPLE