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 25template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size; 26 27template <class _Tp> 28class _LIBCPP_TYPE_VIS_ONLY tuple_size<const _Tp> 29 : public tuple_size<_Tp> {}; 30 31template <class _Tp> 32class _LIBCPP_TYPE_VIS_ONLY tuple_size<volatile _Tp> 33 : public tuple_size<_Tp> {}; 34 35template <class _Tp> 36class _LIBCPP_TYPE_VIS_ONLY tuple_size<const volatile _Tp> 37 : public tuple_size<_Tp> {}; 38 39template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element; 40 41template <size_t _Ip, class _Tp> 42class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const _Tp> 43{ 44public: 45 typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type; 46}; 47 48template <size_t _Ip, class _Tp> 49class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, volatile _Tp> 50{ 51public: 52 typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type; 53}; 54 55template <size_t _Ip, class _Tp> 56class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const volatile _Tp> 57{ 58public: 59 typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type; 60}; 61 62template <class _Tp> struct __tuple_like : false_type {}; 63 64template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {}; 65template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {}; 66template <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 72template <size_t...> struct __tuple_indices {}; 73 74template <class _IdxType, _IdxType... _Values> 75struct __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) 84namespace __detail { 85 86template<typename _Tp, size_t ..._Extra> struct __repeat; 87template<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 100template<size_t _Np> struct __parity; 101template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {}; 102 103template<> struct __make<0> { typedef __integer_sequence<size_t> type; }; 104template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; }; 105template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; }; 106template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; }; 107template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; }; 108template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; }; 109template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; }; 110template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; }; 111 112template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; }; 113template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; }; 114template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; }; 115template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; }; 116template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; }; 117template<> 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> {}; }; 118template<> 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> {}; }; 119template<> 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) 126template <size_t _Ep, size_t _Sp> 127using __make_indices_imp = 128 typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template 129 __to_tuple_indices<_Sp>; 130#else 131template <size_t _Ep, size_t _Sp> 132using __make_indices_imp = 133 typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>; 134 135#endif 136 137template <size_t _Ep, size_t _Sp = 0> 138struct __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 145template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple; 146 147template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {}; 148 149template <class ..._Tp> 150class _LIBCPP_TYPE_VIS_ONLY tuple_size<tuple<_Tp...> > 151 : public integral_constant<size_t, sizeof...(_Tp)> 152{ 153}; 154 155template <size_t _Ip, class ..._Tp> 156_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 157typename tuple_element<_Ip, tuple<_Tp...> >::type& 158get(tuple<_Tp...>&) _NOEXCEPT; 159 160template <size_t _Ip, class ..._Tp> 161_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 162const typename tuple_element<_Ip, tuple<_Tp...> >::type& 163get(const tuple<_Tp...>&) _NOEXCEPT; 164 165template <size_t _Ip, class ..._Tp> 166_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 167typename tuple_element<_Ip, tuple<_Tp...> >::type&& 168get(tuple<_Tp...>&&) _NOEXCEPT; 169 170template <size_t _Ip, class ..._Tp> 171_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 172const typename tuple_element<_Ip, tuple<_Tp...> >::type&& 173get(const tuple<_Tp...>&&) _NOEXCEPT; 174#endif 175 176// pair specializations 177 178template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {}; 179 180template <size_t _Ip, class _T1, class _T2> 181_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 182typename tuple_element<_Ip, pair<_T1, _T2> >::type& 183get(pair<_T1, _T2>&) _NOEXCEPT; 184 185template <size_t _Ip, class _T1, class _T2> 186_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 187const typename tuple_element<_Ip, pair<_T1, _T2> >::type& 188get(const pair<_T1, _T2>&) _NOEXCEPT; 189 190#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 191template <size_t _Ip, class _T1, class _T2> 192_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 193typename tuple_element<_Ip, pair<_T1, _T2> >::type&& 194get(pair<_T1, _T2>&&) _NOEXCEPT; 195 196template <size_t _Ip, class _T1, class _T2> 197_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 198const typename tuple_element<_Ip, pair<_T1, _T2> >::type&& 199get(const pair<_T1, _T2>&&) _NOEXCEPT; 200#endif 201 202// array specializations 203 204template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array; 205 206template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {}; 207 208template <size_t _Ip, class _Tp, size_t _Size> 209_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 210_Tp& 211get(array<_Tp, _Size>&) _NOEXCEPT; 212 213template <size_t _Ip, class _Tp, size_t _Size> 214_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 215const _Tp& 216get(const array<_Tp, _Size>&) _NOEXCEPT; 217 218#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 219template <size_t _Ip, class _Tp, size_t _Size> 220_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 221_Tp&& 222get(array<_Tp, _Size>&&) _NOEXCEPT; 223 224template <size_t _Ip, class _Tp, size_t _Size> 225_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 226const _Tp&& 227get(const array<_Tp, _Size>&&) _NOEXCEPT; 228#endif 229 230#if !defined(_LIBCPP_HAS_NO_VARIADICS) 231 232 233// __tuple_types 234 235template <class ..._Tp> struct __tuple_types {}; 236 237#if !__has_builtin(__type_pack_element) 238 239namespace __indexer_detail { 240 241template <size_t _Idx, class _Tp> 242struct __indexed { using type = _Tp; }; 243 244template <class _Types, class _Indexes> struct __indexer; 245 246template <class ..._Types, size_t ..._Idx> 247struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>> 248 : __indexed<_Idx, _Types>... 249{}; 250 251template <size_t _Idx, class _Tp> 252__indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&); 253 254} // namespace __indexer_detail 255 256template <size_t _Idx, class ..._Types> 257using __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 266template <size_t _Ip, class ..._Types> 267class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Types...>> 268{ 269public: 270 static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range"); 271 typedef __type_pack_element<_Ip, _Types...> type; 272}; 273 274 275template <class ..._Tp> 276class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> > 277 : public integral_constant<size_t, sizeof...(_Tp)> 278{ 279}; 280 281template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {}; 282 283template <bool _ApplyLV, bool _ApplyConst, bool _ApplyVolatile> 284struct __apply_cv_mf; 285template <> 286struct __apply_cv_mf<false, false, false> { 287 template <class _Tp> using __apply = _Tp; 288}; 289template <> 290struct __apply_cv_mf<false, true, false> { 291 template <class _Tp> using __apply = const _Tp; 292}; 293template <> 294struct __apply_cv_mf<false, false, true> { 295 template <class _Tp> using __apply = volatile _Tp; 296}; 297template <> 298struct __apply_cv_mf<false, true, true> { 299 template <class _Tp> using __apply = const volatile _Tp; 300}; 301template <> 302struct __apply_cv_mf<true, false, false> { 303 template <class _Tp> using __apply = _Tp&; 304}; 305template <> 306struct __apply_cv_mf<true, true, false> { 307 template <class _Tp> using __apply = const _Tp&; 308}; 309template <> 310struct __apply_cv_mf<true, false, true> { 311 template <class _Tp> using __apply = volatile _Tp&; 312}; 313template <> 314struct __apply_cv_mf<true, true, true> { 315 template <class _Tp> using __apply = const volatile _Tp&; 316}; 317template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type> 318using __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 330template <class _TupleTypes, class _TupleIndices> 331struct __make_tuple_types_flat; 332 333template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx> 334struct __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 342template <class _Vt, size_t _Np, size_t ..._Idx> 343struct __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 352template <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)> 355struct __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 363template <class ..._Types, size_t _Ep> 364struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> { 365 typedef __tuple_types<_Types...> type; 366}; 367 368template <class ..._Types, size_t _Ep> 369struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> { 370 typedef __tuple_types<_Types...> type; 371}; 372 373template <bool ..._Preds> 374struct __all_dummy; 375 376template <bool ..._Pred> 377using __all = is_same<__all_dummy<_Pred...>, __all_dummy<((void)_Pred, true)...>>; 378 379struct __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 397template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, 398 bool = __tuple_like<_Up>::value> 399struct __tuple_convertible 400 : public false_type {}; 401 402template <class _Tp, class _Up> 403struct __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 412template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, 413 bool = __tuple_like<_Up>::value> 414struct __tuple_constructible 415 : public false_type {}; 416 417template <class _Tp, class _Up> 418struct __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 427template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, 428 bool = __tuple_like<_Up>::value> 429struct __tuple_assignable 430 : public false_type {}; 431 432template <class _Tp, class _Up> 433struct __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 441template <size_t _Ip, class ..._Tp> 442class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, tuple<_Tp...> > 443{ 444public: 445 typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type; 446}; 447 448#if _LIBCPP_STD_VER > 11 449template <size_t _Ip, class ..._Tp> 450using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type; 451#endif 452 453#endif // _LIBCPP_HAS_NO_VARIADICS 454 455#ifndef _LIBCPP_CXX03_LANG 456template <bool _IsTuple, class _SizeTrait, size_t _Expected> 457struct __tuple_like_with_size_imp : false_type {}; 458 459template <class _SizeTrait, size_t _Expected> 460struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected> 461 : integral_constant<bool, _SizeTrait::value == _Expected> {}; 462 463template <class _Tuple, size_t _ExpectedSize, 464 class _RawTuple = typename __uncvref<_Tuple>::type> 465using __tuple_like_with_size = __tuple_like_with_size_imp< 466 __tuple_like<_RawTuple>::value, 467 tuple_size<_RawTuple>, _ExpectedSize 468 >; 469 470struct _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 484template <bool _CanCopy, bool _CanMove> 485struct __sfinae_ctor_base {}; 486template <> 487struct __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}; 494template <> 495struct __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}; 502template <> 503struct __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 511template <bool _CanCopy, bool _CanMove> 512struct __sfinae_assign_base {}; 513template <> 514struct __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}; 521template <> 522struct __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}; 529template <> 530struct __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 542