1//===----------------------------------------------------------------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#ifndef _LIBCPP___UTILITY_PAIR_H 10#define _LIBCPP___UTILITY_PAIR_H 11 12#include <__compare/common_comparison_category.h> 13#include <__compare/synth_three_way.h> 14#include <__concepts/different_from.h> 15#include <__config> 16#include <__fwd/array.h> 17#include <__fwd/get.h> 18#include <__fwd/pair.h> 19#include <__fwd/subrange.h> 20#include <__fwd/tuple.h> 21#include <__tuple/pair_like.h> 22#include <__tuple/sfinae_helpers.h> 23#include <__tuple/tuple_element.h> 24#include <__tuple/tuple_indices.h> 25#include <__tuple/tuple_size.h> 26#include <__type_traits/common_reference.h> 27#include <__type_traits/common_type.h> 28#include <__type_traits/conditional.h> 29#include <__type_traits/decay.h> 30#include <__type_traits/integral_constant.h> 31#include <__type_traits/is_assignable.h> 32#include <__type_traits/is_constructible.h> 33#include <__type_traits/is_convertible.h> 34#include <__type_traits/is_copy_assignable.h> 35#include <__type_traits/is_default_constructible.h> 36#include <__type_traits/is_implicitly_default_constructible.h> 37#include <__type_traits/is_move_assignable.h> 38#include <__type_traits/is_nothrow_assignable.h> 39#include <__type_traits/is_nothrow_constructible.h> 40#include <__type_traits/is_nothrow_copy_assignable.h> 41#include <__type_traits/is_nothrow_copy_constructible.h> 42#include <__type_traits/is_nothrow_default_constructible.h> 43#include <__type_traits/is_nothrow_move_assignable.h> 44#include <__type_traits/is_same.h> 45#include <__type_traits/is_swappable.h> 46#include <__type_traits/nat.h> 47#include <__type_traits/remove_cvref.h> 48#include <__type_traits/unwrap_ref.h> 49#include <__utility/declval.h> 50#include <__utility/forward.h> 51#include <__utility/move.h> 52#include <__utility/piecewise_construct.h> 53#include <cstddef> 54 55#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 56# pragma GCC system_header 57#endif 58 59_LIBCPP_PUSH_MACROS 60#include <__undef_macros> 61 62_LIBCPP_BEGIN_NAMESPACE_STD 63 64template <class, class> 65struct __non_trivially_copyable_base { 66 _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI __non_trivially_copyable_base() _NOEXCEPT {} 67 _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI 68 __non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {} 69}; 70 71#if _LIBCPP_STD_VER >= 23 72template <class _Tp> 73struct __is_specialization_of_subrange : false_type {}; 74 75template <class _Iter, class _Sent, ranges::subrange_kind _Kind> 76struct __is_specialization_of_subrange<ranges::subrange<_Iter, _Sent, _Kind>> : true_type {}; 77#endif 78 79template <class _T1, class _T2> 80struct _LIBCPP_TEMPLATE_VIS pair 81#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR) 82 : private __non_trivially_copyable_base<_T1, _T2> 83#endif 84{ 85 using first_type = _T1; 86 using second_type = _T2; 87 88 _T1 first; 89 _T2 second; 90 91 _LIBCPP_HIDE_FROM_ABI pair(pair const&) = default; 92 _LIBCPP_HIDE_FROM_ABI pair(pair&&) = default; 93 94#ifdef _LIBCPP_CXX03_LANG 95 _LIBCPP_HIDE_FROM_ABI pair() : first(), second() {} 96 97 _LIBCPP_HIDE_FROM_ABI pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {} 98 99 template <class _U1, class _U2> 100 _LIBCPP_HIDE_FROM_ABI pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {} 101 102 _LIBCPP_HIDE_FROM_ABI pair& operator=(pair const& __p) { 103 first = __p.first; 104 second = __p.second; 105 return *this; 106 } 107 108 // Extension: This is provided in C++03 because it allows properly handling the 109 // assignment to a pair containing references, which would be a hard 110 // error otherwise. 111 template <class _U1, 112 class _U2, 113 class = __enable_if_t< is_assignable<first_type&, _U1 const&>::value && 114 is_assignable<second_type&, _U2 const&>::value > > 115 _LIBCPP_HIDE_FROM_ABI pair& operator=(pair<_U1, _U2> const& __p) { 116 first = __p.first; 117 second = __p.second; 118 return *this; 119 } 120#else 121 struct _CheckArgs { 122 template <int&...> 123 static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { 124 return is_default_constructible<_T1>::value && is_default_constructible<_T2>::value && 125 !__enable_implicit_default<>(); 126 } 127 128 template <int&...> 129 static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { 130 return __is_implicitly_default_constructible<_T1>::value && __is_implicitly_default_constructible<_T2>::value; 131 } 132 133 template <class _U1, class _U2> 134 static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_pair_constructible() { 135 return is_constructible<first_type, _U1>::value && is_constructible<second_type, _U2>::value; 136 } 137 138 template <class _U1, class _U2> 139 static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_implicit() { 140 return is_convertible<_U1, first_type>::value && is_convertible<_U2, second_type>::value; 141 } 142 143 template <class _U1, class _U2> 144 static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit() { 145 return __is_pair_constructible<_U1, _U2>() && !__is_implicit<_U1, _U2>(); 146 } 147 148 template <class _U1, class _U2> 149 static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit() { 150 return __is_pair_constructible<_U1, _U2>() && __is_implicit<_U1, _U2>(); 151 } 152 }; 153 154 template <bool _MaybeEnable> 155 using _CheckArgsDep _LIBCPP_NODEBUG = 156 typename conditional< _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type; 157 158 template <bool _Dummy = true, __enable_if_t<_CheckArgsDep<_Dummy>::__enable_explicit_default(), int> = 0> 159 explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR pair() _NOEXCEPT_( 160 is_nothrow_default_constructible<first_type>::value&& is_nothrow_default_constructible<second_type>::value) 161 : first(), second() {} 162 163 template <bool _Dummy = true, __enable_if_t<_CheckArgsDep<_Dummy>::__enable_implicit_default(), int> = 0> 164 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR pair() _NOEXCEPT_( 165 is_nothrow_default_constructible<first_type>::value&& is_nothrow_default_constructible<second_type>::value) 166 : first(), second() {} 167 168 template <bool _Dummy = true, 169 __enable_if_t<_CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>(), int> = 0> 170 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(_T1 const& __t1, _T2 const& __t2) 171 _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value&& is_nothrow_copy_constructible<second_type>::value) 172 : first(__t1), second(__t2) {} 173 174 template <bool _Dummy = true, 175 __enable_if_t<_CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>(), int> = 0> 176 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(_T1 const& __t1, _T2 const& __t2) 177 _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value&& is_nothrow_copy_constructible<second_type>::value) 178 : first(__t1), second(__t2) {} 179 180 template < 181# if _LIBCPP_STD_VER >= 23 // http://wg21.link/P1951 182 class _U1 = _T1, 183 class _U2 = _T2, 184# else 185 class _U1, 186 class _U2, 187# endif 188 __enable_if_t<_CheckArgs::template __enable_explicit<_U1, _U2>(), int> = 0 > 189 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(_U1&& __u1, _U2&& __u2) 190 _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value && 191 is_nothrow_constructible<second_type, _U2>::value)) 192 : first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) { 193 } 194 195 template < 196# if _LIBCPP_STD_VER >= 23 // http://wg21.link/P1951 197 class _U1 = _T1, 198 class _U2 = _T2, 199# else 200 class _U1, 201 class _U2, 202# endif 203 __enable_if_t<_CheckArgs::template __enable_implicit<_U1, _U2>(), int> = 0 > 204 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(_U1&& __u1, _U2&& __u2) 205 _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value && 206 is_nothrow_constructible<second_type, _U2>::value)) 207 : first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) { 208 } 209 210# if _LIBCPP_STD_VER >= 23 211 template <class _U1, 212 class _U2, 213 __enable_if_t< _CheckArgs::template __is_pair_constructible<_U1&, _U2&>() >* = nullptr> 214 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_CheckArgs::template __is_implicit<_U1&, _U2&>()) 215 pair(pair<_U1, _U2>& __p) noexcept((is_nothrow_constructible<first_type, _U1&>::value && 216 is_nothrow_constructible<second_type, _U2&>::value)) 217 : first(__p.first), second(__p.second) {} 218# endif 219 220 template <class _U1, 221 class _U2, 222 __enable_if_t<_CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>(), int> = 0> 223 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(pair<_U1, _U2> const& __p) 224 _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value && 225 is_nothrow_constructible<second_type, _U2 const&>::value)) 226 : first(__p.first), second(__p.second) {} 227 228 template <class _U1, 229 class _U2, 230 __enable_if_t<_CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>(), int> = 0> 231 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(pair<_U1, _U2> const& __p) 232 _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value && 233 is_nothrow_constructible<second_type, _U2 const&>::value)) 234 : first(__p.first), second(__p.second) {} 235 236 template <class _U1, class _U2, __enable_if_t<_CheckArgs::template __enable_explicit<_U1, _U2>(), int> = 0> 237 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(pair<_U1, _U2>&& __p) 238 _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value && 239 is_nothrow_constructible<second_type, _U2&&>::value)) 240 : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {} 241 242 template <class _U1, class _U2, __enable_if_t<_CheckArgs::template __enable_implicit<_U1, _U2>(), int> = 0> 243 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(pair<_U1, _U2>&& __p) 244 _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value && 245 is_nothrow_constructible<second_type, _U2&&>::value)) 246 : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {} 247 248# if _LIBCPP_STD_VER >= 23 249 template <class _U1, 250 class _U2, 251 __enable_if_t< _CheckArgs::template __is_pair_constructible<const _U1&&, const _U2&&>() >* = nullptr> 252 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_CheckArgs::template __is_implicit<const _U1&&, const _U2&&>()) 253 pair(const pair<_U1, _U2>&& __p) noexcept(is_nothrow_constructible<first_type, const _U1&&>::value && 254 is_nothrow_constructible<second_type, const _U2&&>::value) 255 : first(std::move(__p.first)), second(std::move(__p.second)) {} 256# endif 257 258# if _LIBCPP_STD_VER >= 23 259 // This is a workaround for http://llvm.org/PR60710. We should be able to remove it once Clang is fixed. 260 template <class _PairLike> 261 _LIBCPP_HIDE_FROM_ABI static constexpr bool __pair_like_explicit_wknd() { 262 if constexpr (__pair_like<_PairLike>) { 263 return !is_convertible_v<decltype(std::get<0>(std::declval<_PairLike&&>())), first_type> || 264 !is_convertible_v<decltype(std::get<1>(std::declval<_PairLike&&>())), second_type>; 265 } 266 return false; 267 } 268 269 template <__pair_like _PairLike> 270 requires(!__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value && 271 is_constructible_v<first_type, decltype(std::get<0>(std::declval<_PairLike &&>()))> && 272 is_constructible_v<second_type, decltype(std::get<1>(std::declval<_PairLike &&>()))>) 273 _LIBCPP_HIDE_FROM_ABI constexpr explicit(__pair_like_explicit_wknd<_PairLike>()) pair(_PairLike&& __p) 274 : first(std::get<0>(std::forward<_PairLike>(__p))), second(std::get<1>(std::forward<_PairLike>(__p))) {} 275# endif 276 277 template <class... _Args1, class... _Args2> 278 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 279 pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, tuple<_Args2...> __second_args) 280 _NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value && 281 is_nothrow_constructible<second_type, _Args2...>::value)) 282 : pair(__pc, 283 __first_args, 284 __second_args, 285 typename __make_tuple_indices<sizeof...(_Args1)>::type(), 286 typename __make_tuple_indices<sizeof...(_Args2) >::type()) {} 287 288 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& 289 operator=(__conditional_t< is_copy_assignable<first_type>::value && is_copy_assignable<second_type>::value, 290 pair, 291 __nat> const& __p) 292 _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value&& is_nothrow_copy_assignable<second_type>::value) { 293 first = __p.first; 294 second = __p.second; 295 return *this; 296 } 297 298 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& operator=( 299 __conditional_t< is_move_assignable<first_type>::value && is_move_assignable<second_type>::value, pair, __nat>&& 300 __p) 301 _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value&& is_nothrow_move_assignable<second_type>::value) { 302 first = std::forward<first_type>(__p.first); 303 second = std::forward<second_type>(__p.second); 304 return *this; 305 } 306 307 template <class _U1, 308 class _U2, 309 __enable_if_t< is_assignable<first_type&, _U1 const&>::value && 310 is_assignable<second_type&, _U2 const&>::value >* = nullptr> 311 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& operator=(pair<_U1, _U2> const& __p) { 312 first = __p.first; 313 second = __p.second; 314 return *this; 315 } 316 317 template < 318 class _U1, 319 class _U2, 320 __enable_if_t< is_assignable<first_type&, _U1>::value && is_assignable<second_type&, _U2>::value >* = nullptr> 321 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& operator=(pair<_U1, _U2>&& __p) { 322 first = std::forward<_U1>(__p.first); 323 second = std::forward<_U2>(__p.second); 324 return *this; 325 } 326 327# if _LIBCPP_STD_VER >= 23 328 _LIBCPP_HIDE_FROM_ABI constexpr const pair& operator=(pair const& __p) const 329 noexcept(is_nothrow_copy_assignable_v<const first_type> && is_nothrow_copy_assignable_v<const second_type>) 330 requires(is_copy_assignable_v<const first_type> && is_copy_assignable_v<const second_type>) 331 { 332 first = __p.first; 333 second = __p.second; 334 return *this; 335 } 336 337 _LIBCPP_HIDE_FROM_ABI constexpr const pair& operator=(pair&& __p) const 338 noexcept(is_nothrow_assignable_v<const first_type&, first_type> && 339 is_nothrow_assignable_v<const second_type&, second_type>) 340 requires(is_assignable_v<const first_type&, first_type> && is_assignable_v<const second_type&, second_type>) 341 { 342 first = std::forward<first_type>(__p.first); 343 second = std::forward<second_type>(__p.second); 344 return *this; 345 } 346 347 template <class _U1, class _U2> 348 _LIBCPP_HIDE_FROM_ABI constexpr const pair& operator=(const pair<_U1, _U2>& __p) const 349 requires(is_assignable_v<const first_type&, const _U1&> && is_assignable_v<const second_type&, const _U2&>) 350 { 351 first = __p.first; 352 second = __p.second; 353 return *this; 354 } 355 356 template <class _U1, class _U2> 357 _LIBCPP_HIDE_FROM_ABI constexpr const pair& operator=(pair<_U1, _U2>&& __p) const 358 requires(is_assignable_v<const first_type&, _U1> && is_assignable_v<const second_type&, _U2>) 359 { 360 first = std::forward<_U1>(__p.first); 361 second = std::forward<_U2>(__p.second); 362 return *this; 363 } 364 365 template <__pair_like _PairLike> 366 requires(__different_from<_PairLike, pair> && !__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value && 367 is_assignable_v<first_type&, decltype(std::get<0>(std::declval<_PairLike>()))> && 368 is_assignable_v<second_type&, decltype(std::get<1>(std::declval<_PairLike>()))>) 369 _LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(_PairLike&& __p) { 370 first = std::get<0>(std::forward<_PairLike>(__p)); 371 second = std::get<1>(std::forward<_PairLike>(__p)); 372 return *this; 373 } 374 375 template <__pair_like _PairLike> 376 requires(__different_from<_PairLike, pair> && !__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value && 377 is_assignable_v<first_type const&, decltype(std::get<0>(std::declval<_PairLike>()))> && 378 is_assignable_v<second_type const&, decltype(std::get<1>(std::declval<_PairLike>()))>) 379 _LIBCPP_HIDE_FROM_ABI constexpr pair const& operator=(_PairLike&& __p) const { 380 first = std::get<0>(std::forward<_PairLike>(__p)); 381 second = std::get<1>(std::forward<_PairLike>(__p)); 382 return *this; 383 } 384# endif // _LIBCPP_STD_VER >= 23 385 386 // Prior to C++23, we provide an approximation of constructors and assignment operators from 387 // pair-like types. This was historically provided as an extension. 388# if _LIBCPP_STD_VER < 23 389 // from std::tuple 390 template < 391 class _U1, 392 class _U2, 393 __enable_if_t< is_convertible<_U1 const&, _T1>::value && is_convertible<_U2 const&, _T2>::value >* = nullptr> 394 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(tuple<_U1, _U2> const& __p) 395 : first(std::get<0>(__p)), second(std::get<1>(__p)) {} 396 397 template < 398 class _U1, 399 class _U2, 400 __enable_if_t< is_constructible<_T1, _U1 const&>::value && is_constructible<_T2, _U2 const&>::value && 401 !(is_convertible<_U1 const&, _T1>::value && is_convertible<_U2 const&, _T2>::value) >* = nullptr> 402 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(tuple<_U1, _U2> const& __p) 403 : first(std::get<0>(__p)), second(std::get<1>(__p)) {} 404 405 template <class _U1, 406 class _U2, 407 __enable_if_t< is_convertible<_U1, _T1>::value && is_convertible<_U2, _T2>::value >* = nullptr> 408 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(tuple<_U1, _U2>&& __p) 409 : first(std::get<0>(std::move(__p))), second(std::get<1>(std::move(__p))) {} 410 411 template <class _U1, 412 class _U2, 413 __enable_if_t< is_constructible<_T1, _U1>::value && is_constructible<_T2, _U2>::value && 414 !(is_convertible<_U1, _T1>::value && is_convertible<_U2, _T2>::value) >* = nullptr> 415 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(tuple<_U1, _U2>&& __p) 416 : first(std::get<0>(std::move(__p))), second(std::get<1>(std::move(__p))) {} 417 418 template < 419 class _U1, 420 class _U2, 421 __enable_if_t< is_assignable<_T1&, _U1 const&>::value && is_assignable<_T2&, _U2 const&>::value >* = nullptr> 422 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair& operator=(tuple<_U1, _U2> const& __p) { 423 first = std::get<0>(__p); 424 second = std::get<1>(__p); 425 return *this; 426 } 427 428 template <class _U1, 429 class _U2, 430 __enable_if_t< is_assignable<_T1&, _U1&&>::value && is_assignable<_T2&, _U2&&>::value >* = nullptr> 431 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair& operator=(tuple<_U1, _U2>&& __p) { 432 first = std::get<0>(std::move(__p)); 433 second = std::get<1>(std::move(__p)); 434 return *this; 435 } 436 437 // from std::array 438 template < 439 class _Up, 440 __enable_if_t< is_convertible<_Up const&, _T1>::value && is_convertible<_Up const&, _T2>::value >* = nullptr> 441 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(array<_Up, 2> const& __p) : first(__p[0]), second(__p[1]) {} 442 443 template < 444 class _Up, 445 __enable_if_t< is_constructible<_T1, _Up const&>::value && is_constructible<_T2, _Up const&>::value && 446 !(is_convertible<_Up const&, _T1>::value && is_convertible<_Up const&, _T2>::value) >* = nullptr> 447 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(array<_Up, 2> const& __p) 448 : first(__p[0]), second(__p[1]) {} 449 450 template <class _Up, __enable_if_t< is_convertible<_Up, _T1>::value && is_convertible<_Up, _T2>::value >* = nullptr> 451 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(array<_Up, 2>&& __p) 452 : first(std::move(__p)[0]), second(std::move(__p)[1]) {} 453 454 template <class _Up, 455 __enable_if_t< is_constructible<_T1, _Up>::value && is_constructible<_T2, _Up>::value && 456 !(is_convertible<_Up, _T1>::value && is_convertible<_Up, _T2>::value) >* = nullptr> 457 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(array<_Up, 2>&& __p) 458 : first(std::move(__p)[0]), second(std::move(__p)[1]) {} 459 460 template < 461 class _Up, 462 __enable_if_t< is_assignable<_T1&, _Up const&>::value && is_assignable<_T2&, _Up const&>::value >* = nullptr> 463 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair& operator=(array<_Up, 2> const& __p) { 464 first = std::get<0>(__p); 465 second = std::get<1>(__p); 466 return *this; 467 } 468 469 template <class _Up, __enable_if_t< is_assignable<_T1&, _Up>::value && is_assignable<_T2&, _Up>::value >* = nullptr> 470 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair& operator=(array<_Up, 2>&& __p) { 471 first = std::get<0>(std::move(__p)); 472 second = std::get<1>(std::move(__p)); 473 return *this; 474 } 475# endif // _LIBCPP_STD_VER < 23 476#endif // _LIBCPP_CXX03_LANG 477 478 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(pair& __p) 479 _NOEXCEPT_(__is_nothrow_swappable<first_type>::value&& __is_nothrow_swappable<second_type>::value) { 480 using std::swap; 481 swap(first, __p.first); 482 swap(second, __p.second); 483 } 484 485#if _LIBCPP_STD_VER >= 23 486 _LIBCPP_HIDE_FROM_ABI constexpr void swap(const pair& __p) const 487 noexcept(__is_nothrow_swappable<const first_type>::value && __is_nothrow_swappable<const second_type>::value) { 488 using std::swap; 489 swap(first, __p.first); 490 swap(second, __p.second); 491 } 492#endif 493 494private: 495#ifndef _LIBCPP_CXX03_LANG 496 template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> 497 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 498 pair(piecewise_construct_t, 499 tuple<_Args1...>& __first_args, 500 tuple<_Args2...>& __second_args, 501 __tuple_indices<_I1...>, 502 __tuple_indices<_I2...>); 503#endif 504}; 505 506#if _LIBCPP_STD_VER >= 17 507template <class _T1, class _T2> 508pair(_T1, _T2) -> pair<_T1, _T2>; 509#endif 510 511// [pairs.spec], specialized algorithms 512 513template <class _T1, class _T2, class _U1, class _U2> 514inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool 515operator==(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) { 516 return __x.first == __y.first && __x.second == __y.second; 517} 518 519#if _LIBCPP_STD_VER >= 20 520 521template <class _T1, class _T2, class _U1, class _U2> 522_LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t< __synth_three_way_result<_T1, _U1>, 523 __synth_three_way_result<_T2, _U2> > 524operator<=>(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) { 525 if (auto __c = std::__synth_three_way(__x.first, __y.first); __c != 0) { 526 return __c; 527 } 528 return std::__synth_three_way(__x.second, __y.second); 529} 530 531#else // _LIBCPP_STD_VER >= 20 532 533template <class _T1, class _T2, class _U1, class _U2> 534inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool 535operator!=(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) { 536 return !(__x == __y); 537} 538 539template <class _T1, class _T2, class _U1, class _U2> 540inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool 541operator<(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) { 542 return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second); 543} 544 545template <class _T1, class _T2, class _U1, class _U2> 546inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool 547operator>(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) { 548 return __y < __x; 549} 550 551template <class _T1, class _T2, class _U1, class _U2> 552inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool 553operator>=(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) { 554 return !(__x < __y); 555} 556 557template <class _T1, class _T2, class _U1, class _U2> 558inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool 559operator<=(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) { 560 return !(__y < __x); 561} 562 563#endif // _LIBCPP_STD_VER >= 20 564 565#if _LIBCPP_STD_VER >= 23 566template <class _T1, class _T2, class _U1, class _U2, template <class> class _TQual, template <class> class _UQual> 567 requires requires { 568 typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>, common_reference_t<_TQual<_T2>, _UQual<_U2>>>; 569 } 570struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual> { 571 using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>, common_reference_t<_TQual<_T2>, _UQual<_U2>>>; 572}; 573 574template <class _T1, class _T2, class _U1, class _U2> 575 requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; } 576struct common_type<pair<_T1, _T2>, pair<_U1, _U2>> { 577 using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; 578}; 579#endif // _LIBCPP_STD_VER >= 23 580 581template <class _T1, class _T2, __enable_if_t<__is_swappable<_T1>::value && __is_swappable<_T2>::value, int> = 0> 582inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) 583 _NOEXCEPT_((__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value)) { 584 __x.swap(__y); 585} 586 587#if _LIBCPP_STD_VER >= 23 588template <class _T1, class _T2> 589 requires(__is_swappable<const _T1>::value && __is_swappable<const _T2>::value) 590_LIBCPP_HIDE_FROM_ABI constexpr void 591swap(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) noexcept(noexcept(__x.swap(__y))) { 592 __x.swap(__y); 593} 594#endif 595 596template <class _T1, class _T2> 597inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 598 pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type> 599 make_pair(_T1&& __t1, _T2&& __t2) { 600 return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>( 601 std::forward<_T1>(__t1), std::forward<_T2>(__t2)); 602} 603 604template <class _T1, class _T2> 605struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {}; 606 607template <size_t _Ip, class _T1, class _T2> 608struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> > { 609 static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>"); 610}; 611 612template <class _T1, class _T2> 613struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> > { 614 using type _LIBCPP_NODEBUG = _T1; 615}; 616 617template <class _T1, class _T2> 618struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> > { 619 using type _LIBCPP_NODEBUG = _T2; 620}; 621 622template <size_t _Ip> 623struct __get_pair; 624 625template <> 626struct __get_pair<0> { 627 template <class _T1, class _T2> 628 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT { 629 return __p.first; 630 } 631 632 template <class _T1, class _T2> 633 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _T1& get(const pair<_T1, _T2>& __p) _NOEXCEPT { 634 return __p.first; 635 } 636 637 template <class _T1, class _T2> 638 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT { 639 return std::forward<_T1>(__p.first); 640 } 641 642 template <class _T1, class _T2> 643 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _T1&& get(const pair<_T1, _T2>&& __p) _NOEXCEPT { 644 return std::forward<const _T1>(__p.first); 645 } 646}; 647 648template <> 649struct __get_pair<1> { 650 template <class _T1, class _T2> 651 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _T2& get(pair<_T1, _T2>& __p) _NOEXCEPT { 652 return __p.second; 653 } 654 655 template <class _T1, class _T2> 656 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _T2& get(const pair<_T1, _T2>& __p) _NOEXCEPT { 657 return __p.second; 658 } 659 660 template <class _T1, class _T2> 661 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _T2&& get(pair<_T1, _T2>&& __p) _NOEXCEPT { 662 return std::forward<_T2>(__p.second); 663 } 664 665 template <class _T1, class _T2> 666 static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _T2&& get(const pair<_T1, _T2>&& __p) _NOEXCEPT { 667 return std::forward<const _T2>(__p.second); 668 } 669}; 670 671template <size_t _Ip, class _T1, class _T2> 672inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, pair<_T1, _T2> >::type& 673get(pair<_T1, _T2>& __p) _NOEXCEPT { 674 return __get_pair<_Ip>::get(__p); 675} 676 677template <size_t _Ip, class _T1, class _T2> 678inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type& 679get(const pair<_T1, _T2>& __p) _NOEXCEPT { 680 return __get_pair<_Ip>::get(__p); 681} 682 683template <size_t _Ip, class _T1, class _T2> 684inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, pair<_T1, _T2> >::type&& 685get(pair<_T1, _T2>&& __p) _NOEXCEPT { 686 return __get_pair<_Ip>::get(std::move(__p)); 687} 688 689template <size_t _Ip, class _T1, class _T2> 690inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&& 691get(const pair<_T1, _T2>&& __p) _NOEXCEPT { 692 return __get_pair<_Ip>::get(std::move(__p)); 693} 694 695#if _LIBCPP_STD_VER >= 14 696template <class _T1, class _T2> 697inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT { 698 return __get_pair<0>::get(__p); 699} 700 701template <class _T1, class _T2> 702inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT { 703 return __get_pair<0>::get(__p); 704} 705 706template <class _T1, class _T2> 707inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT { 708 return __get_pair<0>::get(std::move(__p)); 709} 710 711template <class _T1, class _T2> 712inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT { 713 return __get_pair<0>::get(std::move(__p)); 714} 715 716template <class _T1, class _T2> 717inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T2, _T1>& __p) _NOEXCEPT { 718 return __get_pair<1>::get(__p); 719} 720 721template <class _T1, class _T2> 722inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T2, _T1> const& __p) _NOEXCEPT { 723 return __get_pair<1>::get(__p); 724} 725 726template <class _T1, class _T2> 727inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T2, _T1>&& __p) _NOEXCEPT { 728 return __get_pair<1>::get(std::move(__p)); 729} 730 731template <class _T1, class _T2> 732inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T2, _T1> const&& __p) _NOEXCEPT { 733 return __get_pair<1>::get(std::move(__p)); 734} 735 736#endif // _LIBCPP_STD_VER >= 14 737 738_LIBCPP_END_NAMESPACE_STD 739 740_LIBCPP_POP_MACROS 741 742#endif // _LIBCPP___UTILITY_PAIR_H 743