blob: a14d90365959dcdf972d326066ca9465c177de63 [file] [log] [blame]
Howard Hinnantc51e1022010-05-11 19:42:16 +00001// -*- C++ -*-
Louis Dionne9bd93882021-11-17 16:25:01 -05002//===----------------------------------------------------------------------===//
Howard Hinnantc51e1022010-05-11 19:42:16 +00003//
Chandler Carruth7642bb12019-01-19 08:50:56 +00004// 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
Howard Hinnantc51e1022010-05-11 19:42:16 +00007//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_TUPLE
11#define _LIBCPP_TUPLE
12
13/*
14 tuple synopsis
15
16namespace std
17{
18
19template <class... T>
20class tuple {
21public:
Louis Dionnea7a2beb2019-09-26 14:51:10 +000022 explicit(see-below) constexpr tuple();
Louis Dionne1afad1d2019-07-22 20:45:23 +000023 explicit(see-below) tuple(const T&...); // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +000024 template <class... U>
Louis Dionne1afad1d2019-07-22 20:45:23 +000025 explicit(see-below) tuple(U&&...); // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +000026 tuple(const tuple&) = default;
Howard Hinnant89ef1212011-05-27 19:08:18 +000027 tuple(tuple&&) = default;
Hui Xied1637a82022-05-12 13:23:11 +010028
29 template<class... UTypes>
30 constexpr explicit(see-below) tuple(tuple<UTypes...>&); // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000031 template <class... U>
Louis Dionne1afad1d2019-07-22 20:45:23 +000032 explicit(see-below) tuple(const tuple<U...>&); // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +000033 template <class... U>
Louis Dionne1afad1d2019-07-22 20:45:23 +000034 explicit(see-below) tuple(tuple<U...>&&); // constexpr in C++14
Hui Xied1637a82022-05-12 13:23:11 +010035 template<class... UTypes>
36 constexpr explicit(see-below) tuple(const tuple<UTypes...>&&); // C++23
37
38 template<class U1, class U2>
39 constexpr explicit(see-below) tuple(pair<U1, U2>&); // iff sizeof...(Types) == 2 // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000040 template <class U1, class U2>
Louis Dionne1afad1d2019-07-22 20:45:23 +000041 explicit(see-below) tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +000042 template <class U1, class U2>
Louis Dionne1afad1d2019-07-22 20:45:23 +000043 explicit(see-below) tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2 // constexpr in C++14
Hui Xied1637a82022-05-12 13:23:11 +010044 template<class U1, class U2>
45 constexpr explicit(see-below) tuple(const pair<U1, U2>&&); // iff sizeof...(Types) == 2 // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000046
47 // allocator-extended constructors
48 template <class Alloc>
49 tuple(allocator_arg_t, const Alloc& a);
50 template <class Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050051 explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const T&...); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000052 template <class Alloc, class... U>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050053 explicit(see-below) tuple(allocator_arg_t, const Alloc& a, U&&...); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000054 template <class Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050055 tuple(allocator_arg_t, const Alloc& a, const tuple&); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000056 template <class Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050057 tuple(allocator_arg_t, const Alloc& a, tuple&&); // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010058 template<class Alloc, class... UTypes>
59 constexpr explicit(see-below)
Louis Dionne76450ee2022-06-27 09:36:52 -040060 tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&); // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000061 template <class Alloc, class... U>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050062 explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000063 template <class Alloc, class... U>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050064 explicit(see-below) tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&); // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010065 template<class Alloc, class... UTypes>
66 constexpr explicit(see-below)
67 tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&&); // C++23
68 template<class Alloc, class U1, class U2>
69 constexpr explicit(see-below)
70 tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&); // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000071 template <class Alloc, class U1, class U2>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050072 explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000073 template <class Alloc, class U1, class U2>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050074 explicit(see-below) tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&); // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010075 template<class Alloc, class U1, class U2>
76 constexpr explicit(see-below)
77 tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&&); // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000078
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050079 tuple& operator=(const tuple&); // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010080 constexpr const tuple& operator=(const tuple&) const; // C++23
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050081 tuple& operator=(tuple&&) noexcept(is_nothrow_move_assignable_v<T> && ...); // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010082 constexpr const tuple& operator=(tuple&&) const; // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000083 template <class... U>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050084 tuple& operator=(const tuple<U...>&); // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010085 template<class... UTypes>
86 constexpr const tuple& operator=(const tuple<UTypes...>&) const; // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000087 template <class... U>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050088 tuple& operator=(tuple<U...>&&); // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010089 template<class... UTypes>
90 constexpr const tuple& operator=(tuple<UTypes...>&&) const; // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000091 template <class U1, class U2>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050092 tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010093 template<class U1, class U2>
94 constexpr const tuple& operator=(const pair<U1, U2>&) const; // iff sizeof...(Types) == 2 // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000095 template <class U1, class U2>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -050096 tuple& operator=(pair<U1, U2>&&); // iff sizeof...(T) == 2 // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +010097 template<class U1, class U2>
98 constexpr const tuple& operator=(pair<U1, U2>&&) const; // iff sizeof...(Types) == 2 // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +000099
Louis Dionne6c0d5342018-07-31 11:56:20 -0400100 template<class U, size_t N>
101 tuple& operator=(array<U, N> const&) // iff sizeof...(T) == N, EXTENSION
102 template<class U, size_t N>
103 tuple& operator=(array<U, N>&&) // iff sizeof...(T) == N, EXTENSION
104
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500105 void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...)); // constexpr in C++20
Hui Xied1637a82022-05-12 13:23:11 +0100106 constexpr void swap(const tuple&) const noexcept(see-below); // C++23
Howard Hinnantc51e1022010-05-11 19:42:16 +0000107};
108
Nikolas Klauserad26ba52022-01-17 19:45:42 +0100109
110template<class... TTypes, class... UTypes, template<class> class TQual, template<class> class UQual> // since C++23
111 requires requires { typename tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>; }
112struct basic_common_reference<tuple<TTypes...>, tuple<UTypes...>, TQual, UQual> {
113 using type = tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>;
114};
115
116template<class... TTypes, class... UTypes> // since C++23
117 requires requires { typename tuple<common_type_t<TTypes, UTypes>...>; }
118struct common_type<tuple<TTypes...>, tuple<UTypes...>> {
119 using type = tuple<common_type_t<TTypes, UTypes>...>;
120};
121
Louis Dionne616da2a2019-08-12 18:30:31 +0000122template <class ...T>
123tuple(T...) -> tuple<T...>; // since C++17
124template <class T1, class T2>
125tuple(pair<T1, T2>) -> tuple<T1, T2>; // since C++17
126template <class Alloc, class ...T>
127tuple(allocator_arg_t, Alloc, T...) -> tuple<T...>; // since C++17
128template <class Alloc, class T1, class T2>
129tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>; // since C++17
130template <class Alloc, class ...T>
131tuple(allocator_arg_t, Alloc, tuple<T...>) -> tuple<T...>; // since C++17
132
Marshall Clowf1bf62f2018-01-02 17:17:01 +0000133inline constexpr unspecified ignore;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000134
Marshall Clow2229cee2013-07-22 16:02:19 +0000135template <class... T> tuple<V...> make_tuple(T&&...); // constexpr in C++14
Marshall Clowded420b2013-10-05 18:46:37 +0000136template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
Marshall Clowa8892812014-02-25 16:11:46 +0000137template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14
Marshall Clow2229cee2013-07-22 16:02:19 +0000138template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14
Eric Fiselier8e892c52016-07-18 00:35:56 +0000139
140// [tuple.apply], calling a function with a tuple of arguments:
141template <class F, class Tuple>
142 constexpr decltype(auto) apply(F&& f, Tuple&& t); // C++17
143template <class T, class Tuple>
144 constexpr T make_from_tuple(Tuple&& t); // C++17
145
Howard Hinnantc51e1022010-05-11 19:42:16 +0000146// 20.4.1.4, tuple helper classes:
Marshall Clowce62b4d2019-01-11 21:57:12 +0000147template <class T> struct tuple_size; // undefined
148template <class... T> struct tuple_size<tuple<T...>>;
Eric Fiselier8e892c52016-07-18 00:35:56 +0000149template <class T>
Marshall Clowf1bf62f2018-01-02 17:17:01 +0000150 inline constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17
Louis Dionnee684aa62019-04-01 16:39:34 +0000151template <size_t I, class T> struct tuple_element; // undefined
152template <size_t I, class... T> struct tuple_element<I, tuple<T...>>;
Marshall Clow36907512015-11-19 19:45:29 +0000153template <size_t I, class T>
154 using tuple_element_t = typename tuple_element <I, T>::type; // C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000155
156// 20.4.1.5, element access:
Marshall Clow36907512015-11-19 19:45:29 +0000157template <size_t I, class... T>
Howard Hinnant89ef1212011-05-27 19:08:18 +0000158 typename tuple_element<I, tuple<T...>>::type&
Marshall Clow0abb1042013-07-17 18:25:36 +0000159 get(tuple<T...>&) noexcept; // constexpr in C++14
Marshall Clow36907512015-11-19 19:45:29 +0000160template <size_t I, class... T>
161 const typename tuple_element<I, tuple<T...>>::type&
Marshall Clow0abb1042013-07-17 18:25:36 +0000162 get(const tuple<T...>&) noexcept; // constexpr in C++14
Marshall Clow36907512015-11-19 19:45:29 +0000163template <size_t I, class... T>
Howard Hinnant89ef1212011-05-27 19:08:18 +0000164 typename tuple_element<I, tuple<T...>>::type&&
Marshall Clow0abb1042013-07-17 18:25:36 +0000165 get(tuple<T...>&&) noexcept; // constexpr in C++14
Eric Fiselier6dea8092015-12-18 00:36:55 +0000166template <size_t I, class... T>
167 const typename tuple_element<I, tuple<T...>>::type&&
168 get(const tuple<T...>&&) noexcept; // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000169
Marshall Clow15b02e02013-07-13 02:54:05 +0000170template <class T1, class... T>
171 constexpr T1& get(tuple<T...>&) noexcept; // C++14
172template <class T1, class... T>
Marshall Clow36907512015-11-19 19:45:29 +0000173 constexpr const T1& get(const tuple<T...>&) noexcept; // C++14
Marshall Clow15b02e02013-07-13 02:54:05 +0000174template <class T1, class... T>
175 constexpr T1&& get(tuple<T...>&&) noexcept; // C++14
Eric Fiselier6dea8092015-12-18 00:36:55 +0000176template <class T1, class... T>
177 constexpr const T1&& get(const tuple<T...>&&) noexcept; // C++14
Marshall Clow15b02e02013-07-13 02:54:05 +0000178
Howard Hinnantc51e1022010-05-11 19:42:16 +0000179// 20.4.1.6, relational operators:
Marshall Clow2229cee2013-07-22 16:02:19 +0000180template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
Kent Ross0861b0d2021-10-08 14:54:28 -0700181template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
182template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
183template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
184template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
185template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14, removed in C++20
186template<class... T, class... U>
187 constexpr common_comparison_category_t<synth-three-way-result<T, U>...>
188 operator<=>(const tuple<T...>&, const tuple<U...>&); // since C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000189
190template <class... Types, class Alloc>
191 struct uses_allocator<tuple<Types...>, Alloc>;
192
193template <class... Types>
Howard Hinnant89ef1212011-05-27 19:08:18 +0000194 void
195 swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
Howard Hinnantc51e1022010-05-11 19:42:16 +0000196
Hui Xied1637a82022-05-12 13:23:11 +0100197template <class... Types>
198 constexpr void swap(const tuple<Types...>& x, const tuple<Types...>& y) noexcept(see-below); // C++23
199
Howard Hinnantc51e1022010-05-11 19:42:16 +0000200} // std
201
202*/
203
Louis Dionneb4fce352022-03-25 12:55:36 -0400204#include <__assert> // all public C++ headers provide the assertion handler
Kent Ross0861b0d2021-10-08 14:54:28 -0700205#include <__compare/common_comparison_category.h>
206#include <__compare/synth_three_way.h>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000207#include <__config>
Christopher Di Bella599a6c62021-06-09 23:10:17 +0000208#include <__functional/unwrap_ref.h>
Nikolas Klausera22eabb2022-09-05 14:38:24 +0200209#include <__fwd/array.h>
Christopher Di Bella55d7a822021-07-01 09:25:35 -0400210#include <__memory/allocator_arg_t.h>
211#include <__memory/uses_allocator.h>
Nikolas Klauser23713ea2022-08-13 23:10:31 +0200212#include <__type_traits/maybe_const.h>
Christopher Di Bella41f26e82021-06-05 02:47:47 +0000213#include <__utility/forward.h>
Kent Ross0861b0d2021-10-08 14:54:28 -0700214#include <__utility/integer_sequence.h>
Christopher Di Bella41f26e82021-06-05 02:47:47 +0000215#include <__utility/move.h>
Nikolas Klauser8fccd622022-03-05 19:17:07 +0100216#include <__utility/pair.h>
217#include <__utility/piecewise_construct.h>
218#include <__utility/swap.h>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000219#include <cstddef>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000220#include <type_traits>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000221#include <version>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000222
Nikolas Klausera0e0edb2022-06-16 22:43:46 +0200223// standard-mandated includes
Nikolas Klauser71619e72022-09-22 18:05:08 +0200224
225// [tuple.syn]
Nikolas Klausera0e0edb2022-06-16 22:43:46 +0200226#include <compare>
227
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000228#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Arthur O'Dwyer6eeaa002022-02-01 20:16:40 -0500229# pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000230#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000231
232_LIBCPP_BEGIN_NAMESPACE_STD
233
Eric Fiselierffe4aba2017-04-19 01:23:39 +0000234#ifndef _LIBCPP_CXX03_LANG
Howard Hinnantc51e1022010-05-11 19:42:16 +0000235
Marshall Clowf50d66f2014-03-03 06:18:11 +0000236
Howard Hinnantc51e1022010-05-11 19:42:16 +0000237// __tuple_leaf
238
Eric Fiselierf7394302015-06-13 07:08:02 +0000239template <size_t _Ip, class _Hp,
240 bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value
Howard Hinnantd0aabf82011-12-11 20:31:33 +0000241 >
Howard Hinnantc51e1022010-05-11 19:42:16 +0000242class __tuple_leaf;
243
244template <size_t _Ip, class _Hp, bool _Ep>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200245inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000246void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
Howard Hinnant89ef1212011-05-27 19:08:18 +0000247 _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000248{
249 swap(__x.get(), __y.get());
250}
251
Hui Xied1637a82022-05-12 13:23:11 +0100252template <size_t _Ip, class _Hp, bool _Ep>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200253_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne76450ee2022-06-27 09:36:52 -0400254void swap(const __tuple_leaf<_Ip, _Hp, _Ep>& __x, const __tuple_leaf<_Ip, _Hp, _Ep>& __y)
Hui Xied1637a82022-05-12 13:23:11 +0100255 _NOEXCEPT_(__is_nothrow_swappable<const _Hp>::value) {
256 swap(__x.get(), __y.get());
257}
258
Howard Hinnantc51e1022010-05-11 19:42:16 +0000259template <size_t _Ip, class _Hp, bool>
260class __tuple_leaf
261{
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000262 _Hp __value_;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000263
Eric Fiselierca8bba12016-07-20 02:57:39 +0000264 template <class _Tp>
265 static constexpr bool __can_bind_reference() {
Eric Fiselier869187d2018-01-24 22:14:01 +0000266#if __has_keyword(__reference_binds_to_temporary)
267 return !__reference_binds_to_temporary(_Hp, _Tp);
Eric Fiselier81c32cb2018-01-24 23:10:02 +0000268#else
269 return true;
Eric Fiselier869187d2018-01-24 22:14:01 +0000270#endif
Eric Fiselierca8bba12016-07-20 02:57:39 +0000271 }
272
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200273 _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000274 __tuple_leaf& operator=(const __tuple_leaf&);
275public:
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500276 _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000277 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
Howard Hinnantc51e1022010-05-11 19:42:16 +0000278 {static_assert(!is_reference<_Hp>::value,
279 "Attempted to default construct a reference element in a tuple");}
280
281 template <class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500282 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000283 __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000284 : __value_()
Howard Hinnantc51e1022010-05-11 19:42:16 +0000285 {static_assert(!is_reference<_Hp>::value,
286 "Attempted to default construct a reference element in a tuple");}
287
288 template <class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500289 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000290 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000291 : __value_(allocator_arg_t(), __a)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000292 {static_assert(!is_reference<_Hp>::value,
293 "Attempted to default construct a reference element in a tuple");}
294
295 template <class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500296 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000297 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000298 : __value_(__a)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000299 {static_assert(!is_reference<_Hp>::value,
300 "Attempted to default construct a reference element in a tuple");}
301
Howard Hinnant693fc212010-09-27 17:54:17 +0000302 template <class _Tp,
Louis Dionne9ce598d2021-09-08 09:14:43 -0400303 class = __enable_if_t<
Eric Fiselier3906a132019-06-23 20:28:29 +0000304 _And<
Nikolas Klauserc9e524e2022-09-06 00:33:34 +0200305 _IsNotSame<__remove_cvref_t<_Tp>, __tuple_leaf>,
Eric Fiselier3906a132019-06-23 20:28:29 +0000306 is_constructible<_Hp, _Tp>
Eric Fiselier42fa85e2014-07-24 18:48:34 +0000307 >::value
Eric Fiselier3906a132019-06-23 20:28:29 +0000308 >
Eric Fiselier42fa85e2014-07-24 18:48:34 +0000309 >
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200310 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant62751642012-07-06 21:53:48 +0000311 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000312 : __value_(_VSTD::forward<_Tp>(__t))
Eric Fiselier869187d2018-01-24 22:14:01 +0000313 {static_assert(__can_bind_reference<_Tp&&>(),
314 "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000315
316 template <class _Tp, class _Alloc>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200317 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000318 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000319 : __value_(_VSTD::forward<_Tp>(__t))
Eric Fiselier869187d2018-01-24 22:14:01 +0000320 {static_assert(__can_bind_reference<_Tp&&>(),
321 "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000322
323 template <class _Tp, class _Alloc>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200324 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000325 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000326 : __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
Eric Fiselierca8bba12016-07-20 02:57:39 +0000327 {static_assert(!is_reference<_Hp>::value,
328 "Attempted to uses-allocator construct a reference element in a tuple");}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000329
330 template <class _Tp, class _Alloc>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200331 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000332 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000333 : __value_(_VSTD::forward<_Tp>(__t), __a)
Eric Fiselierca8bba12016-07-20 02:57:39 +0000334 {static_assert(!is_reference<_Hp>::value,
335 "Attempted to uses-allocator construct a reference element in a tuple");}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000336
Marshall Clow47fcee52014-04-21 23:48:09 +0000337 __tuple_leaf(const __tuple_leaf& __t) = default;
338 __tuple_leaf(__tuple_leaf&& __t) = default;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000339
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200340 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant89ef1212011-05-27 19:08:18 +0000341 int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000342 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000343 _VSTD::swap(*this, __t);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000344 return 0;
345 }
346
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200347 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Hui Xied1637a82022-05-12 13:23:11 +0100348 int swap(const __tuple_leaf& __t) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
349 _VSTD::swap(*this, __t);
350 return 0;
351 }
352
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200353 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _Hp& get() _NOEXCEPT {return __value_;}
354 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Hp& get() const _NOEXCEPT {return __value_;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000355};
356
357template <size_t _Ip, class _Hp>
358class __tuple_leaf<_Ip, _Hp, true>
359 : private _Hp
360{
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200361 _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000362 __tuple_leaf& operator=(const __tuple_leaf&);
363public:
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500364 _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
Howard Hinnantaabb4202012-07-06 20:50:27 +0000365 _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000366
367 template <class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500368 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000369 __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
370
371 template <class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500372 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000373 __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
374 : _Hp(allocator_arg_t(), __a) {}
375
376 template <class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500377 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000378 __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
379 : _Hp(__a) {}
380
Howard Hinnant693fc212010-09-27 17:54:17 +0000381 template <class _Tp,
Louis Dionne9ce598d2021-09-08 09:14:43 -0400382 class = __enable_if_t<
Eric Fiselier3906a132019-06-23 20:28:29 +0000383 _And<
Nikolas Klauserc9e524e2022-09-06 00:33:34 +0200384 _IsNotSame<__remove_cvref_t<_Tp>, __tuple_leaf>,
Eric Fiselier3906a132019-06-23 20:28:29 +0000385 is_constructible<_Hp, _Tp>
386 >::value
387 >
Eric Fiselier42fa85e2014-07-24 18:48:34 +0000388 >
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200389 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant62751642012-07-06 21:53:48 +0000390 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000391 : _Hp(_VSTD::forward<_Tp>(__t)) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000392
393 template <class _Tp, class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500394 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000395 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000396 : _Hp(_VSTD::forward<_Tp>(__t)) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000397
398 template <class _Tp, class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500399 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000400 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000401 : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000402
403 template <class _Tp, class _Alloc>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500404 _LIBCPP_INLINE_VISIBILITY constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000405 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000406 : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000407
Eric Fiselier42fa85e2014-07-24 18:48:34 +0000408 __tuple_leaf(__tuple_leaf const &) = default;
409 __tuple_leaf(__tuple_leaf &&) = default;
410
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200411 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant89ef1212011-05-27 19:08:18 +0000412 int
413 swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000414 {
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000415 _VSTD::swap(*this, __t);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000416 return 0;
417 }
418
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200419 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Hui Xied1637a82022-05-12 13:23:11 +0100420 int swap(const __tuple_leaf& __rhs) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
421 _VSTD::swap(*this, __rhs);
422 return 0;
423 }
424
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200425 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);}
426 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000427};
428
Howard Hinnant1c265cd2010-09-23 18:58:28 +0000429template <class ..._Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200430_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant62751642012-07-06 21:53:48 +0000431void __swallow(_Tp&&...) _NOEXCEPT {}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000432
Marshall Clowc470eae2014-10-15 10:33:02 +0000433template <class _Tp>
434struct __all_default_constructible;
Howard Hinnant89ef1212011-05-27 19:08:18 +0000435
Marshall Clowc470eae2014-10-15 10:33:02 +0000436template <class ..._Tp>
437struct __all_default_constructible<__tuple_types<_Tp...>>
438 : __all<is_default_constructible<_Tp>::value...>
439{ };
Howard Hinnant89ef1212011-05-27 19:08:18 +0000440
Howard Hinnantc51e1022010-05-11 19:42:16 +0000441// __tuple_impl
442
443template<class _Indx, class ..._Tp> struct __tuple_impl;
444
445template<size_t ..._Indx, class ..._Tp>
Eric Fiseliere3cec5f2017-01-16 21:15:08 +0000446struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000447 : public __tuple_leaf<_Indx, _Tp>...
448{
Howard Hinnant38469632012-07-06 20:39:45 +0000449 _LIBCPP_INLINE_VISIBILITY
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500450 constexpr __tuple_impl()
Howard Hinnantaabb4202012-07-06 20:50:27 +0000451 _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
Howard Hinnant38469632012-07-06 20:39:45 +0000452
Howard Hinnantc51e1022010-05-11 19:42:16 +0000453 template <size_t ..._Uf, class ..._Tf,
454 size_t ..._Ul, class ..._Tl, class ..._Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200455 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000456 explicit
457 __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
458 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
Howard Hinnant62751642012-07-06 21:53:48 +0000459 _Up&&... __u)
460 _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
461 __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000462 __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
Howard Hinnantc51e1022010-05-11 19:42:16 +0000463 __tuple_leaf<_Ul, _Tl>()...
464 {}
465
466 template <class _Alloc, size_t ..._Uf, class ..._Tf,
467 size_t ..._Ul, class ..._Tl, class ..._Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200468 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000469 explicit
470 __tuple_impl(allocator_arg_t, const _Alloc& __a,
471 __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
472 __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
473 _Up&&... __u) :
474 __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000475 _VSTD::forward<_Up>(__u))...,
Howard Hinnantc51e1022010-05-11 19:42:16 +0000476 __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
477 {}
478
479 template <class _Tuple,
Nikolas Klauser7537c9c2022-07-04 01:21:44 +0200480 class = __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000481 >
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200482 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant62751642012-07-06 21:53:48 +0000483 __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
484 typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000485 : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
486 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
Howard Hinnantc51e1022010-05-11 19:42:16 +0000487 {}
488
489 template <class _Alloc, class _Tuple,
Nikolas Klauser7537c9c2022-07-04 01:21:44 +0200490 class = __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000491 >
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200492 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000493 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
494 : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000495 typename __make_tuple_types<_Tuple>::type>::type>(), __a,
Howard Hinnantb1ad5a82011-06-30 21:18:19 +0000496 _VSTD::forward<typename tuple_element<_Indx,
497 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
Howard Hinnantc51e1022010-05-11 19:42:16 +0000498 {}
499
Howard Hinnant0d032d12013-11-06 17:45:43 +0000500 __tuple_impl(const __tuple_impl&) = default;
501 __tuple_impl(__tuple_impl&&) = default;
502
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200503 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000504 void swap(__tuple_impl& __t)
Howard Hinnant89ef1212011-05-27 19:08:18 +0000505 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000506 {
Louis Dionne6c0d5342018-07-31 11:56:20 -0400507 _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000508 }
Hui Xied1637a82022-05-12 13:23:11 +0100509
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200510 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Hui Xied1637a82022-05-12 13:23:11 +0100511 void swap(const __tuple_impl& __t) const
512 _NOEXCEPT_(__all<__is_nothrow_swappable<const _Tp>::value...>::value)
513 {
514 _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t))...);
515 }
Howard Hinnantc51e1022010-05-11 19:42:16 +0000516};
517
Louis Dionne6c0d5342018-07-31 11:56:20 -0400518template<class _Dest, class _Source, size_t ..._Np>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200519_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne6c0d5342018-07-31 11:56:20 -0400520void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
521 _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
522}
Eric Fiselier264d04a2016-04-15 18:05:59 +0000523
Louis Dionne6c0d5342018-07-31 11:56:20 -0400524template<class _Dest, class _Source, class ..._Up, size_t ..._Np>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200525_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne6c0d5342018-07-31 11:56:20 -0400526void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
527 _VSTD::__swallow(((
Louis Dionne3b8af4d2021-02-24 14:53:21 -0500528 _VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(__source))
Louis Dionne6c0d5342018-07-31 11:56:20 -0400529 ), void(), 0)...);
530}
Eric Fiselier264d04a2016-04-15 18:05:59 +0000531
Howard Hinnantc51e1022010-05-11 19:42:16 +0000532template <class ..._Tp>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000533class _LIBCPP_TEMPLATE_VIS tuple
Howard Hinnantc51e1022010-05-11 19:42:16 +0000534{
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000535 typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000536
Eric Fiselier3e0d4372017-06-01 02:14:21 +0000537 _BaseT __base_;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000538
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200539 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant28b24882011-12-01 20:21:04 +0000540 typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200541 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant28b24882011-12-01 20:21:04 +0000542 const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200543 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant28b24882011-12-01 20:21:04 +0000544 typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200545 template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
Eric Fiselier6dea8092015-12-18 00:36:55 +0000546 const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000547public:
Louis Dionne574e2e32021-02-10 16:19:50 -0500548 // [tuple.cnstr]
Howard Hinnantc51e1022010-05-11 19:42:16 +0000549
Louis Dionne574e2e32021-02-10 16:19:50 -0500550 // tuple() constructors (including allocator_arg_t variants)
Louis Dionne9ce598d2021-09-08 09:14:43 -0400551 template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500552 _And<
553 _IsImpDefault<_Tp>... // explicit check
554 >::value
555 , int> = 0>
Louis Dionne58bca852021-04-30 15:52:26 -0400556 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Louis Dionnea7a2beb2019-09-26 14:51:10 +0000557 tuple()
Louis Dionne574e2e32021-02-10 16:19:50 -0500558 _NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
559 { }
Louis Dionnea7a2beb2019-09-26 14:51:10 +0000560
Louis Dionne574e2e32021-02-10 16:19:50 -0500561 template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
Louis Dionne9ce598d2021-09-08 09:14:43 -0400562 template<class...> class _IsDefault = is_default_constructible, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500563 _And<
564 _IsDefault<_Tp>...,
565 _Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
566 >::value
567 , int> = 0>
568 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
569 explicit tuple()
570 _NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
571 { }
Howard Hinnant38469632012-07-06 20:39:45 +0000572
Louis Dionne9ce598d2021-09-08 09:14:43 -0400573 template <class _Alloc, template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500574 _And<
575 _IsImpDefault<_Tp>... // explicit check
576 >::value
577 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200578 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500579 tuple(allocator_arg_t, _Alloc const& __a)
580 : __base_(allocator_arg_t(), __a,
581 __tuple_indices<>(), __tuple_types<>(),
582 typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
583 __tuple_types<_Tp...>()) {}
584
585 template <class _Alloc,
586 template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
Louis Dionne9ce598d2021-09-08 09:14:43 -0400587 template<class...> class _IsDefault = is_default_constructible, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500588 _And<
589 _IsDefault<_Tp>...,
590 _Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
591 >::value
592 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200593 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500594 explicit tuple(allocator_arg_t, _Alloc const& __a)
595 : __base_(allocator_arg_t(), __a,
596 __tuple_indices<>(), __tuple_types<>(),
597 typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
598 __tuple_types<_Tp...>()) {}
599
600 // tuple(const T&...) constructors (including allocator_arg_t variants)
Louis Dionne9ce598d2021-09-08 09:14:43 -0400601 template <template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500602 _And<
603 _BoolConstant<sizeof...(_Tp) >= 1>,
604 is_copy_constructible<_Tp>...,
605 is_convertible<const _Tp&, _Tp>... // explicit check
606 >::value
607 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200608 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500609 tuple(const _Tp& ... __t)
610 _NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
611 : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
612 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
613 typename __make_tuple_indices<0>::type(),
614 typename __make_tuple_types<tuple, 0>::type(),
615 __t...
616 ) {}
617
Louis Dionne9ce598d2021-09-08 09:14:43 -0400618 template <template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500619 _And<
620 _BoolConstant<sizeof...(_Tp) >= 1>,
621 is_copy_constructible<_Tp>...,
622 _Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
623 >::value
624 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200625 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500626 explicit tuple(const _Tp& ... __t)
627 _NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
628 : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
629 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
630 typename __make_tuple_indices<0>::type(),
631 typename __make_tuple_types<tuple, 0>::type(),
632 __t...
633 ) {}
634
Louis Dionne9ce598d2021-09-08 09:14:43 -0400635 template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500636 _And<
637 _BoolConstant<sizeof...(_Tp) >= 1>,
638 is_copy_constructible<_Tp>...,
639 is_convertible<const _Tp&, _Tp>... // explicit check
640 >::value
641 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200642 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500643 tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
644 : __base_(allocator_arg_t(), __a,
645 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
646 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
647 typename __make_tuple_indices<0>::type(),
648 typename __make_tuple_types<tuple, 0>::type(),
649 __t...
650 ) {}
651
Louis Dionne9ce598d2021-09-08 09:14:43 -0400652 template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500653 _And<
654 _BoolConstant<sizeof...(_Tp) >= 1>,
655 is_copy_constructible<_Tp>...,
656 _Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
657 >::value
658 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200659 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500660 explicit tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
661 : __base_(allocator_arg_t(), __a,
662 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
663 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
664 typename __make_tuple_indices<0>::type(),
665 typename __make_tuple_types<tuple, 0>::type(),
666 __t...
667 ) {}
668
669 // tuple(U&& ...) constructors (including allocator_arg_t variants)
670 template <class ..._Up> struct _IsThisTuple : false_type { };
Nikolas Klauserc9e524e2022-09-06 00:33:34 +0200671 template <class _Up> struct _IsThisTuple<_Up> : is_same<__remove_cvref_t<_Up>, tuple> { };
Louis Dionne574e2e32021-02-10 16:19:50 -0500672
673 template <class ..._Up>
674 struct _EnableUTypesCtor : _And<
675 _BoolConstant<sizeof...(_Tp) >= 1>,
676 _Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors
677 is_constructible<_Tp, _Up>...
678 > { };
679
Louis Dionne9ce598d2021-09-08 09:14:43 -0400680 template <class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500681 _And<
682 _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
683 _EnableUTypesCtor<_Up...>,
684 is_convertible<_Up, _Tp>... // explicit check
685 >::value
686 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200687 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500688 tuple(_Up&&... __u)
689 _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
690 : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
691 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
692 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
693 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
694 _VSTD::forward<_Up>(__u)...) {}
695
Louis Dionne9ce598d2021-09-08 09:14:43 -0400696 template <class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500697 _And<
698 _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
699 _EnableUTypesCtor<_Up...>,
700 _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
701 >::value
702 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200703 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500704 explicit tuple(_Up&&... __u)
705 _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
706 : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
707 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
708 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
709 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
710 _VSTD::forward<_Up>(__u)...) {}
711
Louis Dionne9ce598d2021-09-08 09:14:43 -0400712 template <class _Alloc, class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500713 _And<
714 _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
715 _EnableUTypesCtor<_Up...>,
716 is_convertible<_Up, _Tp>... // explicit check
717 >::value
718 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200719 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500720 tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
721 : __base_(allocator_arg_t(), __a,
722 typename __make_tuple_indices<sizeof...(_Up)>::type(),
723 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
724 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
725 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
726 _VSTD::forward<_Up>(__u)...) {}
727
Louis Dionne9ce598d2021-09-08 09:14:43 -0400728 template <class _Alloc, class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500729 _And<
730 _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
731 _EnableUTypesCtor<_Up...>,
732 _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
733 >::value
734 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200735 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500736 explicit tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
737 : __base_(allocator_arg_t(), __a,
738 typename __make_tuple_indices<sizeof...(_Up)>::type(),
739 typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
740 typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
741 typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
742 _VSTD::forward<_Up>(__u)...) {}
743
744 // Copy and move constructors (including the allocator_arg_t variants)
745 tuple(const tuple&) = default;
Eric Fiselier737a16d2016-07-25 02:36:42 +0000746 tuple(tuple&&) = default;
747
Louis Dionne9ce598d2021-09-08 09:14:43 -0400748 template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500749 _And<is_copy_constructible<_Tp>...>::value
750 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200751 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500752 tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
753 : __base_(allocator_arg_t(), __alloc, __t)
754 { }
755
Louis Dionne9ce598d2021-09-08 09:14:43 -0400756 template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500757 _And<is_move_constructible<_Tp>...>::value
758 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200759 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500760 tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
761 : __base_(allocator_arg_t(), __alloc, _VSTD::move(__t))
762 { }
763
764 // tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
Louis Dionne76450ee2022-06-27 09:36:52 -0400765
Nikolas Klauserc9e524e2022-09-06 00:33:34 +0200766 template <class _OtherTuple, class _DecayedOtherTuple = __remove_cvref_t<_OtherTuple>, class = void>
Hui Xied1637a82022-05-12 13:23:11 +0100767 struct _EnableCtorFromUTypesTuple : false_type {};
768
769 template <class _OtherTuple, class... _Up>
Louis Dionne76450ee2022-06-27 09:36:52 -0400770 struct _EnableCtorFromUTypesTuple<_OtherTuple, tuple<_Up...>,
Hui Xied1637a82022-05-12 13:23:11 +0100771 // the length of the packs needs to checked first otherwise the 2 packs cannot be expanded simultaneously below
772 __enable_if_t<sizeof...(_Up) == sizeof...(_Tp)>> : _And<
773 // the two conditions below are not in spec. The purpose is to disable the UTypes Ctor when copy/move Ctor can work.
774 // Otherwise, is_constructible can trigger hard error in those cases https://godbolt.org/z/M94cGdKcE
775 _Not<is_same<_OtherTuple, const tuple&> >,
776 _Not<is_same<_OtherTuple, tuple&&> >,
777 is_constructible<_Tp, __copy_cvref_t<_OtherTuple, _Up> >...,
778 _Lazy<_Or, _BoolConstant<sizeof...(_Tp) != 1>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500779 // _Tp and _Up are 1-element packs - the pack expansions look
780 // weird to avoid tripping up the type traits in degenerate cases
781 _Lazy<_And,
Hui Xied1637a82022-05-12 13:23:11 +0100782 _Not<is_same<_Tp, _Up> >...,
783 _Not<is_convertible<_OtherTuple, _Tp> >...,
784 _Not<is_constructible<_Tp, _OtherTuple> >...
Louis Dionne574e2e32021-02-10 16:19:50 -0500785 >
Hui Xied1637a82022-05-12 13:23:11 +0100786 >
787 > {};
Louis Dionne574e2e32021-02-10 16:19:50 -0500788
Louis Dionne9ce598d2021-09-08 09:14:43 -0400789 template <class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500790 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100791 _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500792 is_convertible<const _Up&, _Tp>... // explicit check
793 >::value
794 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200795 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500796 tuple(const tuple<_Up...>& __t)
797 _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
798 : __base_(__t)
799 { }
800
Louis Dionne9ce598d2021-09-08 09:14:43 -0400801 template <class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500802 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100803 _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500804 _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
805 >::value
806 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200807 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500808 explicit tuple(const tuple<_Up...>& __t)
809 _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
810 : __base_(__t)
811 { }
812
Louis Dionne9ce598d2021-09-08 09:14:43 -0400813 template <class ..._Up, class _Alloc, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500814 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100815 _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500816 is_convertible<const _Up&, _Tp>... // explicit check
817 >::value
818 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200819 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500820 tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
821 : __base_(allocator_arg_t(), __a, __t)
822 { }
Eric Fiselierc170df52016-04-15 03:29:40 +0000823
Louis Dionne9ce598d2021-09-08 09:14:43 -0400824 template <class ..._Up, class _Alloc, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500825 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100826 _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500827 _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
828 >::value
829 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200830 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500831 explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
832 : __base_(allocator_arg_t(), __a, __t)
833 { }
Louis Dionne668a50c2019-09-27 15:06:52 +0000834
Hui Xied1637a82022-05-12 13:23:11 +0100835#if _LIBCPP_STD_VER > 20
836 // tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
837
838 template <class... _Up, enable_if_t<
839 _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
840 _LIBCPP_HIDE_FROM_ABI constexpr
841 explicit(!(is_convertible_v<_Up&, _Tp> && ...))
842 tuple(tuple<_Up...>& __t) : __base_(__t) {}
843
844 template <class _Alloc, class... _Up, enable_if_t<
845 _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
846 _LIBCPP_HIDE_FROM_ABI constexpr
847 explicit(!(is_convertible_v<_Up&, _Tp> && ...))
848 tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t) : __base_(allocator_arg_t(), __alloc, __t) {}
849#endif // _LIBCPP_STD_VER > 20
850
Louis Dionne574e2e32021-02-10 16:19:50 -0500851 // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
Louis Dionne574e2e32021-02-10 16:19:50 -0500852
Louis Dionne9ce598d2021-09-08 09:14:43 -0400853 template <class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500854 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100855 _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500856 is_convertible<_Up, _Tp>... // explicit check
857 >::value
858 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200859 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500860 tuple(tuple<_Up...>&& __t)
861 _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
862 : __base_(_VSTD::move(__t))
863 { }
Howard Hinnantc51e1022010-05-11 19:42:16 +0000864
Louis Dionne9ce598d2021-09-08 09:14:43 -0400865 template <class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500866 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100867 _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500868 _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
869 >::value
870 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200871 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500872 explicit tuple(tuple<_Up...>&& __t)
873 _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
874 : __base_(_VSTD::move(__t))
875 { }
Eric Fiselier8e6a5f02016-04-19 01:19:25 +0000876
Louis Dionne9ce598d2021-09-08 09:14:43 -0400877 template <class _Alloc, class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500878 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100879 _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500880 is_convertible<_Up, _Tp>... // explicit check
881 >::value
882 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200883 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500884 tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
885 : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
886 { }
Howard Hinnantc51e1022010-05-11 19:42:16 +0000887
Louis Dionne9ce598d2021-09-08 09:14:43 -0400888 template <class _Alloc, class ..._Up, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500889 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100890 _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
Louis Dionne574e2e32021-02-10 16:19:50 -0500891 _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
892 >::value
893 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200894 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500895 explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
896 : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
897 { }
Eric Fiselier8e6a5f02016-04-19 01:19:25 +0000898
Hui Xied1637a82022-05-12 13:23:11 +0100899#if _LIBCPP_STD_VER > 20
900 // tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
Hui Xiea3ac9222022-05-12 13:23:11 +0100901
Hui Xied1637a82022-05-12 13:23:11 +0100902 template <class... _Up, enable_if_t<
903 _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
904 _LIBCPP_HIDE_FROM_ABI constexpr
905 explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
906 tuple(const tuple<_Up...>&& __t) : __base_(std::move(__t)) {}
907
908 template <class _Alloc, class... _Up, enable_if_t<
909 _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
910 _LIBCPP_HIDE_FROM_ABI constexpr
911 explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
912 tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
913 : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
914#endif // _LIBCPP_STD_VER > 20
915
916 // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
917
Nikolas Klauserc9e524e2022-09-06 00:33:34 +0200918 template <template <class...> class Pred, class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
Hui Xied1637a82022-05-12 13:23:11 +0100919 struct _CtorPredicateFromPair : false_type{};
920
921 template <template <class...> class Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
922 struct _CtorPredicateFromPair<Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
923 Pred<_Tp1, __copy_cvref_t<_Pair, _Up1> >,
924 Pred<_Tp2, __copy_cvref_t<_Pair, _Up2> >
925 > {};
926
927 template <class _Pair>
928 struct _EnableCtorFromPair : _CtorPredicateFromPair<is_constructible, _Pair>{};
929
930 template <class _Pair>
931 struct _NothrowConstructibleFromPair : _CtorPredicateFromPair<is_nothrow_constructible, _Pair>{};
932
Nikolas Klauserc9e524e2022-09-06 00:33:34 +0200933 template <class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
Hui Xied1637a82022-05-12 13:23:11 +0100934 struct _BothImplicitlyConvertible : false_type{};
935
936 template <class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
937 struct _BothImplicitlyConvertible<_Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
938 is_convertible<__copy_cvref_t<_Pair, _Up1>, _Tp1>,
939 is_convertible<__copy_cvref_t<_Pair, _Up2>, _Tp2>
940 > {};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000941
Louis Dionne9ce598d2021-09-08 09:14:43 -0400942 template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500943 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100944 _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
945 _BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check
Louis Dionne574e2e32021-02-10 16:19:50 -0500946 >::value
947 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200948 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500949 tuple(const pair<_Up1, _Up2>& __p)
Hui Xied1637a82022-05-12 13:23:11 +0100950 _NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value))
Louis Dionne574e2e32021-02-10 16:19:50 -0500951 : __base_(__p)
952 { }
Howard Hinnantc51e1022010-05-11 19:42:16 +0000953
Louis Dionne9ce598d2021-09-08 09:14:43 -0400954 template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500955 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100956 _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
957 _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
Louis Dionne574e2e32021-02-10 16:19:50 -0500958 >::value
959 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200960 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -0500961 explicit tuple(const pair<_Up1, _Up2>& __p)
Hui Xied1637a82022-05-12 13:23:11 +0100962 _NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value))
Louis Dionne574e2e32021-02-10 16:19:50 -0500963 : __base_(__p)
964 { }
Eric Fiselier8e6a5f02016-04-19 01:19:25 +0000965
Louis Dionne9ce598d2021-09-08 09:14:43 -0400966 template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500967 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100968 _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
969 _BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check
Louis Dionne574e2e32021-02-10 16:19:50 -0500970 >::value
971 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200972 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500973 tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
974 : __base_(allocator_arg_t(), __a, __p)
975 { }
Howard Hinnantc51e1022010-05-11 19:42:16 +0000976
Louis Dionne9ce598d2021-09-08 09:14:43 -0400977 template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -0500978 _And<
Hui Xied1637a82022-05-12 13:23:11 +0100979 _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
980 _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
Louis Dionne574e2e32021-02-10 16:19:50 -0500981 >::value
982 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +0200983 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -0500984 explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
985 : __base_(allocator_arg_t(), __a, __p)
986 { }
Howard Hinnant65704d02012-04-01 23:10:42 +0000987
Hui Xied1637a82022-05-12 13:23:11 +0100988#if _LIBCPP_STD_VER > 20
989 // tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
Hui Xie39360e22022-06-23 21:54:23 +0100990
Hui Xied1637a82022-05-12 13:23:11 +0100991 template <class _U1, class _U2, enable_if_t<
992 _EnableCtorFromPair<pair<_U1, _U2>&>::value>* = nullptr>
993 _LIBCPP_HIDE_FROM_ABI constexpr
994 explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
995 tuple(pair<_U1, _U2>& __p) : __base_(__p) {}
996
997 template <class _Alloc, class _U1, class _U2, enable_if_t<
998 _EnableCtorFromPair<std::pair<_U1, _U2>&>::value>* = nullptr>
999 _LIBCPP_HIDE_FROM_ABI constexpr
1000 explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
1001 tuple(allocator_arg_t, const _Alloc& __alloc, pair<_U1, _U2>& __p) : __base_(allocator_arg_t(), __alloc, __p) {}
1002#endif
1003
1004 // tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001005
Louis Dionne9ce598d2021-09-08 09:14:43 -04001006 template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -05001007 _And<
Hui Xied1637a82022-05-12 13:23:11 +01001008 _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
1009 _BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check
Louis Dionne574e2e32021-02-10 16:19:50 -05001010 >::value
1011 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001012 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -05001013 tuple(pair<_Up1, _Up2>&& __p)
Hui Xied1637a82022-05-12 13:23:11 +01001014 _NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value))
Louis Dionne574e2e32021-02-10 16:19:50 -05001015 : __base_(_VSTD::move(__p))
1016 { }
1017
Louis Dionne9ce598d2021-09-08 09:14:43 -04001018 template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -05001019 _And<
Hui Xied1637a82022-05-12 13:23:11 +01001020 _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
1021 _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
Louis Dionne574e2e32021-02-10 16:19:50 -05001022 >::value
1023 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001024 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionne574e2e32021-02-10 16:19:50 -05001025 explicit tuple(pair<_Up1, _Up2>&& __p)
Hui Xied1637a82022-05-12 13:23:11 +01001026 _NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value))
Louis Dionne574e2e32021-02-10 16:19:50 -05001027 : __base_(_VSTD::move(__p))
1028 { }
1029
Louis Dionne9ce598d2021-09-08 09:14:43 -04001030 template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -05001031 _And<
Hui Xied1637a82022-05-12 13:23:11 +01001032 _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
1033 _BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check
Louis Dionne574e2e32021-02-10 16:19:50 -05001034 >::value
1035 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001036 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -05001037 tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
1038 : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
1039 { }
1040
Louis Dionne9ce598d2021-09-08 09:14:43 -04001041 template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
Louis Dionne574e2e32021-02-10 16:19:50 -05001042 _And<
Hui Xied1637a82022-05-12 13:23:11 +01001043 _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
1044 _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
Louis Dionne574e2e32021-02-10 16:19:50 -05001045 >::value
1046 , int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001047 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne574e2e32021-02-10 16:19:50 -05001048 explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
1049 : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
1050 { }
Eric Fiselier8e6a5f02016-04-19 01:19:25 +00001051
Hui Xied1637a82022-05-12 13:23:11 +01001052#if _LIBCPP_STD_VER > 20
1053 // tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)
1054
1055 template <class _U1, class _U2, enable_if_t<
1056 _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
1057 _LIBCPP_HIDE_FROM_ABI constexpr
1058 explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
1059 tuple(const pair<_U1, _U2>&& __p) : __base_(std::move(__p)) {}
1060
1061 template <class _Alloc, class _U1, class _U2, enable_if_t<
1062 _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
1063 _LIBCPP_HIDE_FROM_ABI constexpr
1064 explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
1065 tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p)
1066 : __base_(allocator_arg_t(), __alloc, std::move(__p)) {}
1067#endif // _LIBCPP_STD_VER > 20
1068
Louis Dionne6c0d5342018-07-31 11:56:20 -04001069 // [tuple.assign]
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001070 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne6c0d5342018-07-31 11:56:20 -04001071 tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
1072 _NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
Eric Fiselier737a16d2016-07-25 02:36:42 +00001073 {
Louis Dionne6c0d5342018-07-31 11:56:20 -04001074 _VSTD::__memberwise_copy_assign(*this, __tuple,
1075 typename __make_tuple_indices<sizeof...(_Tp)>::type());
Eric Fiselier737a16d2016-07-25 02:36:42 +00001076 return *this;
1077 }
1078
Hui Xied1637a82022-05-12 13:23:11 +01001079#if _LIBCPP_STD_VER > 20
1080 _LIBCPP_HIDE_FROM_ABI constexpr
1081 const tuple& operator=(tuple const& __tuple) const
1082 requires (_And<is_copy_assignable<const _Tp>...>::value) {
1083 std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());
1084 return *this;
1085 }
1086
1087 _LIBCPP_HIDE_FROM_ABI constexpr
1088 const tuple& operator=(tuple&& __tuple) const
1089 requires (_And<is_assignable<const _Tp&, _Tp>...>::value) {
1090 std::__memberwise_forward_assign(*this,
1091 std::move(__tuple),
1092 __tuple_types<_Tp...>(),
1093 typename __make_tuple_indices<sizeof...(_Tp)>::type());
1094 return *this;
1095 }
1096#endif // _LIBCPP_STD_VER > 20
1097
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001098 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne6c0d5342018-07-31 11:56:20 -04001099 tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
1100 _NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value))
Eric Fiselier737a16d2016-07-25 02:36:42 +00001101 {
Louis Dionne6c0d5342018-07-31 11:56:20 -04001102 _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
1103 __tuple_types<_Tp...>(),
1104 typename __make_tuple_indices<sizeof...(_Tp)>::type());
Eric Fiselier737a16d2016-07-25 02:36:42 +00001105 return *this;
1106 }
1107
Louis Dionne9ce598d2021-09-08 09:14:43 -04001108 template<class... _Up, __enable_if_t<
Louis Dionne6c0d5342018-07-31 11:56:20 -04001109 _And<
1110 _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
1111 is_assignable<_Tp&, _Up const&>...
1112 >::value
1113 ,int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001114 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne6c0d5342018-07-31 11:56:20 -04001115 tuple& operator=(tuple<_Up...> const& __tuple)
1116 _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
1117 {
1118 _VSTD::__memberwise_copy_assign(*this, __tuple,
1119 typename __make_tuple_indices<sizeof...(_Tp)>::type());
1120 return *this;
1121 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001122
Louis Dionne9ce598d2021-09-08 09:14:43 -04001123 template<class... _Up, __enable_if_t<
Louis Dionne6c0d5342018-07-31 11:56:20 -04001124 _And<
1125 _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
1126 is_assignable<_Tp&, _Up>...
1127 >::value
1128 ,int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001129 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne6c0d5342018-07-31 11:56:20 -04001130 tuple& operator=(tuple<_Up...>&& __tuple)
1131 _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
1132 {
1133 _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
1134 __tuple_types<_Up...>(),
1135 typename __make_tuple_indices<sizeof...(_Tp)>::type());
1136 return *this;
1137 }
1138
Hui Xied1637a82022-05-12 13:23:11 +01001139
1140#if _LIBCPP_STD_VER > 20
1141 template <class... _UTypes, enable_if_t<
1142 _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
1143 is_assignable<const _Tp&, const _UTypes&>...>::value>* = nullptr>
1144 _LIBCPP_HIDE_FROM_ABI constexpr
1145 const tuple& operator=(const tuple<_UTypes...>& __u) const {
1146 std::__memberwise_copy_assign(*this,
1147 __u,
1148 typename __make_tuple_indices<sizeof...(_Tp)>::type());
1149 return *this;
1150 }
1151
1152 template <class... _UTypes, enable_if_t<
1153 _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
1154 is_assignable<const _Tp&, _UTypes>...>::value>* = nullptr>
1155 _LIBCPP_HIDE_FROM_ABI constexpr
1156 const tuple& operator=(tuple<_UTypes...>&& __u) const {
1157 std::__memberwise_forward_assign(*this,
1158 __u,
1159 __tuple_types<_UTypes...>(),
1160 typename __make_tuple_indices<sizeof...(_Tp)>::type());
1161 return *this;
1162 }
1163#endif // _LIBCPP_STD_VER > 20
1164
Louis Dionne76450ee2022-06-27 09:36:52 -04001165 template <template<class...> class Pred, bool _Const,
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001166 class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
Hui Xied1637a82022-05-12 13:23:11 +01001167 struct _AssignPredicateFromPair : false_type {};
1168
Louis Dionne76450ee2022-06-27 09:36:52 -04001169 template <template<class...> class Pred, bool _Const,
Hui Xied1637a82022-05-12 13:23:11 +01001170 class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
Louis Dionne76450ee2022-06-27 09:36:52 -04001171 struct _AssignPredicateFromPair<Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > :
Hui Xied1637a82022-05-12 13:23:11 +01001172 _And<Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >,
1173 Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> >
1174 > {};
1175
1176 template <bool _Const, class _Pair>
1177 struct _EnableAssignFromPair : _AssignPredicateFromPair<is_assignable, _Const, _Pair> {};
1178
1179 template <bool _Const, class _Pair>
1180 struct _NothrowAssignFromPair : _AssignPredicateFromPair<is_nothrow_assignable, _Const, _Pair> {};
1181
1182#if _LIBCPP_STD_VER > 20
1183 template <class _U1, class _U2, enable_if_t<
1184 _EnableAssignFromPair<true, const pair<_U1, _U2>&>::value>* = nullptr>
1185 _LIBCPP_HIDE_FROM_ABI constexpr
1186 const tuple& operator=(const pair<_U1, _U2>& __pair) const
1187 noexcept(_NothrowAssignFromPair<true, const pair<_U1, _U2>&>::value) {
1188 std::get<0>(*this) = __pair.first;
1189 std::get<1>(*this) = __pair.second;
1190 return *this;
1191 }
1192
1193 template <class _U1, class _U2, enable_if_t<
1194 _EnableAssignFromPair<true, pair<_U1, _U2>&&>::value>* = nullptr>
1195 _LIBCPP_HIDE_FROM_ABI constexpr
1196 const tuple& operator=(pair<_U1, _U2>&& __pair) const
1197 noexcept(_NothrowAssignFromPair<true, pair<_U1, _U2>&&>::value) {
1198 std::get<0>(*this) = std::move(__pair.first);
1199 std::get<1>(*this) = std::move(__pair.second);
1200 return *this;
1201 }
1202#endif // _LIBCPP_STD_VER > 20
1203
1204 template<class _Up1, class _Up2, __enable_if_t<
1205 _EnableAssignFromPair<false, pair<_Up1, _Up2> const&>::value
Louis Dionne6c0d5342018-07-31 11:56:20 -04001206 ,int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001207 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne6c0d5342018-07-31 11:56:20 -04001208 tuple& operator=(pair<_Up1, _Up2> const& __pair)
Hui Xied1637a82022-05-12 13:23:11 +01001209 _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2> const&>::value))
Louis Dionne6c0d5342018-07-31 11:56:20 -04001210 {
1211 _VSTD::get<0>(*this) = __pair.first;
1212 _VSTD::get<1>(*this) = __pair.second;
1213 return *this;
1214 }
1215
Hui Xied1637a82022-05-12 13:23:11 +01001216 template<class _Up1, class _Up2, __enable_if_t<
1217 _EnableAssignFromPair<false, pair<_Up1, _Up2>&&>::value
Louis Dionne6c0d5342018-07-31 11:56:20 -04001218 ,int> = 0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001219 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne6c0d5342018-07-31 11:56:20 -04001220 tuple& operator=(pair<_Up1, _Up2>&& __pair)
Hui Xied1637a82022-05-12 13:23:11 +01001221 _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2>&&>::value))
Louis Dionne6c0d5342018-07-31 11:56:20 -04001222 {
Louis Dionne3b8af4d2021-02-24 14:53:21 -05001223 _VSTD::get<0>(*this) = _VSTD::forward<_Up1>(__pair.first);
1224 _VSTD::get<1>(*this) = _VSTD::forward<_Up2>(__pair.second);
Louis Dionne6c0d5342018-07-31 11:56:20 -04001225 return *this;
1226 }
1227
1228 // EXTENSION
Louis Dionne9ce598d2021-09-08 09:14:43 -04001229 template<class _Up, size_t _Np, class = __enable_if_t<
Louis Dionne6c0d5342018-07-31 11:56:20 -04001230 _And<
1231 _BoolConstant<_Np == sizeof...(_Tp)>,
1232 is_assignable<_Tp&, _Up const&>...
1233 >::value
1234 > >
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001235 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne6c0d5342018-07-31 11:56:20 -04001236 tuple& operator=(array<_Up, _Np> const& __array)
1237 _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
1238 {
1239 _VSTD::__memberwise_copy_assign(*this, __array,
1240 typename __make_tuple_indices<sizeof...(_Tp)>::type());
1241 return *this;
1242 }
1243
1244 // EXTENSION
Louis Dionne9ce598d2021-09-08 09:14:43 -04001245 template<class _Up, size_t _Np, class = void, class = __enable_if_t<
Louis Dionne6c0d5342018-07-31 11:56:20 -04001246 _And<
1247 _BoolConstant<_Np == sizeof...(_Tp)>,
1248 is_assignable<_Tp&, _Up>...
1249 >::value
1250 > >
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001251 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Louis Dionne6c0d5342018-07-31 11:56:20 -04001252 tuple& operator=(array<_Up, _Np>&& __array)
1253 _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
1254 {
1255 _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__array),
1256 __tuple_types<_If<true, _Up, _Tp>...>(),
1257 typename __make_tuple_indices<sizeof...(_Tp)>::type());
1258 return *this;
1259 }
1260
1261 // [tuple.swap]
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001262 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Howard Hinnant89ef1212011-05-27 19:08:18 +00001263 void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
Eric Fiselier3e0d4372017-06-01 02:14:21 +00001264 {__base_.swap(__t.__base_);}
Hui Xied1637a82022-05-12 13:23:11 +01001265
1266#if _LIBCPP_STD_VER > 20
1267 _LIBCPP_HIDE_FROM_ABI constexpr
1268 void swap(const tuple& __t) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
1269 __base_.swap(__t.__base_);
1270 }
1271#endif // _LIBCPP_STD_VER > 20
Howard Hinnantc51e1022010-05-11 19:42:16 +00001272};
1273
1274template <>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001275class _LIBCPP_TEMPLATE_VIS tuple<>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001276{
1277public:
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -05001278 _LIBCPP_INLINE_VISIBILITY constexpr
1279 tuple() _NOEXCEPT = default;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001280 template <class _Alloc>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001281 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Howard Hinnant62751642012-07-06 21:53:48 +00001282 tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001283 template <class _Alloc>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001284 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Howard Hinnant62751642012-07-06 21:53:48 +00001285 tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
Howard Hinnantc834c512011-11-29 18:15:50 +00001286 template <class _Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001287 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Howard Hinnant62751642012-07-06 21:53:48 +00001288 tuple(array<_Up, 0>) _NOEXCEPT {}
Howard Hinnantc834c512011-11-29 18:15:50 +00001289 template <class _Alloc, class _Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001290 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Howard Hinnant62751642012-07-06 21:53:48 +00001291 tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001292 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Howard Hinnant89ef1212011-05-27 19:08:18 +00001293 void swap(tuple&) _NOEXCEPT {}
Hui Xied1637a82022-05-12 13:23:11 +01001294#if _LIBCPP_STD_VER > 20
1295 _LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
1296#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001297};
1298
Joe Loserd9b3d972022-03-12 10:46:57 -05001299#if _LIBCPP_STD_VER > 20
Nikolas Klauserad26ba52022-01-17 19:45:42 +01001300template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual>
1301 requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
1302struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> {
1303 using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
1304};
1305
1306template <class... _TTypes, class... _UTypes>
1307 requires requires { typename tuple<common_type_t<_TTypes, _UTypes>...>; }
1308struct common_type<tuple<_TTypes...>, tuple<_UTypes...>> {
1309 using type = tuple<common_type_t<_TTypes, _UTypes>...>;
1310};
Joe Loserd9b3d972022-03-12 10:46:57 -05001311#endif // _LIBCPP_STD_VER > 20
Nikolas Klauserad26ba52022-01-17 19:45:42 +01001312
1313#if _LIBCPP_STD_VER > 14
Louis Dionne616da2a2019-08-12 18:30:31 +00001314template <class ..._Tp>
1315tuple(_Tp...) -> tuple<_Tp...>;
1316template <class _Tp1, class _Tp2>
1317tuple(pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
1318template <class _Alloc, class ..._Tp>
1319tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>;
1320template <class _Alloc, class _Tp1, class _Tp2>
1321tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
1322template <class _Alloc, class ..._Tp>
1323tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;
Eric Fiselier9a5075c2017-06-08 07:18:17 +00001324#endif
1325
Howard Hinnantc51e1022010-05-11 19:42:16 +00001326template <class ..._Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001327inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Nikolas Klauser7537c9c2022-07-04 01:21:44 +02001328__enable_if_t<__all<__is_swappable<_Tp>::value...>::value, void>
Howard Hinnant89ef1212011-05-27 19:08:18 +00001329swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
1330 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
1331 {__t.swap(__u);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001332
Hui Xied1637a82022-05-12 13:23:11 +01001333#if _LIBCPP_STD_VER > 20
1334template <class... _Tp>
1335_LIBCPP_HIDE_FROM_ABI constexpr
1336enable_if_t<__all<is_swappable_v<const _Tp>...>::value, void>
1337swap(const tuple<_Tp...>& __lhs, const tuple<_Tp...>& __rhs)
1338 noexcept(__all<is_nothrow_swappable_v<const _Tp>...>::value) {
1339 __lhs.swap(__rhs);
1340}
1341#endif
1342
Howard Hinnantc51e1022010-05-11 19:42:16 +00001343// get
1344
1345template <size_t _Ip, class ..._Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001346inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant3a47c3d2011-01-24 16:07:25 +00001347typename tuple_element<_Ip, tuple<_Tp...> >::type&
Howard Hinnant28b24882011-12-01 20:21:04 +00001348get(tuple<_Tp...>& __t) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001349{
Louis Dionnea6c4ace2021-08-31 10:32:11 -04001350 typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
Eric Fiselier3e0d4372017-06-01 02:14:21 +00001351 return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
Howard Hinnantc51e1022010-05-11 19:42:16 +00001352}
1353
1354template <size_t _Ip, class ..._Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001355inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant3a47c3d2011-01-24 16:07:25 +00001356const typename tuple_element<_Ip, tuple<_Tp...> >::type&
Howard Hinnant28b24882011-12-01 20:21:04 +00001357get(const tuple<_Tp...>& __t) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001358{
Louis Dionnea6c4ace2021-08-31 10:32:11 -04001359 typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
Eric Fiselier3e0d4372017-06-01 02:14:21 +00001360 return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
Howard Hinnantc51e1022010-05-11 19:42:16 +00001361}
1362
Howard Hinnant22e97242010-11-17 19:52:17 +00001363template <size_t _Ip, class ..._Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001364inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant3a47c3d2011-01-24 16:07:25 +00001365typename tuple_element<_Ip, tuple<_Tp...> >::type&&
Howard Hinnant28b24882011-12-01 20:21:04 +00001366get(tuple<_Tp...>&& __t) _NOEXCEPT
Howard Hinnant22e97242010-11-17 19:52:17 +00001367{
Louis Dionnea6c4ace2021-08-31 10:32:11 -04001368 typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
Howard Hinnantb574f9a2011-01-25 16:31:30 +00001369 return static_cast<type&&>(
Eric Fiselier3e0d4372017-06-01 02:14:21 +00001370 static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
Howard Hinnant22e97242010-11-17 19:52:17 +00001371}
1372
Eric Fiselier6dea8092015-12-18 00:36:55 +00001373template <size_t _Ip, class ..._Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001374inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Eric Fiselier6dea8092015-12-18 00:36:55 +00001375const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
1376get(const tuple<_Tp...>&& __t) _NOEXCEPT
1377{
Louis Dionnea6c4ace2021-08-31 10:32:11 -04001378 typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
Eric Fiselier6dea8092015-12-18 00:36:55 +00001379 return static_cast<const type&&>(
Eric Fiselier3e0d4372017-06-01 02:14:21 +00001380 static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
Eric Fiselier6dea8092015-12-18 00:36:55 +00001381}
1382
Marshall Clow15b02e02013-07-13 02:54:05 +00001383#if _LIBCPP_STD_VER > 11
Marshall Clow15b02e02013-07-13 02:54:05 +00001384
Eric Fiselier2d0e2042016-07-02 03:18:30 +00001385namespace __find_detail {
Marshall Clow15b02e02013-07-13 02:54:05 +00001386
Louis Dionne7dd28aa2021-07-20 11:46:05 -04001387static constexpr size_t __not_found = static_cast<size_t>(-1);
Eric Fiselier2d0e2042016-07-02 03:18:30 +00001388static constexpr size_t __ambiguous = __not_found - 1;
Marshall Clow15b02e02013-07-13 02:54:05 +00001389
Eric Fiselier2d0e2042016-07-02 03:18:30 +00001390inline _LIBCPP_INLINE_VISIBILITY
1391constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
1392 return !__matches ? __res :
1393 (__res == __not_found ? __curr_i : __ambiguous);
1394}
Marshall Clow15b02e02013-07-13 02:54:05 +00001395
Eric Fiselier2d0e2042016-07-02 03:18:30 +00001396template <size_t _Nx>
1397inline _LIBCPP_INLINE_VISIBILITY
1398constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
1399 return __i == _Nx ? __not_found :
1400 __find_idx_return(__i, __find_idx(__i + 1, __matches), __matches[__i]);
1401}
1402
1403template <class _T1, class ..._Args>
1404struct __find_exactly_one_checked {
Casey Carter7b5a7482017-12-12 17:22:24 +00001405 static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
Eric Fiselier2d0e2042016-07-02 03:18:30 +00001406 static constexpr size_t value = __find_detail::__find_idx(0, __matches);
Casey Carter7b5a7482017-12-12 17:22:24 +00001407 static_assert(value != __not_found, "type not found in type list" );
1408 static_assert(value != __ambiguous, "type occurs more than once in type list");
Eric Fiselier2d0e2042016-07-02 03:18:30 +00001409};
1410
Eric Fiselier8087d302016-07-02 03:46:08 +00001411template <class _T1>
1412struct __find_exactly_one_checked<_T1> {
1413 static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
1414};
1415
Nikolas Klauserd26407a2021-12-02 14:12:51 +01001416} // namespace __find_detail
Marshall Clow15b02e02013-07-13 02:54:05 +00001417
1418template <typename _T1, typename... _Args>
Eric Fiselier2d0e2042016-07-02 03:18:30 +00001419struct __find_exactly_one_t
1420 : public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
1421};
Marshall Clow15b02e02013-07-13 02:54:05 +00001422
1423template <class _T1, class... _Args>
1424inline _LIBCPP_INLINE_VISIBILITY
1425constexpr _T1& get(tuple<_Args...>& __tup) noexcept
1426{
1427 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
1428}
1429
1430template <class _T1, class... _Args>
1431inline _LIBCPP_INLINE_VISIBILITY
1432constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
1433{
1434 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
1435}
1436
1437template <class _T1, class... _Args>
1438inline _LIBCPP_INLINE_VISIBILITY
1439constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
1440{
Marshall Clowfe9aa372013-07-15 20:46:11 +00001441 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
Marshall Clow15b02e02013-07-13 02:54:05 +00001442}
1443
Eric Fiselier6dea8092015-12-18 00:36:55 +00001444template <class _T1, class... _Args>
1445inline _LIBCPP_INLINE_VISIBILITY
1446constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
1447{
1448 return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
1449}
1450
Marshall Clow15b02e02013-07-13 02:54:05 +00001451#endif
1452
Howard Hinnantc51e1022010-05-11 19:42:16 +00001453// tie
1454
1455template <class ..._Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001456inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001457tuple<_Tp&...>
Howard Hinnant62751642012-07-06 21:53:48 +00001458tie(_Tp&... __t) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001459{
1460 return tuple<_Tp&...>(__t...);
1461}
1462
1463template <class _Up>
1464struct __ignore_t
1465{
Howard Hinnantc51e1022010-05-11 19:42:16 +00001466 template <class _Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001467 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Eric Fiselier24e70262017-02-06 01:25:31 +00001468 const __ignore_t& operator=(_Tp&&) const {return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001469};
1470
Eric Fiselier24e70262017-02-06 01:25:31 +00001471namespace {
Louis Dionne559be102021-09-22 09:35:32 -04001472 constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
Nikolas Klauserd26407a2021-12-02 14:12:51 +01001473} // namespace
Howard Hinnantc51e1022010-05-11 19:42:16 +00001474
Howard Hinnantc51e1022010-05-11 19:42:16 +00001475template <class... _Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001476inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Louis Dionnedb1892a2018-12-03 14:03:27 +00001477tuple<typename __unwrap_ref_decay<_Tp>::type...>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001478make_tuple(_Tp&&... __t)
1479{
Louis Dionnedb1892a2018-12-03 14:03:27 +00001480 return tuple<typename __unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001481}
1482
Howard Hinnant3d203a32010-08-19 18:59:38 +00001483template <class... _Tp>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001484inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Marshall Clow2229cee2013-07-22 16:02:19 +00001485tuple<_Tp&&...>
Howard Hinnant62751642012-07-06 21:53:48 +00001486forward_as_tuple(_Tp&&... __t) _NOEXCEPT
Howard Hinnant3d203a32010-08-19 18:59:38 +00001487{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001488 return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
Howard Hinnant3d203a32010-08-19 18:59:38 +00001489}
1490
Howard Hinnantc834c512011-11-29 18:15:50 +00001491template <size_t _Ip>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001492struct __tuple_equal
1493{
1494 template <class _Tp, class _Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001495 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001496 bool operator()(const _Tp& __x, const _Up& __y)
1497 {
Marshall Clow60e4aa72014-06-24 00:46:19 +00001498 return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001499 }
1500};
1501
1502template <>
1503struct __tuple_equal<0>
1504{
1505 template <class _Tp, class _Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001506 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001507 bool operator()(const _Tp&, const _Up&)
1508 {
1509 return true;
1510 }
1511};
1512
1513template <class ..._Tp, class ..._Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001514inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001515bool
1516operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1517{
Marshall Clow8ee1ddd2019-02-07 19:03:48 +00001518 static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
Howard Hinnantc51e1022010-05-11 19:42:16 +00001519 return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
1520}
1521
Joe Loserd9b3d972022-03-12 10:46:57 -05001522#if _LIBCPP_STD_VER > 17
Kent Ross0861b0d2021-10-08 14:54:28 -07001523
1524// operator<=>
1525
1526template <class ..._Tp, class ..._Up, size_t ..._Is>
1527_LIBCPP_HIDE_FROM_ABI constexpr
1528auto
1529__tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) {
1530 common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
1531 static_cast<void>(((__result = _VSTD::__synth_three_way(_VSTD::get<_Is>(__x), _VSTD::get<_Is>(__y)), __result != 0) || ...));
1532 return __result;
1533}
1534
1535template <class ..._Tp, class ..._Up>
1536requires (sizeof...(_Tp) == sizeof...(_Up))
1537_LIBCPP_HIDE_FROM_ABI constexpr
1538common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
1539operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1540{
1541 return _VSTD::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
1542}
1543
Joe Loserd9b3d972022-03-12 10:46:57 -05001544#else // _LIBCPP_STD_VER > 17
Kent Ross0861b0d2021-10-08 14:54:28 -07001545
Howard Hinnantc51e1022010-05-11 19:42:16 +00001546template <class ..._Tp, class ..._Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001547inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001548bool
1549operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1550{
1551 return !(__x == __y);
1552}
1553
Howard Hinnantc834c512011-11-29 18:15:50 +00001554template <size_t _Ip>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001555struct __tuple_less
1556{
1557 template <class _Tp, class _Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001558 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001559 bool operator()(const _Tp& __x, const _Up& __y)
1560 {
Duncan P. N. Exon Smith6d3ec092015-01-21 02:51:17 +00001561 const size_t __idx = tuple_size<_Tp>::value - _Ip;
1562 if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y))
1563 return true;
1564 if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x))
1565 return false;
1566 return __tuple_less<_Ip-1>()(__x, __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001567 }
1568};
1569
1570template <>
1571struct __tuple_less<0>
1572{
1573 template <class _Tp, class _Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001574 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001575 bool operator()(const _Tp&, const _Up&)
1576 {
1577 return false;
1578 }
1579};
1580
1581template <class ..._Tp, class ..._Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001582inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001583bool
1584operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1585{
Marshall Clow8ee1ddd2019-02-07 19:03:48 +00001586 static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
Howard Hinnantc51e1022010-05-11 19:42:16 +00001587 return __tuple_less<sizeof...(_Tp)>()(__x, __y);
1588}
1589
1590template <class ..._Tp, class ..._Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001591inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001592bool
1593operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1594{
1595 return __y < __x;
1596}
1597
1598template <class ..._Tp, class ..._Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001599inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001600bool
1601operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1602{
1603 return !(__x < __y);
1604}
1605
1606template <class ..._Tp, class ..._Up>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001607inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001608bool
1609operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
1610{
1611 return !(__y < __x);
1612}
1613
Joe Loserd9b3d972022-03-12 10:46:57 -05001614#endif // _LIBCPP_STD_VER > 17
Kent Ross0861b0d2021-10-08 14:54:28 -07001615
Howard Hinnantc51e1022010-05-11 19:42:16 +00001616// tuple_cat
1617
Howard Hinnant6256ee72010-12-11 20:47:50 +00001618template <class _Tp, class _Up> struct __tuple_cat_type;
1619
1620template <class ..._Ttypes, class ..._Utypes>
Howard Hinnant3a47c3d2011-01-24 16:07:25 +00001621struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001622{
Louis Dionnea6c4ace2021-08-31 10:32:11 -04001623 typedef _LIBCPP_NODEBUG tuple<_Ttypes..., _Utypes...> type;
Howard Hinnant6256ee72010-12-11 20:47:50 +00001624};
1625
1626template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
1627struct __tuple_cat_return_1
1628{
1629};
1630
1631template <class ..._Types, class _Tuple0>
1632struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
1633{
Nikolas Klauser669b4452022-02-17 22:53:20 +01001634 using type _LIBCPP_NODEBUG = typename __tuple_cat_type<
1635 tuple<_Types...>,
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001636 typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type
Nikolas Klauser669b4452022-02-17 22:53:20 +01001637 >::type;
Howard Hinnant6256ee72010-12-11 20:47:50 +00001638};
1639
1640template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
1641struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
1642 : public __tuple_cat_return_1<
1643 typename __tuple_cat_type<
1644 tuple<_Types...>,
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001645 typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type
Howard Hinnant6256ee72010-12-11 20:47:50 +00001646 >::type,
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001647 __tuple_like<__libcpp_remove_reference_t<_Tuple1> >::value,
Howard Hinnant6256ee72010-12-11 20:47:50 +00001648 _Tuple1, _Tuples...>
1649{
1650};
1651
1652template <class ..._Tuples> struct __tuple_cat_return;
1653
1654template <class _Tuple0, class ..._Tuples>
1655struct __tuple_cat_return<_Tuple0, _Tuples...>
1656 : public __tuple_cat_return_1<tuple<>,
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001657 __tuple_like<__libcpp_remove_reference_t<_Tuple0> >::value, _Tuple0,
Howard Hinnant6256ee72010-12-11 20:47:50 +00001658 _Tuples...>
1659{
1660};
1661
1662template <>
1663struct __tuple_cat_return<>
1664{
Louis Dionnea6c4ace2021-08-31 10:32:11 -04001665 typedef _LIBCPP_NODEBUG tuple<> type;
Howard Hinnant6256ee72010-12-11 20:47:50 +00001666};
1667
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001668inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant6256ee72010-12-11 20:47:50 +00001669tuple<>
1670tuple_cat()
1671{
1672 return tuple<>();
Howard Hinnantc51e1022010-05-11 19:42:16 +00001673}
1674
Howard Hinnantc834c512011-11-29 18:15:50 +00001675template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
Howard Hinnant21376f62010-12-12 23:04:37 +00001676struct __tuple_cat_return_ref_imp;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001677
Howard Hinnant21376f62010-12-12 23:04:37 +00001678template <class ..._Types, size_t ..._I0, class _Tuple0>
1679struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001680{
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001681 typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
Howard Hinnant21376f62010-12-12 23:04:37 +00001682 typedef tuple<_Types..., typename __apply_cv<_Tuple0,
1683 typename tuple_element<_I0, _T0>::type>::type&&...> type;
1684};
Howard Hinnantc51e1022010-05-11 19:42:16 +00001685
Howard Hinnant21376f62010-12-12 23:04:37 +00001686template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
1687struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
1688 _Tuple0, _Tuple1, _Tuples...>
1689 : public __tuple_cat_return_ref_imp<
1690 tuple<_Types..., typename __apply_cv<_Tuple0,
1691 typename tuple_element<_I0,
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001692 __libcpp_remove_reference_t<_Tuple0> >::type>::type&&...>,
1693 typename __make_tuple_indices<tuple_size<__libcpp_remove_reference_t<_Tuple1> >::value>::type,
Howard Hinnant21376f62010-12-12 23:04:37 +00001694 _Tuple1, _Tuples...>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001695{
Howard Hinnant21376f62010-12-12 23:04:37 +00001696};
1697
1698template <class _Tuple0, class ..._Tuples>
1699struct __tuple_cat_return_ref
1700 : public __tuple_cat_return_ref_imp<tuple<>,
1701 typename __make_tuple_indices<
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001702 tuple_size<__libcpp_remove_reference_t<_Tuple0> >::value
Howard Hinnant21376f62010-12-12 23:04:37 +00001703 >::type, _Tuple0, _Tuples...>
1704{
1705};
1706
1707template <class _Types, class _I0, class _J0>
1708struct __tuple_cat;
1709
1710template <class ..._Types, size_t ..._I0, size_t ..._J0>
Howard Hinnant3a47c3d2011-01-24 16:07:25 +00001711struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
Howard Hinnant21376f62010-12-12 23:04:37 +00001712{
1713 template <class _Tuple0>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001714 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant21376f62010-12-12 23:04:37 +00001715 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
1716 operator()(tuple<_Types...> __t, _Tuple0&& __t0)
1717 {
Louis Dionne6209e9f2022-03-03 13:39:12 -05001718 (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
David Blaikie699a5e22019-10-28 18:03:59 -07001719 return _VSTD::forward_as_tuple(
1720 _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
1721 _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
Howard Hinnant21376f62010-12-12 23:04:37 +00001722 }
1723
1724 template <class _Tuple0, class _Tuple1, class ..._Tuples>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001725 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant21376f62010-12-12 23:04:37 +00001726 typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
1727 operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
1728 {
Louis Dionne6209e9f2022-03-03 13:39:12 -05001729 (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001730 typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
1731 typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple1> _T1;
Howard Hinnant21376f62010-12-12 23:04:37 +00001732 return __tuple_cat<
David Blaikie699a5e22019-10-28 18:03:59 -07001733 tuple<_Types...,
1734 typename __apply_cv<_Tuple0, typename tuple_element<
1735 _J0, _T0>::type>::type&&...>,
1736 typename __make_tuple_indices<sizeof...(_Types) +
1737 tuple_size<_T0>::value>::type,
1738 typename __make_tuple_indices<tuple_size<_T1>::value>::type>()(
1739 _VSTD::forward_as_tuple(
1740 _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
1741 _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...),
1742 _VSTD::forward<_Tuple1>(__t1), _VSTD::forward<_Tuples>(__tpls)...);
Howard Hinnant21376f62010-12-12 23:04:37 +00001743 }
1744};
1745
1746template <class _Tuple0, class... _Tuples>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001747inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
Howard Hinnant21376f62010-12-12 23:04:37 +00001748typename __tuple_cat_return<_Tuple0, _Tuples...>::type
1749tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
1750{
Nikolas Klauserc9e524e2022-09-06 00:33:34 +02001751 typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
Howard Hinnant21376f62010-12-12 23:04:37 +00001752 return __tuple_cat<tuple<>, __tuple_indices<>,
1753 typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001754 (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
1755 _VSTD::forward<_Tuples>(__tpls)...);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001756}
1757
1758template <class ..._Tp, class _Alloc>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001759struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001760 : true_type {};
1761
Howard Hinnantc51e1022010-05-11 19:42:16 +00001762template <class _T1, class _T2>
1763template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
Nikolas Klauser8b1c5062022-08-19 13:08:01 +02001764inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
Howard Hinnantc51e1022010-05-11 19:42:16 +00001765pair<_T1, _T2>::pair(piecewise_construct_t,
1766 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
1767 __tuple_indices<_I1...>, __tuple_indices<_I2...>)
Marshall Clow60e4aa72014-06-24 00:46:19 +00001768 : first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
1769 second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001770{
1771}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001772
Eric Fiselier8e892c52016-07-18 00:35:56 +00001773#if _LIBCPP_STD_VER > 14
1774template <class _Tp>
Louis Dionne559be102021-09-22 09:35:32 -04001775inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
Eric Fiselier8e892c52016-07-18 00:35:56 +00001776
1777#define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
1778
1779template <class _Fn, class _Tuple, size_t ..._Id>
1780inline _LIBCPP_INLINE_VISIBILITY
1781constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
1782 __tuple_indices<_Id...>)
1783_LIBCPP_NOEXCEPT_RETURN(
Nikolas Klausera28f48e2022-04-06 23:10:21 +02001784 _VSTD::__invoke(
Eric Fiselier8e892c52016-07-18 00:35:56 +00001785 _VSTD::forward<_Fn>(__f),
1786 _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
1787)
1788
1789template <class _Fn, class _Tuple>
1790inline _LIBCPP_INLINE_VISIBILITY
1791constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
1792_LIBCPP_NOEXCEPT_RETURN(
1793 _VSTD::__apply_tuple_impl(
1794 _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
Marshall Clowd5bbc242018-02-06 20:56:55 +00001795 typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
Eric Fiselier8e892c52016-07-18 00:35:56 +00001796)
1797
1798template <class _Tp, class _Tuple, size_t... _Idx>
1799inline _LIBCPP_INLINE_VISIBILITY
1800constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
1801_LIBCPP_NOEXCEPT_RETURN(
1802 _Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
1803)
1804
1805template <class _Tp, class _Tuple>
1806inline _LIBCPP_INLINE_VISIBILITY
1807constexpr _Tp make_from_tuple(_Tuple&& __t)
1808_LIBCPP_NOEXCEPT_RETURN(
1809 _VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
Marshall Clowd5bbc242018-02-06 20:56:55 +00001810 typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
Eric Fiselier8e892c52016-07-18 00:35:56 +00001811)
1812
1813#undef _LIBCPP_NOEXCEPT_RETURN
1814
1815#endif // _LIBCPP_STD_VER > 14
1816
Eric Fiselierffe4aba2017-04-19 01:23:39 +00001817#endif // !defined(_LIBCPP_CXX03_LANG)
1818
Howard Hinnantc51e1022010-05-11 19:42:16 +00001819_LIBCPP_END_NAMESPACE_STD
1820
Mark de Weveree5fe272022-09-02 17:53:28 +02001821#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
1822# include <exception>
1823# include <iosfwd>
1824# include <new>
1825# include <typeinfo>
1826# include <utility>
1827#endif
1828
Louis Dionne2b1ceaa2021-04-20 12:03:32 -04001829#endif // _LIBCPP_TUPLE