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