318 constexpr _Tuple_impl(
const _Tuple_impl&) =
default;
322 _Tuple_impl& operator=(
const _Tuple_impl&) =
delete;
324 _Tuple_impl(_Tuple_impl&&) =
default;
326 template<
typename... _UElements>
328 _Tuple_impl(
const _Tuple_impl<_Idx, _UElements...>& __in)
329 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
330 _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
333 template<
typename _UHead,
typename... _UTails>
335 _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
337 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
339 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
342#if __cpp_lib_ranges_zip
343 template<
typename... _UElements>
345 _Tuple_impl(_Tuple_impl<_Idx, _UElements...>& __in)
346 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
347 _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
350 template<
typename _UHead,
typename... _UTails>
352 _Tuple_impl(
const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
354 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
356 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
360#if __cpp_lib_tuple_like
361 template<
typename _UTuple,
size_t... _Is>
363 _Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<_Is...>)
368 template<
typename _Alloc>
370 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a)
371 : _Inherited(__tag, __a),
372 _Base(__tag, __use_alloc<_Head>(__a))
375 template<
typename _Alloc>
377 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
378 const _Head& __head,
const _Tail&... __tail)
379 : _Inherited(__tag, __a, __tail...),
380 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head)
383 template<
typename _Alloc,
typename _UHead,
typename... _UTail,
384 typename = __enable_if_t<
sizeof...(_Tail) ==
sizeof...(_UTail)>>
386 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
387 _UHead&& __head, _UTail&&... __tail)
388 : _Inherited(__tag, __a,
std::
forward<_UTail>(__tail)...),
389 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
393 template<
typename _Alloc>
395 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
396 const _Tuple_impl& __in)
397 : _Inherited(__tag, __a, _M_tail(__in)),
398 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in))
401 template<
typename _Alloc>
403 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
405 : _Inherited(__tag, __a,
std::
move(_M_tail(__in))),
406 _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
410 template<
typename _Alloc,
typename _UHead,
typename... _UTails>
412 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
413 const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
414 : _Inherited(__tag, __a,
415 _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
416 _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
417 _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
420 template<
typename _Alloc,
typename _UHead,
typename... _UTails>
422 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
423 _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
424 : _Inherited(__tag, __a,
std::
move
425 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
426 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
428 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
431#if __cpp_lib_ranges_zip
432 template<
typename _Alloc,
typename _UHead,
typename... _UTails>
434 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
435 _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
436 : _Inherited(__tag, __a,
437 _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
438 _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
439 _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
442 template<
typename _Alloc,
typename _UHead,
typename... _UTails>
444 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
445 const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
446 : _Inherited(__tag, __a,
std::
move
447 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
448 _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
450 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
454#if __cpp_lib_tuple_like
455 template<
typename _Alloc,
typename _UTuple,
size_t... _Is>
457 _Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag,
const _Alloc& __a,
458 _UTuple&& __u, index_sequence<_Is...>)
459 : _Tuple_impl(__tag, __a,
std::get<_Is>(
std::
forward<_UTuple>(__u))...)
463 template<
typename... _UElements>
466 _M_assign(
const _Tuple_impl<_Idx, _UElements...>& __in)
468 _M_head(*
this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
469 _M_tail(*this)._M_assign(
470 _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
473 template<
typename _UHead,
typename... _UTails>
476 _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
478 _M_head(*
this) = std::forward<_UHead>
479 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
480 _M_tail(*this)._M_assign(
481 std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
484#if __cpp_lib_ranges_zip
485 template<
typename... _UElements>
487 _M_assign(
const _Tuple_impl<_Idx, _UElements...>& __in)
const
489 _M_head(*
this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
490 _M_tail(*this)._M_assign(
491 _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
494 template<
typename _UHead,
typename... _UTails>
496 _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
const
498 _M_head(*
this) = std::forward<_UHead>
499 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
500 _M_tail(*this)._M_assign(
501 std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
505#if __cpp_lib_tuple_like
506 template<
typename _UTuple>
508 _M_assign(__tuple_like_tag_t __tag, _UTuple&& __u)
510 _M_head(*
this) = std::get<_Idx>(std::forward<_UTuple>(__u));
511 _M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u));
514 template<
typename _UTuple>
516 _M_assign(__tuple_like_tag_t __tag, _UTuple&& __u)
const
518 _M_head(*
this) = std::get<_Idx>(std::forward<_UTuple>(__u));
519 _M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u));
526 _M_swap(_Tuple_impl& __in)
529 swap(_M_head(*
this), _M_head(__in));
530 _Inherited::_M_swap(_M_tail(__in));
533#if __cpp_lib_ranges_zip
535 _M_swap(
const _Tuple_impl& __in)
const
538 swap(_M_head(*
this), _M_head(__in));
539 _Inherited::_M_swap(_M_tail(__in));
545 template<
size_t _Idx,
typename _Head>
546 struct _Tuple_impl<_Idx, _Head>
547 :
private _Head_base<_Idx, _Head>
549 template<size_t,
typename...>
friend struct _Tuple_impl;
551 typedef _Head_base<_Idx, _Head> _Base;
553 static constexpr _Head&
554 _M_head(_Tuple_impl& __t)
noexcept {
return _Base::_M_head(__t); }
556 static constexpr const _Head&
557 _M_head(
const _Tuple_impl& __t)
noexcept {
return _Base::_M_head(__t); }
564 _Tuple_impl(
const _Head& __head)
568 template<
typename _UHead>
570 _Tuple_impl(_UHead&& __head)
574 constexpr _Tuple_impl(
const _Tuple_impl&) =
default;
578 _Tuple_impl& operator=(
const _Tuple_impl&) =
delete;
580#if _GLIBCXX_INLINE_VERSION
581 _Tuple_impl(_Tuple_impl&&) =
default;
584 _Tuple_impl(_Tuple_impl&& __in)
585 noexcept(is_nothrow_move_constructible<_Head>::value)
586 : _Base(static_cast<_Base&&>(__in))
590 template<
typename _UHead>
592 _Tuple_impl(
const _Tuple_impl<_Idx, _UHead>& __in)
593 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
596 template<
typename _UHead>
598 _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
599 : _Base(
std::
forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
602#if __cpp_lib_ranges_zip
603 template<
typename _UHead>
605 _Tuple_impl(_Tuple_impl<_Idx, _UHead>& __in)
606 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
609 template<
typename _UHead>
611 _Tuple_impl(
const _Tuple_impl<_Idx, _UHead>&& __in)
612 : _Base(
std::
forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
616#if __cpp_lib_tuple_like
617 template<
typename _UTuple>
619 _Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<0>)
624 template<
typename _Alloc>
626 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a)
627 : _Base(__tag, __use_alloc<_Head>(__a))
630 template<
typename _Alloc>
632 _Tuple_impl(allocator_arg_t,
const _Alloc& __a,
634 : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head)
637 template<
typename _Alloc,
typename _UHead>
639 _Tuple_impl(allocator_arg_t,
const _Alloc& __a,
641 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
645 template<
typename _Alloc>
647 _Tuple_impl(allocator_arg_t,
const _Alloc& __a,
648 const _Tuple_impl& __in)
649 : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in))
652 template<
typename _Alloc>
654 _Tuple_impl(allocator_arg_t,
const _Alloc& __a,
656 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
660 template<
typename _Alloc,
typename _UHead>
662 _Tuple_impl(allocator_arg_t,
const _Alloc& __a,
663 const _Tuple_impl<_Idx, _UHead>& __in)
664 : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
665 _Tuple_impl<_Idx, _UHead>::_M_head(__in))
668 template<
typename _Alloc,
typename _UHead>
670 _Tuple_impl(allocator_arg_t,
const _Alloc& __a,
671 _Tuple_impl<_Idx, _UHead>&& __in)
672 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
673 std::
forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
676#if __cpp_lib_ranges_zip
677 template<
typename _Alloc,
typename _UHead>
679 _Tuple_impl(allocator_arg_t,
const _Alloc& __a,
680 _Tuple_impl<_Idx, _UHead>& __in)
681 : _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
682 _Tuple_impl<_Idx, _UHead>::_M_head(__in))
685 template<
typename _Alloc,
typename _UHead>
687 _Tuple_impl(allocator_arg_t,
const _Alloc& __a,
688 const _Tuple_impl<_Idx, _UHead>&& __in)
689 : _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
690 std::
forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
694#if __cpp_lib_tuple_like
695 template<
typename _Alloc,
typename _UTuple>
697 _Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag,
const _Alloc& __a,
698 _UTuple&& __u, index_sequence<0>)
699 : _Tuple_impl(__tag, __a,
std::get<0>(
std::
forward<_UTuple>(__u)))
703 template<
typename _UHead>
706 _M_assign(
const _Tuple_impl<_Idx, _UHead>& __in)
708 _M_head(*
this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
711 template<
typename _UHead>
714 _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
717 = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
720#if __cpp_lib_ranges_zip
721 template<
typename _UHead>
723 _M_assign(
const _Tuple_impl<_Idx, _UHead>& __in)
const
725 _M_head(*
this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
728 template<
typename _UHead>
730 _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
const
733 = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
737#if __cpp_lib_tuple_like
738 template<
typename _UTuple>
740 _M_assign(__tuple_like_tag_t, _UTuple&& __u)
741 { _M_head(*
this) = std::get<_Idx>(std::forward<_UTuple>(__u)); }
743 template<
typename _UTuple>
745 _M_assign(__tuple_like_tag_t, _UTuple&& __u)
const
746 { _M_head(*
this) = std::get<_Idx>(std::forward<_UTuple>(__u)); }
752 _M_swap(_Tuple_impl& __in)
755 swap(_M_head(*
this), _M_head(__in));
758#if __cpp_lib_ranges_zip
760 _M_swap(
const _Tuple_impl& __in)
const
763 swap(_M_head(*
this), _M_head(__in));
770 template<bool,
typename... _Types>
771 struct _TupleConstraints
773 template<
typename... _UTypes>
774 using __constructible = __and_<is_constructible<_Types, _UTypes>...>;
776 template<
typename... _UTypes>
777 using __convertible = __and_<is_convertible<_UTypes, _Types>...>;
782 template<
typename... _UTypes>
783 static constexpr bool __is_implicitly_constructible()
785 return __and_<__constructible<_UTypes...>,
786 __convertible<_UTypes...>
793 template<
typename... _UTypes>
794 static constexpr bool __is_explicitly_constructible()
796 return __and_<__constructible<_UTypes...>,
797 __not_<__convertible<_UTypes...>>
801 static constexpr bool __is_implicitly_default_constructible()
803 return __and_<std::__is_implicitly_default_constructible<_Types>...
807 static constexpr bool __is_explicitly_default_constructible()
809 return __and_<is_default_constructible<_Types>...,
811 std::__is_implicitly_default_constructible<_Types>...>
818 template<
typename... _Types>
819 struct _TupleConstraints<false, _Types...>
821 template<
typename... _UTypes>
822 static constexpr bool __is_implicitly_constructible()
825 template<
typename... _UTypes>
826 static constexpr bool __is_explicitly_constructible()
832 template<
typename... _Elements>
833 class tuple :
public _Tuple_impl<0, _Elements...>
835 using _Inherited = _Tuple_impl<0, _Elements...>;
837#if __cpp_concepts && __cpp_consteval && __cpp_conditional_explicit
838 template<
typename... _UTypes>
839 static consteval bool
842 if constexpr (
sizeof...(_UTypes) ==
sizeof...(_Elements))
848 template<
typename... _UTypes>
849 static consteval bool
850 __nothrow_constructible()
852 if constexpr (
sizeof...(_UTypes) ==
sizeof...(_Elements))
858 template<
typename... _UTypes>
859 static consteval bool
862 if constexpr (
sizeof...(_UTypes) ==
sizeof...(_Elements))
870 template<
typename... _UTypes>
871 static consteval bool
872 __disambiguating_constraint()
874 if constexpr (
sizeof...(_Elements) !=
sizeof...(_UTypes))
876 else if constexpr (
sizeof...(_Elements) == 1)
878 using _U0 =
typename _Nth_type<0, _UTypes...>::type;
879 return !is_same_v<remove_cvref_t<_U0>,
tuple>;
881 else if constexpr (
sizeof...(_Elements) < 4)
883 using _U0 =
typename _Nth_type<0, _UTypes...>::type;
884 if constexpr (!is_same_v<remove_cvref_t<_U0>, allocator_arg_t>)
888 using _T0 =
typename _Nth_type<0, _Elements...>::type;
889 return is_same_v<remove_cvref_t<_T0>, allocator_arg_t>;
898 template<
typename _Tuple>
899 static consteval bool
902 if constexpr (
sizeof...(_Elements) != 1)
904 else if constexpr (is_same_v<remove_cvref_t<_Tuple>,
tuple>)
908 using _Tp =
typename _Nth_type<0, _Elements...>::type;
909 if constexpr (is_convertible_v<_Tuple, _Tp>)
911 else if constexpr (is_constructible_v<_Tp, _Tuple>)
917 template<
typename... _Up>
918 static consteval bool
921#if __has_builtin(__reference_constructs_from_temporary)
922 return (__reference_constructs_from_temporary(_Elements, _Up&&)
929#if __cpp_lib_tuple_like
932 template<
typename _UTuple>
933 static consteval bool
934 __dangles_from_tuple_like()
937 return __dangles<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
941 template<
typename _UTuple>
942 static consteval bool
943 __constructible_from_tuple_like()
946 return __constructible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
950 template<
typename _UTuple>
951 static consteval bool
952 __convertible_from_tuple_like()
955 return __convertible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
962 explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
964 noexcept((is_nothrow_default_constructible_v<_Elements> && ...))
965 requires (is_default_constructible_v<_Elements> && ...)
970 template<
typename =
void>
971 constexpr explicit(!__convertible<
const _Elements&...>())
972 tuple(
const _Elements&... __elements)
973 noexcept(__nothrow_constructible<
const _Elements&...>())
974 requires (__constructible<
const _Elements&...>())
975 : _Inherited(__elements...)
978 template<
typename... _UTypes>
979 requires (__disambiguating_constraint<_UTypes...>())
980 && (__constructible<_UTypes...>())
981 && (!__dangles<_UTypes...>())
982 constexpr explicit(!__convertible<_UTypes...>())
983 tuple(_UTypes&&... __u)
984 noexcept(__nothrow_constructible<_UTypes...>())
985 : _Inherited(std::forward<_UTypes>(__u)...)
988 template<
typename... _UTypes>
989 requires (__disambiguating_constraint<_UTypes...>())
990 && (__constructible<_UTypes...>())
991 && (__dangles<_UTypes...>())
992 tuple(_UTypes&&...) =
delete;
998 template<
typename... _UTypes>
999 requires (__constructible<
const _UTypes&...>())
1000 && (!__use_other_ctor<
const tuple<_UTypes...>&>())
1001 && (!__dangles<
const _UTypes&...>())
1002 constexpr explicit(!__convertible<
const _UTypes&...>())
1004 noexcept(__nothrow_constructible<
const _UTypes&...>())
1005 : _Inherited(
static_cast<const _Tuple_impl<0, _UTypes...
>&>(__u))
1008 template<
typename... _UTypes>
1009 requires (__constructible<
const _UTypes&...>())
1010 && (!__use_other_ctor<
const tuple<_UTypes...>&>())
1011 && (__dangles<
const _UTypes&...>())
1014 template<
typename... _UTypes>
1015 requires (__constructible<_UTypes...>())
1016 && (!__use_other_ctor<
tuple<_UTypes...>>())
1017 && (!__dangles<_UTypes...>())
1018 constexpr explicit(!__convertible<_UTypes...>())
1020 noexcept(__nothrow_constructible<_UTypes...>())
1021 : _Inherited(
static_cast<_Tuple_impl<0, _UTypes...
>&&>(__u))
1024 template<
typename... _UTypes>
1025 requires (__constructible<_UTypes...>())
1026 && (!__use_other_ctor<
tuple<_UTypes...>>())
1027 && (__dangles<_UTypes...>())
1030#if __cpp_lib_ranges_zip
1031 template<
typename... _UTypes>
1032 requires (__constructible<_UTypes&...>())
1033 && (!__use_other_ctor<
tuple<_UTypes...>&>())
1034 && (!__dangles<_UTypes&...>())
1035 constexpr explicit(!__convertible<_UTypes&...>())
1037 noexcept(__nothrow_constructible<_UTypes&...>())
1038 : _Inherited(
static_cast<_Tuple_impl<0, _UTypes...
>&>(__u))
1041 template<
typename... _UTypes>
1042 requires (__constructible<_UTypes&...>())
1043 && (!__use_other_ctor<
tuple<_UTypes...>&>())
1044 && (__dangles<_UTypes&...>())
1047 template<
typename... _UTypes>
1048 requires (__constructible<
const _UTypes...>())
1049 && (!__use_other_ctor<
const tuple<_UTypes...>>())
1050 && (!__dangles<
const _UTypes...>())
1051 constexpr explicit(!__convertible<
const _UTypes...>())
1053 noexcept(__nothrow_constructible<
const _UTypes...>())
1054 : _Inherited(
static_cast<const _Tuple_impl<0, _UTypes...
>&&>(__u))
1057 template<
typename... _UTypes>
1058 requires (__constructible<
const _UTypes...>())
1059 && (!__use_other_ctor<
const tuple<_UTypes...>>())
1060 && (__dangles<
const _UTypes...>())
1064 template<
typename _U1,
typename _U2>
1065 requires (
sizeof...(_Elements) == 2)
1066 && (__constructible<const _U1&, const _U2&>())
1067 && (!__dangles<const _U1&, const _U2&>())
1068 constexpr explicit(!__convertible<const _U1&, const _U2&>())
1070 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
1071 : _Inherited(__u.first, __u.second)
1074 template<
typename _U1,
typename _U2>
1075 requires (
sizeof...(_Elements) == 2)
1076 && (__constructible<const _U1&, const _U2&>())
1077 && (__dangles<const _U1&, const _U2&>())
1080 template<
typename _U1,
typename _U2>
1081 requires (
sizeof...(_Elements) == 2)
1082 && (__constructible<_U1, _U2>())
1083 && (!__dangles<_U1, _U2>())
1084 constexpr explicit(!__convertible<_U1, _U2>())
1086 noexcept(__nothrow_constructible<_U1, _U2>())
1087 : _Inherited(std::forward<_U1>(__u.first),
1088 std::forward<_U2>(__u.second))
1091 template<
typename _U1,
typename _U2>
1092 requires (
sizeof...(_Elements) == 2)
1093 && (__constructible<_U1, _U2>())
1094 && (__dangles<_U1, _U2>())
1097#if __cpp_lib_ranges_zip
1098 template<
typename _U1,
typename _U2>
1099 requires (
sizeof...(_Elements) == 2)
1100 && (__constructible<_U1&, _U2&>())
1101 && (!__dangles<_U1&, _U2&>())
1102 constexpr explicit(!__convertible<_U1&, _U2&>())
1104 noexcept(__nothrow_constructible<_U1&, _U2&>())
1105 : _Inherited(__u.first, __u.second)
1108 template<
typename _U1,
typename _U2>
1109 requires (
sizeof...(_Elements) == 2)
1110 && (__constructible<_U1&, _U2&>())
1111 && (__dangles<_U1&, _U2&>())
1114 template<
typename _U1,
typename _U2>
1115 requires (
sizeof...(_Elements) == 2)
1116 && (__constructible<const _U1, const _U2>())
1117 && (!__dangles<const _U1, const _U2>())
1118 constexpr explicit(!__convertible<const _U1, const _U2>())
1120 noexcept(__nothrow_constructible<const _U1, const _U2>())
1121 : _Inherited(std::forward<const _U1>(__u.first),
1122 std::forward<const _U2>(__u.second))
1125 template<
typename _U1,
typename _U2>
1126 requires (
sizeof...(_Elements) == 2)
1127 && (__constructible<const _U1, const _U2>())
1128 && (__dangles<const _U1, const _U2>())
1132#if __cpp_lib_tuple_like
1133 template<__eligible_tuple_like<tuple> _UTuple>
1134 requires (__constructible_from_tuple_like<_UTuple>())
1135 && (!__use_other_ctor<_UTuple>())
1136 && (!__dangles_from_tuple_like<_UTuple>())
1137 constexpr explicit(!__convertible_from_tuple_like<_UTuple>())
1138 tuple(_UTuple&& __u)
1139 : _Inherited(__tuple_like_tag_t{},
1140 std::forward<_UTuple>(__u),
1144 template<__eligible_tuple_like<tuple> _UTuple>
1145 requires (__constructible_from_tuple_like<_UTuple>())
1146 && (!__use_other_ctor<_UTuple>())
1147 && (__dangles_from_tuple_like<_UTuple>())
1148 tuple(_UTuple&&) =
delete;
1153 template<
typename _Alloc>
1155 explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
1156 tuple(allocator_arg_t __tag,
const _Alloc& __a)
1157 requires (is_default_constructible_v<_Elements> && ...)
1158 : _Inherited(__tag, __a)
1161 template<
typename _Alloc>
1162 constexpr explicit(!__convertible<
const _Elements&...>())
1163 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1164 const _Elements&... __elements)
1165 requires (__constructible<
const _Elements&...>())
1166 : _Inherited(__tag, __a, __elements...)
1169 template<
typename _Alloc,
typename... _UTypes>
1170 requires (__disambiguating_constraint<_UTypes...>())
1171 && (__constructible<_UTypes...>())
1172 && (!__dangles<_UTypes...>())
1173 constexpr explicit(!__convertible<_UTypes...>())
1174 tuple(allocator_arg_t __tag,
const _Alloc& __a, _UTypes&&... __u)
1175 : _Inherited(__tag, __a, std::forward<_UTypes>(__u)...)
1178 template<
typename _Alloc,
typename... _UTypes>
1179 requires (__disambiguating_constraint<_UTypes...>())
1180 && (__constructible<_UTypes...>())
1181 && (__dangles<_UTypes...>())
1182 tuple(allocator_arg_t,
const _Alloc&, _UTypes&&...) =
delete;
1184 template<
typename _Alloc>
1186 tuple(allocator_arg_t __tag,
const _Alloc& __a,
const tuple& __u)
1187 : _Inherited(__tag, __a,
static_cast<const _Inherited&
>(__u))
1190 template<
typename _Alloc>
1191 requires (__constructible<_Elements...>())
1193 tuple(allocator_arg_t __tag,
const _Alloc& __a,
tuple&& __u)
1194 : _Inherited(__tag, __a,
static_cast<_Inherited&&
>(__u))
1197 template<
typename _Alloc,
typename... _UTypes>
1198 requires (__constructible<
const _UTypes&...>())
1199 && (!__use_other_ctor<
const tuple<_UTypes...>&>())
1200 && (!__dangles<
const _UTypes&...>())
1201 constexpr explicit(!__convertible<
const _UTypes&...>())
1202 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1204 : _Inherited(__tag, __a,
1205 static_cast<const _Tuple_impl<0, _UTypes...
>&>(__u))
1208 template<
typename _Alloc,
typename... _UTypes>
1209 requires (__constructible<
const _UTypes&...>())
1210 && (!__use_other_ctor<
const tuple<_UTypes...>&>())
1211 && (__dangles<
const _UTypes&...>())
1214 template<
typename _Alloc,
typename... _UTypes>
1215 requires (__constructible<_UTypes...>())
1216 && (!__use_other_ctor<
tuple<_UTypes...>>())
1217 && (!__dangles<_UTypes...>())
1218 constexpr explicit(!__use_other_ctor<
tuple<_UTypes...>>())
1220 : _Inherited(__tag, __a,
static_cast<_Tuple_impl<0, _UTypes...
>&&>(__u))
1223 template<
typename _Alloc,
typename... _UTypes>
1224 requires (__constructible<_UTypes...>())
1225 && (!__use_other_ctor<
tuple<_UTypes...>>())
1226 && (__dangles<_UTypes...>())
1229#if __cpp_lib_ranges_zip
1230 template<
typename _Alloc,
typename... _UTypes>
1231 requires (__constructible<_UTypes&...>())
1232 && (!__use_other_ctor<
tuple<_UTypes...>&>())
1233 && (!__dangles<_UTypes&...>())
1234 constexpr explicit(!__convertible<_UTypes&...>())
1236 : _Inherited(__tag, __a,
static_cast<_Tuple_impl<0, _UTypes...
>&>(__u))
1239 template<
typename _Alloc,
typename... _UTypes>
1240 requires (__constructible<_UTypes&...>())
1241 && (!__use_other_ctor<
tuple<_UTypes...>&>())
1242 && (__dangles<_UTypes&...>())
1245 template<
typename _Alloc,
typename... _UTypes>
1246 requires (__constructible<
const _UTypes...>())
1247 && (!__use_other_ctor<
const tuple<_UTypes...>>())
1248 && (!__dangles<
const _UTypes...>())
1249 constexpr explicit(!__convertible<
const _UTypes...>())
1250 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1252 : _Inherited(__tag, __a,
1253 static_cast<const _Tuple_impl<0, _UTypes...
>&&>(__u))
1256 template<
typename _Alloc,
typename... _UTypes>
1257 requires (__constructible<
const _UTypes...>())
1258 && (!__use_other_ctor<
const tuple<_UTypes...>>())
1259 && (__dangles<
const _UTypes...>())
1263 template<
typename _Alloc,
typename _U1,
typename _U2>
1264 requires (
sizeof...(_Elements) == 2)
1265 && (__constructible<const _U1&, const _U2&>())
1266 && (!__dangles<const _U1&, const _U2&>())
1267 constexpr explicit(!__convertible<const _U1&, const _U2&>())
1268 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1270 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
1271 : _Inherited(__tag, __a, __u.first, __u.second)
1274 template<
typename _Alloc,
typename _U1,
typename _U2>
1275 requires (
sizeof...(_Elements) == 2)
1276 && (__constructible<const _U1&, const _U2&>())
1277 && (__dangles<const _U1&, const _U2&>())
1280 template<
typename _Alloc,
typename _U1,
typename _U2>
1281 requires (
sizeof...(_Elements) == 2)
1282 && (__constructible<_U1, _U2>())
1283 && (!__dangles<_U1, _U2>())
1284 constexpr explicit(!__convertible<_U1, _U2>())
1286 noexcept(__nothrow_constructible<_U1, _U2>())
1290 template<
typename _Alloc,
typename _U1,
typename _U2>
1291 requires (
sizeof...(_Elements) == 2)
1292 && (__constructible<_U1, _U2>())
1293 && (__dangles<_U1, _U2>())
1296#if __cpp_lib_ranges_zip
1297 template<
typename _Alloc,
typename _U1,
typename _U2>
1298 requires (
sizeof...(_Elements) == 2)
1299 && (__constructible<_U1&, _U2&>())
1300 && (!__dangles<_U1&, _U2&>())
1301 constexpr explicit(!__convertible<_U1&, _U2&>())
1303 noexcept(__nothrow_constructible<_U1&, _U2&>())
1304 : _Inherited(__tag, __a, __u.first, __u.second)
1307 template<
typename _Alloc,
typename _U1,
typename _U2>
1308 requires (
sizeof...(_Elements) == 2)
1309 && (__constructible<_U1&, _U2&>())
1310 && (__dangles<_U1&, _U2&>())
1313 template<
typename _Alloc,
typename _U1,
typename _U2>
1314 requires (
sizeof...(_Elements) == 2)
1315 && (__constructible<const _U1, const _U2>())
1316 && (!__dangles<const _U1, const _U2>())
1317 constexpr explicit(!__convertible<const _U1, const _U2>())
1318 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1320 noexcept(__nothrow_constructible<const _U1, const _U2>())
1324 template<
typename _Alloc,
typename _U1,
typename _U2>
1325 requires (
sizeof...(_Elements) == 2)
1326 && (__constructible<const _U1, const _U2>())
1327 && (__dangles<const _U1, const _U2>())
1331#if __cpp_lib_tuple_like
1332 template<
typename _Alloc, __eligible_tuple_like<tuple> _UTuple>
1333 requires (__constructible_from_tuple_like<_UTuple>())
1334 && (!__use_other_ctor<_UTuple>())
1335 && (!__dangles_from_tuple_like<_UTuple>())
1336 constexpr explicit(!__convertible_from_tuple_like<_UTuple>())
1337 tuple(allocator_arg_t __tag,
const _Alloc& __a, _UTuple&& __u)
1338 : _Inherited(__tuple_like_tag_t{},
1339 __tag, __a, std::forward<_UTuple>(__u),
1343 template<
typename _Alloc, __eligible_tuple_like<tuple> _UTuple>
1344 requires (__constructible_from_tuple_like<_UTuple>())
1345 && (!__use_other_ctor<_UTuple>())
1346 && (__dangles_from_tuple_like<_UTuple>())
1347 tuple(allocator_arg_t,
const _Alloc&, _UTuple&&) =
delete;
1352 template<
bool _Cond>
1353 using _TCC = _TupleConstraints<_Cond, _Elements...>;
1356 template<
bool _Dummy>
1357 using _ImplicitDefaultCtor = __enable_if_t<
1358 _TCC<_Dummy>::__is_implicitly_default_constructible(),
1362 template<
bool _Dummy>
1363 using _ExplicitDefaultCtor = __enable_if_t<
1364 _TCC<_Dummy>::__is_explicitly_default_constructible(),
1368 template<
bool _Cond,
typename... _Args>
1369 using _ImplicitCtor = __enable_if_t<
1370 _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(),
1374 template<
bool _Cond,
typename... _Args>
1375 using _ExplicitCtor = __enable_if_t<
1376 _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(),
1380 template<
typename... _UElements>
1381 static constexpr bool __nothrow_constructible()
1384 __and_<is_nothrow_constructible<_Elements, _UElements>...>::value;
1388 template<
typename _Up>
1389 static constexpr bool __valid_args()
1391 return sizeof...(_Elements) == 1
1396 template<
typename,
typename,
typename... _Tail>
1397 static constexpr bool __valid_args()
1398 {
return (
sizeof...(_Tail) + 2) ==
sizeof...(_Elements); }
1409 template<
typename _Tuple,
typename =
tuple,
1410 typename = __remove_cvref_t<_Tuple>>
1411 struct _UseOtherCtor
1416 template<
typename _Tuple,
typename _Tp,
typename _Up>
1417 struct _UseOtherCtor<_Tuple,
tuple<_Tp>,
tuple<_Up>>
1418 : __or_<is_convertible<_Tuple, _Tp>, is_constructible<_Tp, _Tuple>>::type
1422 template<
typename _Tuple,
typename _Tp>
1423 struct _UseOtherCtor<_Tuple,
tuple<_Tp>,
tuple<_Tp>>
1430 template<
typename _Tuple>
1431 static constexpr bool __use_other_ctor()
1432 {
return _UseOtherCtor<_Tuple>::value; }
1435#undef __glibcxx_no_dangling_refs
1436#if __has_builtin(__reference_constructs_from_temporary) \
1437 && defined _GLIBCXX_DEBUG
1439# if __cpp_fold_expressions
1440# define __glibcxx_dangling_refs(U) \
1441 (__reference_constructs_from_temporary(_Elements, U) || ...)
1443# define __glibcxx_dangling_refs(U) \
1444 __or_<__bool_constant<__reference_constructs_from_temporary(_Elements, U) \
1447# define __glibcxx_no_dangling_refs(U) \
1448 static_assert(!__glibcxx_dangling_refs(U), \
1449 "std::tuple constructor creates a dangling reference")
1451# define __glibcxx_no_dangling_refs(U)
1456 template<
typename _Dummy = void,
1457 _ImplicitDefaultCtor<is_void<_Dummy>::value> =
true>
1460 noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
1463 template<
typename _Dummy = void,
1464 _ExplicitDefaultCtor<is_void<_Dummy>::value> =
false>
1467 noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
1470 template<
bool _NotEmpty = (
sizeof...(_Elements) >= 1),
1471 _ImplicitCtor<_NotEmpty,
const _Elements&...> =
true>
1473 tuple(
const _Elements&... __elements)
1474 noexcept(__nothrow_constructible<
const _Elements&...>())
1475 : _Inherited(__elements...) { }
1477 template<
bool _NotEmpty = (
sizeof...(_Elements) >= 1),
1478 _ExplicitCtor<_NotEmpty,
const _Elements&...> =
false>
1480 tuple(
const _Elements&... __elements)
1481 noexcept(__nothrow_constructible<
const _Elements&...>())
1482 : _Inherited(__elements...) { }
1484 template<
typename... _UElements,
1485 bool _Valid = __valid_args<_UElements...>(),
1486 _ImplicitCtor<_Valid, _UElements...> =
true>
1488 tuple(_UElements&&... __elements)
1489 noexcept(__nothrow_constructible<_UElements...>())
1490 : _Inherited(std::forward<_UElements>(__elements)...)
1491 { __glibcxx_no_dangling_refs(_UElements&&); }
1493 template<
typename... _UElements,
1494 bool _Valid = __valid_args<_UElements...>(),
1495 _ExplicitCtor<_Valid, _UElements...> =
false>
1497 tuple(_UElements&&... __elements)
1498 noexcept(__nothrow_constructible<_UElements...>())
1499 : _Inherited(std::forward<_UElements>(__elements)...)
1500 { __glibcxx_no_dangling_refs(_UElements&&); }
1506 template<
typename... _UElements,
1507 bool _Valid = (
sizeof...(_Elements) ==
sizeof...(_UElements))
1509 _ImplicitCtor<_Valid,
const _UElements&...> =
true>
1512 noexcept(__nothrow_constructible<
const _UElements&...>())
1513 : _Inherited(
static_cast<const _Tuple_impl<0, _UElements...
>&>(__in))
1514 { __glibcxx_no_dangling_refs(
const _UElements&); }
1516 template<
typename... _UElements,
1517 bool _Valid = (
sizeof...(_Elements) ==
sizeof...(_UElements))
1519 _ExplicitCtor<_Valid,
const _UElements&...> =
false>
1522 noexcept(__nothrow_constructible<
const _UElements&...>())
1523 : _Inherited(
static_cast<const _Tuple_impl<0, _UElements...
>&>(__in))
1524 { __glibcxx_no_dangling_refs(
const _UElements&); }
1526 template<
typename... _UElements,
1527 bool _Valid = (
sizeof...(_Elements) ==
sizeof...(_UElements))
1529 _ImplicitCtor<_Valid, _UElements...> =
true>
1532 noexcept(__nothrow_constructible<_UElements...>())
1533 : _Inherited(
static_cast<_Tuple_impl<0, _UElements...
>&&>(__in))
1534 { __glibcxx_no_dangling_refs(_UElements&&); }
1536 template<
typename... _UElements,
1537 bool _Valid = (
sizeof...(_Elements) ==
sizeof...(_UElements))
1539 _ExplicitCtor<_Valid, _UElements...> =
false>
1542 noexcept(__nothrow_constructible<_UElements...>())
1543 : _Inherited(
static_cast<_Tuple_impl<0, _UElements...
>&&>(__in))
1544 { __glibcxx_no_dangling_refs(_UElements&&); }
1548 template<
typename _Alloc,
1549 _ImplicitDefaultCtor<is_object<_Alloc>::value> =
true>
1550 _GLIBCXX20_CONSTEXPR
1551 tuple(allocator_arg_t __tag,
const _Alloc& __a)
1552 : _Inherited(__tag, __a) { }
1554 template<
typename _Alloc,
1555 _ExplicitDefaultCtor<is_object<_Alloc>::value> =
false>
1556 _GLIBCXX20_CONSTEXPR
1558 tuple(allocator_arg_t __tag,
const _Alloc& __a)
1559 : _Inherited(__tag, __a) { }
1561 template<
typename _Alloc,
bool _NotEmpty = (
sizeof...(_Elements) >= 1),
1562 _ImplicitCtor<_NotEmpty,
const _Elements&...> =
true>
1563 _GLIBCXX20_CONSTEXPR
1564 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1565 const _Elements&... __elements)
1566 : _Inherited(__tag, __a, __elements...) { }
1568 template<
typename _Alloc,
bool _NotEmpty = (
sizeof...(_Elements) >= 1),
1569 _ExplicitCtor<_NotEmpty,
const _Elements&...> =
false>
1570 _GLIBCXX20_CONSTEXPR
1572 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1573 const _Elements&... __elements)
1574 : _Inherited(__tag, __a, __elements...) { }
1576 template<
typename _Alloc,
typename... _UElements,
1577 bool _Valid = __valid_args<_UElements...>(),
1578 _ImplicitCtor<_Valid, _UElements...> =
true>
1579 _GLIBCXX20_CONSTEXPR
1580 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1581 _UElements&&... __elements)
1582 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
1583 { __glibcxx_no_dangling_refs(_UElements&&); }
1585 template<
typename _Alloc,
typename... _UElements,
1586 bool _Valid = __valid_args<_UElements...>(),
1587 _ExplicitCtor<_Valid, _UElements...> =
false>
1588 _GLIBCXX20_CONSTEXPR
1590 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1591 _UElements&&... __elements)
1592 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
1593 { __glibcxx_no_dangling_refs(_UElements&&); }
1595 template<
typename _Alloc>
1596 _GLIBCXX20_CONSTEXPR
1597 tuple(allocator_arg_t __tag,
const _Alloc& __a,
const tuple& __in)
1598 : _Inherited(__tag, __a,
static_cast<const _Inherited&
>(__in)) { }
1600 template<
typename _Alloc>
1601 _GLIBCXX20_CONSTEXPR
1602 tuple(allocator_arg_t __tag,
const _Alloc& __a,
tuple&& __in)
1603 : _Inherited(__tag, __a,
static_cast<_Inherited&&
>(__in)) { }
1605 template<
typename _Alloc,
typename... _UElements,
1606 bool _Valid = (
sizeof...(_Elements) ==
sizeof...(_UElements))
1608 _ImplicitCtor<_Valid,
const _UElements&...> =
true>
1609 _GLIBCXX20_CONSTEXPR
1610 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1612 : _Inherited(__tag, __a,
1613 static_cast<const _Tuple_impl<0, _UElements...
>&>(__in))
1614 { __glibcxx_no_dangling_refs(
const _UElements&); }
1616 template<
typename _Alloc,
typename... _UElements,
1617 bool _Valid = (
sizeof...(_Elements) ==
sizeof...(_UElements))
1619 _ExplicitCtor<_Valid,
const _UElements&...> =
false>
1620 _GLIBCXX20_CONSTEXPR
1622 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1624 : _Inherited(__tag, __a,
1625 static_cast<const _Tuple_impl<0, _UElements...
>&>(__in))
1626 { __glibcxx_no_dangling_refs(
const _UElements&); }
1628 template<
typename _Alloc,
typename... _UElements,
1629 bool _Valid = (
sizeof...(_Elements) ==
sizeof...(_UElements))
1631 _ImplicitCtor<_Valid, _UElements...> =
true>
1632 _GLIBCXX20_CONSTEXPR
1633 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1635 : _Inherited(__tag, __a,
1636 static_cast<_Tuple_impl<0, _UElements...
>&&>(__in))
1637 { __glibcxx_no_dangling_refs(_UElements&&); }
1639 template<
typename _Alloc,
typename... _UElements,
1640 bool _Valid = (
sizeof...(_Elements) ==
sizeof...(_UElements))
1642 _ExplicitCtor<_Valid, _UElements...> =
false>
1643 _GLIBCXX20_CONSTEXPR
1645 tuple(allocator_arg_t __tag,
const _Alloc& __a,
1647 : _Inherited(__tag, __a,
1648 static_cast<_Tuple_impl<0, _UElements...
>&&>(__in))
1649 { __glibcxx_no_dangling_refs(_UElements&&); }
1654#if __cpp_concepts && __cpp_consteval
1656 template<
typename... _UTypes>
1657 static consteval bool
1660 if constexpr (
sizeof...(_UTypes) ==
sizeof...(_Elements))
1666 template<
typename... _UTypes>
1667 static consteval bool
1668 __nothrow_assignable()
1670 if constexpr (
sizeof...(_UTypes) ==
sizeof...(_Elements))
1676#if __cpp_lib_ranges_zip
1677 template<
typename... _UTypes>
1678 static consteval bool
1679 __const_assignable()
1681 if constexpr (
sizeof...(_UTypes) ==
sizeof...(_Elements))
1688#if __cpp_lib_tuple_like
1689 template<
typename _UTuple>
1690 static consteval bool
1691 __assignable_from_tuple_like()
1694 return __assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
1698 template<
typename _UTuple>
1699 static consteval bool
1700 __const_assignable_from_tuple_like()
1703 return __const_assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
1713 operator=(
const tuple& __u)
1714 noexcept(__nothrow_assignable<
const _Elements&...>())
1715 requires (__assignable<
const _Elements&...>())
1717 this->_M_assign(__u);
1722 operator=(
tuple&& __u)
1723 noexcept(__nothrow_assignable<_Elements...>())
1724 requires (__assignable<_Elements...>())
1730 template<
typename... _UTypes>
1731 requires (__assignable<
const _UTypes&...>())
1734 noexcept(__nothrow_assignable<
const _UTypes&...>())
1736 this->_M_assign(__u);
1740 template<
typename... _UTypes>
1741 requires (__assignable<_UTypes...>())
1744 noexcept(__nothrow_assignable<_UTypes...>())
1750#if __cpp_lib_ranges_zip
1751 constexpr const tuple&
1752 operator=(
const tuple& __u)
const
1753 requires (__const_assignable<
const _Elements&...>())
1755 this->_M_assign(__u);
1759 constexpr const tuple&
1760 operator=(
tuple&& __u)
const
1761 requires (__const_assignable<_Elements...>())
1767 template<
typename... _UTypes>
1768 constexpr const tuple&
1770 requires (__const_assignable<
const _UTypes&...>())
1772 this->_M_assign(__u);
1776 template<
typename... _UTypes>
1777 constexpr const tuple&
1779 requires (__const_assignable<_UTypes...>())
1786 template<
typename _U1,
typename _U2>
1787 requires (__assignable<const _U1&, const _U2&>())
1790 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
1792 this->_M_head(*
this) = __u.first;
1793 this->_M_tail(*this)._M_head(*
this) = __u.second;
1797 template<
typename _U1,
typename _U2>
1798 requires (__assignable<_U1, _U2>())
1801 noexcept(__nothrow_assignable<_U1, _U2>())
1803 this->_M_head(*
this) = std::forward<_U1>(__u.first);
1804 this->_M_tail(*this)._M_head(*
this) = std::forward<_U2>(__u.second);
1808#if __cpp_lib_ranges_zip
1809 template<
typename _U1,
typename _U2>
1810 requires (__const_assignable<const _U1&, const _U2>())
1811 constexpr const tuple&
1814 this->_M_head(*
this) = __u.first;
1815 this->_M_tail(*this)._M_head(*
this) = __u.second;
1819 template<
typename _U1,
typename _U2>
1820 requires (__const_assignable<_U1, _U2>())
1821 constexpr const tuple&
1824 this->_M_head(*
this) = std::forward<_U1>(__u.first);
1825 this->_M_tail(*this)._M_head(*
this) = std::forward<_U2>(__u.second);
1830#if __cpp_lib_tuple_like
1831 template<__eligible_tuple_like<tuple> _UTuple>
1832 requires (__assignable_from_tuple_like<_UTuple>())
1834 operator=(_UTuple&& __u)
1836 this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u));
1840 template<__eligible_tuple_like<tuple> _UTuple>
1841 requires (__const_assignable_from_tuple_like<_UTuple>())
1842 constexpr const tuple&
1843 operator=(_UTuple&& __u)
const
1845 this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u));
1849 template<__tuple_like _UTuple>
1850 requires (!__is_tuple_v<_UTuple>)
1851 friend constexpr bool
1852 operator== [[nodiscard]] (
const tuple& __t,
const _UTuple& __u)
1854 static_assert(
sizeof...(_Elements) == tuple_size_v<_UTuple>,
1855 "tuple objects can only be compared if they have equal sizes.");
1857 return (
bool(std::get<_Is>(__t) == std::get<_Is>(__u))
1862 template<__tuple_like _UTuple,
1864 struct __tuple_like_common_comparison_category;
1866 template<__tuple_like _UTuple,
size_t... _Is>
1868 {
typename void_t<__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>; }
1869 struct __tuple_like_common_comparison_category<_UTuple,
index_sequence<_Is...>>
1871 using type = common_comparison_category_t
1872 <__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>;
1875 template<__tuple_like _UTuple>
1876 requires (!__is_tuple_v<_UTuple>)
1877 friend constexpr typename __tuple_like_common_comparison_category<_UTuple>::type
1878 operator<=>(
const tuple& __t,
const _UTuple& __u)
1880 using _Cat =
typename __tuple_like_common_comparison_category<_UTuple>::type;
1888 template<
typename... _UElements>
1890 __enable_if_t<
sizeof...(_UElements) ==
sizeof...(_Elements),
bool>
1892 {
return __and_<is_assignable<_Elements&, _UElements>...>::value; }
1895 template<
typename... _UElements>
1896 static constexpr bool __nothrow_assignable()
1899 __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value;
1904 _GLIBCXX20_CONSTEXPR
1906 operator=(__conditional_t<__assignable<const _Elements&...>(),
1908 const __nonesuch&> __in)
1909 noexcept(__nothrow_assignable<
const _Elements&...>())
1911 this->_M_assign(__in);
1915 _GLIBCXX20_CONSTEXPR
1917 operator=(__conditional_t<__assignable<_Elements...>(),
1920 noexcept(__nothrow_assignable<_Elements...>())
1926 template<
typename... _UElements>
1927 _GLIBCXX20_CONSTEXPR
1928 __enable_if_t<__assignable<
const _UElements&...>(),
tuple&>
1930 noexcept(__nothrow_assignable<
const _UElements&...>())
1932 this->_M_assign(__in);
1936 template<
typename... _UElements>
1937 _GLIBCXX20_CONSTEXPR
1938 __enable_if_t<__assignable<_UElements...>(),
tuple&>
1940 noexcept(__nothrow_assignable<_UElements...>())
1948 _GLIBCXX20_CONSTEXPR
1951 noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
1952 { _Inherited::_M_swap(__in); }
1954#if __cpp_lib_ranges_zip
1962 swap(
const tuple& __in)
const
1963 noexcept(__and_v<__is_nothrow_swappable<const _Elements>...>)
1964 requires (is_swappable_v<const _Elements> && ...)
1965 { _Inherited::_M_swap(__in); }
1969#if __cpp_deduction_guides >= 201606
1970 template<
typename... _UTypes>
1972 template<
typename _T1,
typename _T2>
1974 template<
typename _Alloc,
typename... _UTypes>
1975 tuple(allocator_arg_t, _Alloc, _UTypes...) ->
tuple<_UTypes...>;
1976 template<
typename _Alloc,
typename _T1,
typename _T2>
1978 template<
typename _Alloc,
typename... _UTypes>
1987 _GLIBCXX20_CONSTEXPR
1988 void swap(
tuple&)
noexcept { }
1989#if __cpp_lib_ranges_zip
1990 constexpr void swap(
const tuple&)
const noexcept { }
1996 template<
typename _Alloc>
1997 _GLIBCXX20_CONSTEXPR
1998 tuple(allocator_arg_t,
const _Alloc&)
noexcept { }
1999 template<
typename _Alloc>
2000 _GLIBCXX20_CONSTEXPR
2001 tuple(allocator_arg_t,
const _Alloc&,
const tuple&)
noexcept { }
2004#if !(__cpp_concepts && __cpp_consteval && __cpp_conditional_explicit)
2007 template<typename _T1, typename _T2>
2008 class tuple<_T1, _T2> :
public _Tuple_impl<0, _T1, _T2>
2010 typedef _Tuple_impl<0, _T1, _T2> _Inherited;
2013 template<
bool _Dummy,
typename _U1,
typename _U2>
2014 using _ImplicitDefaultCtor = __enable_if_t<
2015 _TupleConstraints<_Dummy, _U1, _U2>::
2016 __is_implicitly_default_constructible(),
2020 template<
bool _Dummy,
typename _U1,
typename _U2>
2021 using _ExplicitDefaultCtor = __enable_if_t<
2022 _TupleConstraints<_Dummy, _U1, _U2>::
2023 __is_explicitly_default_constructible(),
2026 template<
bool _Dummy>
2027 using _TCC = _TupleConstraints<_Dummy, _T1, _T2>;
2030 template<
bool _Cond,
typename _U1,
typename _U2>
2031 using _ImplicitCtor = __enable_if_t<
2032 _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(),
2036 template<
bool _Cond,
typename _U1,
typename _U2>
2037 using _ExplicitCtor = __enable_if_t<
2038 _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(),
2041 template<
typename _U1,
typename _U2>
2042 static constexpr bool __assignable()
2044 return __and_<is_assignable<_T1&, _U1>,
2048 template<
typename _U1,
typename _U2>
2049 static constexpr bool __nothrow_assignable()
2051 return __and_<is_nothrow_assignable<_T1&, _U1>,
2055 template<
typename _U1,
typename _U2>
2056 static constexpr bool __nothrow_constructible()
2058 return __and_<is_nothrow_constructible<_T1, _U1>,
2062 static constexpr bool __nothrow_default_constructible()
2064 return __and_<is_nothrow_default_constructible<_T1>,
2068 template<
typename _U1>
2069 static constexpr bool __is_alloc_arg()
2073#undef __glibcxx_no_dangling_refs
2075#if __has_builtin(__reference_constructs_from_temporary) \
2076 && defined _GLIBCXX_DEBUG
2077# define __glibcxx_no_dangling_refs(_U1, _U2) \
2078 static_assert(!__reference_constructs_from_temporary(_T1, _U1) \
2079 && !__reference_constructs_from_temporary(_T2, _U2), \
2080 "std::tuple constructor creates a dangling reference")
2082# define __glibcxx_no_dangling_refs(_U1, _U2)
2087 template<
bool _Dummy =
true,
2088 _ImplicitDefaultCtor<_Dummy, _T1, _T2> =
true>
2091 noexcept(__nothrow_default_constructible())
2094 template<
bool _Dummy =
true,
2095 _ExplicitDefaultCtor<_Dummy, _T1, _T2> =
false>
2098 noexcept(__nothrow_default_constructible())
2101 template<
bool _Dummy =
true,
2102 _ImplicitCtor<_Dummy, const _T1&, const _T2&> =
true>
2104 tuple(
const _T1& __a1,
const _T2& __a2)
2105 noexcept(__nothrow_constructible<const _T1&, const _T2&>())
2106 : _Inherited(__a1, __a2) { }
2108 template<
bool _Dummy =
true,
2109 _ExplicitCtor<_Dummy, const _T1&, const _T2&> =
false>
2111 tuple(
const _T1& __a1,
const _T2& __a2)
2112 noexcept(__nothrow_constructible<const _T1&, const _T2&>())
2113 : _Inherited(__a1, __a2) { }
2115 template<
typename _U1,
typename _U2,
2116 _ImplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> =
true>
2118 tuple(_U1&& __a1, _U2&& __a2)
2119 noexcept(__nothrow_constructible<_U1, _U2>())
2120 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2))
2121 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2123 template<
typename _U1,
typename _U2,
2124 _ExplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> =
false>
2126 tuple(_U1&& __a1, _U2&& __a2)
2127 noexcept(__nothrow_constructible<_U1, _U2>())
2128 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2))
2129 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2135 template<
typename _U1,
typename _U2,
2136 _ImplicitCtor<true, const _U1&, const _U2&> =
true>
2139 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
2140 : _Inherited(
static_cast<const _Tuple_impl<0, _U1, _U2>&
>(__in))
2141 { __glibcxx_no_dangling_refs(
const _U1&,
const _U2&); }
2143 template<
typename _U1,
typename _U2,
2144 _ExplicitCtor<true, const _U1&, const _U2&> =
false>
2147 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
2148 : _Inherited(
static_cast<const _Tuple_impl<0, _U1, _U2>&
>(__in))
2149 { __glibcxx_no_dangling_refs(
const _U1&,
const _U2&); }
2151 template<
typename _U1,
typename _U2,
2152 _ImplicitCtor<true, _U1, _U2> =
true>
2155 noexcept(__nothrow_constructible<_U1, _U2>())
2156 : _Inherited(
static_cast<_Tuple_impl<0, _U1, _U2>&&
>(__in))
2157 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2159 template<
typename _U1,
typename _U2,
2160 _ExplicitCtor<true, _U1, _U2> =
false>
2163 noexcept(__nothrow_constructible<_U1, _U2>())
2164 : _Inherited(
static_cast<_Tuple_impl<0, _U1, _U2>&&
>(__in))
2165 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2167 template<
typename _U1,
typename _U2,
2168 _ImplicitCtor<true, const _U1&, const _U2&> =
true>
2171 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
2172 : _Inherited(__in.first, __in.second)
2173 { __glibcxx_no_dangling_refs(
const _U1&,
const _U2&); }
2175 template<
typename _U1,
typename _U2,
2176 _ExplicitCtor<true, const _U1&, const _U2&> =
false>
2179 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
2180 : _Inherited(__in.first, __in.second)
2181 { __glibcxx_no_dangling_refs(
const _U1&,
const _U2&); }
2183 template<
typename _U1,
typename _U2,
2184 _ImplicitCtor<true, _U1, _U2> =
true>
2187 noexcept(__nothrow_constructible<_U1, _U2>())
2188 : _Inherited(std::forward<_U1>(__in.first),
2189 std::forward<_U2>(__in.second))
2190 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2192 template<
typename _U1,
typename _U2,
2193 _ExplicitCtor<true, _U1, _U2> =
false>
2196 noexcept(__nothrow_constructible<_U1, _U2>())
2197 : _Inherited(std::forward<_U1>(__in.first),
2198 std::forward<_U2>(__in.second))
2199 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2203 template<
typename _Alloc,
2204 _ImplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> =
true>
2205 _GLIBCXX20_CONSTEXPR
2206 tuple(allocator_arg_t __tag,
const _Alloc& __a)
2207 : _Inherited(__tag, __a) { }
2209 template<
typename _Alloc,
2210 _ExplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> =
false>
2211 _GLIBCXX20_CONSTEXPR
2213 tuple(allocator_arg_t __tag,
const _Alloc& __a)
2214 : _Inherited(__tag, __a) { }
2216 template<
typename _Alloc,
bool _Dummy =
true,
2217 _ImplicitCtor<_Dummy, const _T1&, const _T2&> =
true>
2218 _GLIBCXX20_CONSTEXPR
2219 tuple(allocator_arg_t __tag,
const _Alloc& __a,
2220 const _T1& __a1,
const _T2& __a2)
2221 : _Inherited(__tag, __a, __a1, __a2) { }
2223 template<
typename _Alloc,
bool _Dummy =
true,
2224 _ExplicitCtor<_Dummy, const _T1&, const _T2&> =
false>
2226 _GLIBCXX20_CONSTEXPR
2227 tuple(allocator_arg_t __tag,
const _Alloc& __a,
2228 const _T1& __a1,
const _T2& __a2)
2229 : _Inherited(__tag, __a, __a1, __a2) { }
2231 template<
typename _Alloc,
typename _U1,
typename _U2,
2232 _ImplicitCtor<true, _U1, _U2> =
true>
2233 _GLIBCXX20_CONSTEXPR
2234 tuple(allocator_arg_t __tag,
const _Alloc& __a, _U1&& __a1, _U2&& __a2)
2235 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
2236 std::forward<_U2>(__a2))
2237 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2239 template<
typename _Alloc,
typename _U1,
typename _U2,
2240 _ExplicitCtor<true, _U1, _U2> =
false>
2242 _GLIBCXX20_CONSTEXPR
2243 tuple(allocator_arg_t __tag,
const _Alloc& __a,
2244 _U1&& __a1, _U2&& __a2)
2245 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
2246 std::forward<_U2>(__a2))
2247 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2249 template<
typename _Alloc>
2250 _GLIBCXX20_CONSTEXPR
2251 tuple(allocator_arg_t __tag,
const _Alloc& __a,
const tuple& __in)
2252 : _Inherited(__tag, __a,
static_cast<const _Inherited&
>(__in)) { }
2254 template<
typename _Alloc>
2255 _GLIBCXX20_CONSTEXPR
2256 tuple(allocator_arg_t __tag,
const _Alloc& __a,
tuple&& __in)
2257 : _Inherited(__tag, __a,
static_cast<_Inherited&&
>(__in)) { }
2259 template<
typename _Alloc,
typename _U1,
typename _U2,
2260 _ImplicitCtor<true, const _U1&, const _U2&> =
true>
2261 _GLIBCXX20_CONSTEXPR
2262 tuple(allocator_arg_t __tag,
const _Alloc& __a,
2264 : _Inherited(__tag, __a,
2265 static_cast<const _Tuple_impl<0, _U1, _U2>&
>(__in))
2266 { __glibcxx_no_dangling_refs(
const _U1&,
const _U2&); }
2268 template<
typename _Alloc,
typename _U1,
typename _U2,
2269 _ExplicitCtor<true, const _U1&, const _U2&> =
false>
2271 _GLIBCXX20_CONSTEXPR
2272 tuple(allocator_arg_t __tag,
const _Alloc& __a,
2274 : _Inherited(__tag, __a,
2275 static_cast<const _Tuple_impl<0, _U1, _U2>&
>(__in))
2276 { __glibcxx_no_dangling_refs(
const _U1&,
const _U2&); }
2278 template<
typename _Alloc,
typename _U1,
typename _U2,
2279 _ImplicitCtor<true, _U1, _U2> =
true>
2280 _GLIBCXX20_CONSTEXPR
2282 : _Inherited(__tag, __a,
static_cast<_Tuple_impl<0, _U1, _U2>&&
>(__in))
2283 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2285 template<
typename _Alloc,
typename _U1,
typename _U2,
2286 _ExplicitCtor<true, _U1, _U2> =
false>
2288 _GLIBCXX20_CONSTEXPR
2290 : _Inherited(__tag, __a,
static_cast<_Tuple_impl<0, _U1, _U2>&&
>(__in))
2291 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2293 template<
typename _Alloc,
typename _U1,
typename _U2,
2294 _ImplicitCtor<true, const _U1&, const _U2&> =
true>
2295 _GLIBCXX20_CONSTEXPR
2296 tuple(allocator_arg_t __tag,
const _Alloc& __a,
2298 : _Inherited(__tag, __a, __in.first, __in.second)
2299 { __glibcxx_no_dangling_refs(
const _U1&,
const _U2&); }
2301 template<
typename _Alloc,
typename _U1,
typename _U2,
2302 _ExplicitCtor<true, const _U1&, const _U2&> =
false>
2304 _GLIBCXX20_CONSTEXPR
2305 tuple(allocator_arg_t __tag,
const _Alloc& __a,
2307 : _Inherited(__tag, __a, __in.first, __in.second)
2308 { __glibcxx_no_dangling_refs(
const _U1&,
const _U2&); }
2310 template<
typename _Alloc,
typename _U1,
typename _U2,
2311 _ImplicitCtor<true, _U1, _U2> =
true>
2312 _GLIBCXX20_CONSTEXPR
2314 : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
2315 std::forward<_U2>(__in.second))
2316 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2318 template<
typename _Alloc,
typename _U1,
typename _U2,
2319 _ExplicitCtor<true, _U1, _U2> =
false>
2321 _GLIBCXX20_CONSTEXPR
2323 : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
2324 std::forward<_U2>(__in.second))
2325 { __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
2329 _GLIBCXX20_CONSTEXPR
2331 operator=(__conditional_t<__assignable<const _T1&, const _T2&>(),
2333 const __nonesuch&> __in)
2334 noexcept(__nothrow_assignable<const _T1&, const _T2&>())
2336 this->_M_assign(__in);
2340 _GLIBCXX20_CONSTEXPR
2342 operator=(__conditional_t<__assignable<_T1, _T2>(),
2345 noexcept(__nothrow_assignable<_T1, _T2>())
2351 template<
typename _U1,
typename _U2>
2352 _GLIBCXX20_CONSTEXPR
2353 __enable_if_t<__assignable<const _U1&, const _U2&>(),
tuple&>
2355 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
2357 this->_M_assign(__in);
2361 template<
typename _U1,
typename _U2>
2362 _GLIBCXX20_CONSTEXPR
2363 __enable_if_t<__assignable<_U1, _U2>(),
tuple&>
2365 noexcept(__nothrow_assignable<_U1, _U2>())
2371 template<
typename _U1,
typename _U2>
2372 _GLIBCXX20_CONSTEXPR
2373 __enable_if_t<__assignable<const _U1&, const _U2&>(),
tuple&>
2375 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
2377 this->_M_head(*
this) = __in.first;
2378 this->_M_tail(*this)._M_head(*
this) = __in.second;
2382 template<
typename _U1,
typename _U2>
2383 _GLIBCXX20_CONSTEXPR
2384 __enable_if_t<__assignable<_U1, _U2>(),
tuple&>
2386 noexcept(__nothrow_assignable<_U1, _U2>())
2388 this->_M_head(*
this) = std::forward<_U1>(__in.first);
2389 this->_M_tail(*this)._M_head(*
this) = std::forward<_U2>(__in.second);
2393 _GLIBCXX20_CONSTEXPR
2396 noexcept(__and_<__is_nothrow_swappable<_T1>,
2397 __is_nothrow_swappable<_T2>>::value)
2398 { _Inherited::_M_swap(__in); }
2403 template<
typename... _Elements>
2407#if __cplusplus >= 201703L
2408 template<
typename... _Types>
2409 inline constexpr size_t tuple_size_v<
tuple<_Types...>>
2410 =
sizeof...(_Types);
2412 template<
typename... _Types>
2413 inline constexpr size_t tuple_size_v<
const tuple<_Types...>>
2414 =
sizeof...(_Types);
2418 template<
size_t __i,
typename... _Types>
2421 static_assert(__i <
sizeof...(_Types),
"tuple index must be in range");
2423 using type =
typename _Nth_type<__i, _Types...>::type;
2426 template<
size_t __i,
typename _Head,
typename... _Tail>
2428 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t)
noexcept
2429 {
return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
2431 template<
size_t __i,
typename _Head,
typename... _Tail>
2432 constexpr const _Head&
2433 __get_helper(
const _Tuple_impl<__i, _Head, _Tail...>& __t)
noexcept
2434 {
return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
2437 template<
size_t __i,
typename... _Types>
2438 __enable_if_t<(__i >=
sizeof...(_Types))>
2439 __get_helper(
const tuple<_Types...>&) =
delete;
2442 template<
size_t __i,
typename... _Elements>
2443 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
2445 {
return std::__get_helper<__i>(__t); }
2448 template<
size_t __i,
typename... _Elements>
2449 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
2451 {
return std::__get_helper<__i>(__t); }
2454 template<
size_t __i,
typename... _Elements>
2455 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
2458 typedef __tuple_element_t<__i,
tuple<_Elements...>> __element_type;
2459 return std::forward<__element_type>(std::__get_helper<__i>(__t));
2463 template<
size_t __i,
typename... _Elements>
2464 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
2467 typedef __tuple_element_t<__i,
tuple<_Elements...>> __element_type;
2468 return std::forward<const __element_type>(std::__get_helper<__i>(__t));
2473 template<
size_t __i,
typename... _Elements>
2474 constexpr __enable_if_t<(__i >=
sizeof...(_Elements))>
2475 get(
const tuple<_Elements...>&) =
delete;
2478#ifdef __cpp_lib_tuples_by_type
2480 template <typename _Tp, typename... _Types>
2482 get(tuple<_Types...>& __t)
noexcept
2484 constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
2485 static_assert(__idx <
sizeof...(_Types),
2486 "the type T in std::get<T> must occur exactly once in the tuple");
2487 return std::__get_helper<__idx>(__t);
2491 template <
typename _Tp,
typename... _Types>
2493 get(tuple<_Types...>&& __t)
noexcept
2495 constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
2496 static_assert(__idx <
sizeof...(_Types),
2497 "the type T in std::get<T> must occur exactly once in the tuple");
2498 return std::forward<_Tp>(std::__get_helper<__idx>(__t));
2502 template <
typename _Tp,
typename... _Types>
2503 constexpr const _Tp&
2504 get(
const tuple<_Types...>& __t)
noexcept
2506 constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
2507 static_assert(__idx <
sizeof...(_Types),
2508 "the type T in std::get<T> must occur exactly once in the tuple");
2509 return std::__get_helper<__idx>(__t);
2514 template <
typename _Tp,
typename... _Types>
2515 constexpr const _Tp&&
2516 get(
const tuple<_Types...>&& __t)
noexcept
2518 constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
2519 static_assert(__idx <
sizeof...(_Types),
2520 "the type T in std::get<T> must occur exactly once in the tuple");
2521 return std::forward<const _Tp>(std::__get_helper<__idx>(__t));
2525#if __cpp_lib_three_way_comparison
2526 template<
typename... _Tps,
typename... _Ups>
2527 requires (
sizeof...(_Tps) ==
sizeof...(_Ups))
2528 && (
requires (
const _Tps& __t,
const _Ups& __u) {
2529 { __t == __u } -> __detail::__boolean_testable;
2532 operator== [[nodiscard]] (
const tuple<_Tps...>& __t,
2533 const tuple<_Ups...>& __u)
2537 return (
bool(std::get<_Inds>(__t) == std::get<_Inds>(__u)) && ...);
2541 template<
typename _Cat,
typename _Tp,
typename _Up,
typename _IndexSeq>
2544 __tuple_cmp(
const _Tp& __t,
const _Up& __u, _IndexSeq __indices)
2546 _Cat __c = _Cat::equivalent;
2550 auto __cmp = [&]<
size_t _Ind>(integral_constant<size_t, _Ind>) {
2551 __c = __detail::__synth3way(std::get<_Ind>(__t), std::get<_Ind>(__u));
2557 (void)(__cmp(integral_constant<size_t, _Inds>{}) && ...);
2563 template<
typename... _Tps,
typename... _Ups>
2564 requires (
sizeof...(_Tps) ==
sizeof...(_Ups))
2565 && (
requires {
typename __detail::__synth3way_t<_Tps, _Ups>; } && ...)
2567 common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>
2568 operator<=> [[nodiscard]] (
const tuple<_Tps...>& __t,
2569 const tuple<_Ups...>& __u)
2572 = common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>;
2573 return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Tps...>());
2578 template<
typename _Tp,
typename _Up,
size_t __i,
size_t __size>
2579 struct __tuple_compare
2581 static constexpr bool
2582 __eq(
const _Tp& __t,
const _Up& __u)
2584 return bool(std::get<__i>(__t) == std::get<__i>(__u))
2585 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
2588 static constexpr bool
2589 __less(
const _Tp& __t,
const _Up& __u)
2591 return bool(std::get<__i>(__t) < std::get<__i>(__u))
2592 || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
2593 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
2597 template<
typename _Tp,
typename _Up,
size_t __size>
2598 struct __tuple_compare<_Tp, _Up, __size, __size>
2600 static constexpr bool
2601 __eq(
const _Tp&,
const _Up&) {
return true; }
2603 static constexpr bool
2604 __less(
const _Tp&,
const _Up&) {
return false; }
2607 template<
typename... _TElements,
typename... _UElements>
2610 operator==(
const tuple<_TElements...>& __t,
2611 const tuple<_UElements...>& __u)
2613 static_assert(
sizeof...(_TElements) ==
sizeof...(_UElements),
2614 "tuple objects can only be compared if they have equal sizes.");
2615 using __compare = __tuple_compare<tuple<_TElements...>,
2616 tuple<_UElements...>,
2617 0,
sizeof...(_TElements)>;
2618 return __compare::__eq(__t, __u);
2621 template<
typename... _TElements,
typename... _UElements>
2624 operator<(
const tuple<_TElements...>& __t,
2625 const tuple<_UElements...>& __u)
2627 static_assert(
sizeof...(_TElements) ==
sizeof...(_UElements),
2628 "tuple objects can only be compared if they have equal sizes.");
2629 using __compare = __tuple_compare<tuple<_TElements...>,
2630 tuple<_UElements...>,
2631 0,
sizeof...(_TElements)>;
2632 return __compare::__less(__t, __u);
2635 template<
typename... _TElements,
typename... _UElements>
2638 operator!=(
const tuple<_TElements...>& __t,
2639 const tuple<_UElements...>& __u)
2640 {
return !(__t == __u); }
2642 template<
typename... _TElements,
typename... _UElements>
2645 operator>(
const tuple<_TElements...>& __t,
2646 const tuple<_UElements...>& __u)
2647 {
return __u < __t; }
2649 template<
typename... _TElements,
typename... _UElements>
2653 const tuple<_UElements...>& __u)
2654 {
return !(__u < __t); }
2656 template<
typename... _TElements,
typename... _UElements>
2660 const tuple<_UElements...>& __u)
2661 {
return !(__t < __u); }
2666 template<
typename... _Elements>
2667 constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
2672 return __result_type(std::forward<_Elements>(__args)...);
2678 template<
typename... _Elements>
2679 constexpr tuple<_Elements&&...>
2681 {
return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
2684 template<
size_t,
typename,
typename,
size_t>
2685 struct __make_tuple_impl;
2687 template<
size_t _Idx,
typename _Tuple,
typename... _Tp,
size_t _Nm>
2688 struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
2689 : __make_tuple_impl<_Idx + 1,
2690 tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
2694 template<
size_t _Nm,
typename _Tuple,
typename... _Tp>
2695 struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
2697 typedef tuple<_Tp...> __type;
2700 template<
typename _Tuple>
2701 struct __do_make_tuple
2702 : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value>
2706 template<
typename _Tuple>
2708 :
public __do_make_tuple<__remove_cvref_t<_Tuple>>
2712 template<
typename...>
2713 struct __combine_tuples;
2716 struct __combine_tuples<>
2718 typedef tuple<> __type;
2721 template<
typename... _Ts>
2722 struct __combine_tuples<tuple<_Ts...>>
2724 typedef tuple<_Ts...> __type;
2727 template<
typename... _T1s,
typename... _T2s,
typename... _Rem>
2728 struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
2730 typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
2731 _Rem...>::__type __type;
2735 template<
typename... _Tpls>
2736 struct __tuple_cat_result
2738 typedef typename __combine_tuples
2739 <
typename __make_tuple<_Tpls>::__type...>::__type __type;
2744 template<
typename...>
2745 struct __make_1st_indices;
2748 struct __make_1st_indices<>
2750 typedef _Index_tuple<> __type;
2753 template<
typename _Tp,
typename... _Tpls>
2754 struct __make_1st_indices<_Tp, _Tpls...>
2756 typedef typename _Build_index_tuple<tuple_size<
2757 typename remove_reference<_Tp>::type>::value>::__type __type;
2763 template<
typename _Ret,
typename _Indices,
typename... _Tpls>
2764 struct __tuple_concater;
2766 template<
typename _Ret,
size_t... _Is,
typename _Tp,
typename... _Tpls>
2767 struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...>
2769 template<
typename... _Us>
2770 static constexpr _Ret
2771 _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
2773 typedef typename __make_1st_indices<_Tpls...>::__type __idx;
2774 typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
2775 return __next::_S_do(std::forward<_Tpls>(__tps)...,
2776 std::forward<_Us>(__us)...,
2777 std::get<_Is>(std::forward<_Tp>(__tp))...);
2781 template<
typename _Ret>
2782 struct __tuple_concater<_Ret, _Index_tuple<>>
2784 template<
typename... _Us>
2785 static constexpr _Ret
2786 _S_do(_Us&&... __us)
2788 return _Ret(std::forward<_Us>(__us)...);
2792 template<
typename... _Tps>
2793 struct __is_tuple_like_impl<tuple<_Tps...>> :
true_type
2798#if __cpp_lib_tuple_like
2799 template<__tuple_like... _Tpls>
2801 template<
typename... _Tpls,
typename =
typename
2802 enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
2806 ->
typename __tuple_cat_result<_Tpls...>::__type
2808 typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
2809 typedef typename __make_1st_indices<_Tpls...>::__type __idx;
2810 typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
2811 return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
2817 template<
typename... _Elements>
2818 constexpr tuple<_Elements&...>
2819 tie(_Elements&... __args)
noexcept
2820 {
return tuple<_Elements&...>(__args...); }
2823 template<
typename... _Elements>
2824 _GLIBCXX20_CONSTEXPR
2826#if __cplusplus > 201402L || !defined(__STRICT_ANSI__)
2828 typename enable_if<__and_<__is_swappable<_Elements>...>::value
2834 noexcept(
noexcept(__x.swap(__y)))
2837#if __cpp_lib_ranges_zip
2838 template<
typename... _Elements>
2839 requires (is_swappable_v<const _Elements> && ...)
2841 swap(
const tuple<_Elements...>& __x,
const tuple<_Elements...>& __y)
2842 noexcept(
noexcept(__x.swap(__y)))
2846#if __cplusplus > 201402L || !defined(__STRICT_ANSI__)
2848 template<typename... _Elements>
2849 _GLIBCXX20_CONSTEXPR
2850 typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
2851 swap(tuple<_Elements...>&, tuple<_Elements...>&) =
delete;
2855 template<
typename... _Types,
typename _Alloc>
2867 template<
class _T1,
class _T2>
2868 template<
typename... _Args1,
typename... _Args2>
2869 _GLIBCXX20_CONSTEXPR
2874 :
pair(__first, __second,
2875 typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
2876 typename _Build_index_tuple<sizeof...(_Args2)>::__type())