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