mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-06-03 19:22:27 +00:00
Upgrade to 2022-era LLVM LIBCXX
This commit is contained in:
Justine Tunney
parent
2f4ca71f26
commit
8e68384e15
2078 changed files with 165657 additions and 65010 deletions
896
third_party/libcxx/__utility/pair.h
vendored
Normal file
896
third_party/libcxx/__utility/pair.h
vendored
Normal file
|
|
@ -0,0 +1,896 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___UTILITY_PAIR_H
|
||||
#define _LIBCPP___UTILITY_PAIR_H
|
||||
|
||||
#include <__compare/common_comparison_category.h>
|
||||
#include <__compare/synth_three_way.h>
|
||||
#include <__concepts/different_from.h>
|
||||
#include <__config>
|
||||
#include <__fwd/array.h>
|
||||
#include <__fwd/get.h>
|
||||
#include <__fwd/subrange.h>
|
||||
#include <__fwd/tuple.h>
|
||||
#include <__tuple/pair_like.h>
|
||||
#include <__tuple/sfinae_helpers.h>
|
||||
#include <__tuple/tuple_element.h>
|
||||
#include <__tuple/tuple_indices.h>
|
||||
#include <__tuple/tuple_size.h>
|
||||
#include <__type_traits/common_reference.h>
|
||||
#include <__type_traits/common_type.h>
|
||||
#include <__type_traits/conditional.h>
|
||||
#include <__type_traits/decay.h>
|
||||
#include <__type_traits/integral_constant.h>
|
||||
#include <__type_traits/is_assignable.h>
|
||||
#include <__type_traits/is_constructible.h>
|
||||
#include <__type_traits/is_convertible.h>
|
||||
#include <__type_traits/is_copy_assignable.h>
|
||||
#include <__type_traits/is_default_constructible.h>
|
||||
#include <__type_traits/is_implicitly_default_constructible.h>
|
||||
#include <__type_traits/is_move_assignable.h>
|
||||
#include <__type_traits/is_nothrow_assignable.h>
|
||||
#include <__type_traits/is_nothrow_constructible.h>
|
||||
#include <__type_traits/is_nothrow_copy_assignable.h>
|
||||
#include <__type_traits/is_nothrow_copy_constructible.h>
|
||||
#include <__type_traits/is_nothrow_default_constructible.h>
|
||||
#include <__type_traits/is_nothrow_move_assignable.h>
|
||||
#include <__type_traits/is_same.h>
|
||||
#include <__type_traits/is_swappable.h>
|
||||
#include <__type_traits/nat.h>
|
||||
#include <__type_traits/remove_cvref.h>
|
||||
#include <__type_traits/unwrap_ref.h>
|
||||
#include <__utility/declval.h>
|
||||
#include <__utility/forward.h>
|
||||
#include <__utility/move.h>
|
||||
#include <__utility/piecewise_construct.h>
|
||||
#include <cstddef>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
# pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class, class>
|
||||
struct __non_trivially_copyable_base {
|
||||
_LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI
|
||||
__non_trivially_copyable_base() _NOEXCEPT {}
|
||||
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
|
||||
__non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
|
||||
};
|
||||
|
||||
#if _LIBCPP_STD_VER >= 23
|
||||
template <class _Tp>
|
||||
struct __is_specialization_of_subrange : false_type {};
|
||||
|
||||
template <class _Iter, class _Sent, ranges::subrange_kind _Kind>
|
||||
struct __is_specialization_of_subrange<ranges::subrange<_Iter, _Sent, _Kind>> : true_type {};
|
||||
#endif
|
||||
|
||||
template <class _T1, class _T2>
|
||||
struct _LIBCPP_TEMPLATE_VIS pair
|
||||
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
|
||||
: private __non_trivially_copyable_base<_T1, _T2>
|
||||
#endif
|
||||
{
|
||||
using first_type = _T1;
|
||||
using second_type = _T2;
|
||||
|
||||
_T1 first;
|
||||
_T2 second;
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI pair(pair const&) = default;
|
||||
_LIBCPP_HIDE_FROM_ABI pair(pair&&) = default;
|
||||
|
||||
#ifdef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_HIDE_FROM_ABI
|
||||
pair() : first(), second() {}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI
|
||||
pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
|
||||
|
||||
template <class _U1, class _U2>
|
||||
_LIBCPP_HIDE_FROM_ABI
|
||||
pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI
|
||||
pair& operator=(pair const& __p) {
|
||||
first = __p.first;
|
||||
second = __p.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Extension: This is provided in C++03 because it allows properly handling the
|
||||
// assignment to a pair containing references, which would be a hard
|
||||
// error otherwise.
|
||||
template <class _U1, class _U2, class = __enable_if_t<
|
||||
is_assignable<first_type&, _U1 const&>::value &&
|
||||
is_assignable<second_type&, _U2 const&>::value
|
||||
> >
|
||||
_LIBCPP_HIDE_FROM_ABI
|
||||
pair& operator=(pair<_U1, _U2> const& __p) {
|
||||
first = __p.first;
|
||||
second = __p.second;
|
||||
return *this;
|
||||
}
|
||||
#else
|
||||
struct _CheckArgs {
|
||||
template <int&...>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() {
|
||||
return is_default_constructible<_T1>::value
|
||||
&& is_default_constructible<_T2>::value
|
||||
&& !__enable_implicit_default<>();
|
||||
}
|
||||
|
||||
template <int&...>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() {
|
||||
return __is_implicitly_default_constructible<_T1>::value
|
||||
&& __is_implicitly_default_constructible<_T2>::value;
|
||||
}
|
||||
|
||||
template <class _U1, class _U2>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_pair_constructible() {
|
||||
return is_constructible<first_type, _U1>::value
|
||||
&& is_constructible<second_type, _U2>::value;
|
||||
}
|
||||
|
||||
template <class _U1, class _U2>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_implicit() {
|
||||
return is_convertible<_U1, first_type>::value
|
||||
&& is_convertible<_U2, second_type>::value;
|
||||
}
|
||||
|
||||
template <class _U1, class _U2>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit() {
|
||||
return __is_pair_constructible<_U1, _U2>() && !__is_implicit<_U1, _U2>();
|
||||
}
|
||||
|
||||
template <class _U1, class _U2>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit() {
|
||||
return __is_pair_constructible<_U1, _U2>() && __is_implicit<_U1, _U2>();
|
||||
}
|
||||
};
|
||||
|
||||
template <bool _MaybeEnable>
|
||||
using _CheckArgsDep _LIBCPP_NODEBUG = typename conditional<
|
||||
_MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
|
||||
|
||||
template<bool _Dummy = true, typename enable_if<
|
||||
_CheckArgsDep<_Dummy>::__enable_explicit_default()
|
||||
>::type* = nullptr>
|
||||
explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
|
||||
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
|
||||
is_nothrow_default_constructible<second_type>::value)
|
||||
: first(), second() {}
|
||||
|
||||
template<bool _Dummy = true, typename enable_if<
|
||||
_CheckArgsDep<_Dummy>::__enable_implicit_default()
|
||||
>::type* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
|
||||
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
|
||||
is_nothrow_default_constructible<second_type>::value)
|
||||
: first(), second() {}
|
||||
|
||||
template <bool _Dummy = true, typename enable_if<
|
||||
_CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
|
||||
>::type* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
explicit pair(_T1 const& __t1, _T2 const& __t2)
|
||||
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
|
||||
is_nothrow_copy_constructible<second_type>::value)
|
||||
: first(__t1), second(__t2) {}
|
||||
|
||||
template<bool _Dummy = true, typename enable_if<
|
||||
_CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
|
||||
>::type* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair(_T1 const& __t1, _T2 const& __t2)
|
||||
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
|
||||
is_nothrow_copy_constructible<second_type>::value)
|
||||
: first(__t1), second(__t2) {}
|
||||
|
||||
template <
|
||||
#if _LIBCPP_STD_VER >= 23 // http://wg21.link/P1951
|
||||
class _U1 = _T1, class _U2 = _T2,
|
||||
#else
|
||||
class _U1, class _U2,
|
||||
#endif
|
||||
typename enable_if<_CheckArgs::template __enable_explicit<_U1, _U2>()>::type* = nullptr
|
||||
>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
explicit pair(_U1&& __u1, _U2&& __u2)
|
||||
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
|
||||
is_nothrow_constructible<second_type, _U2>::value))
|
||||
: first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) {}
|
||||
|
||||
template <
|
||||
#if _LIBCPP_STD_VER >= 23 // http://wg21.link/P1951
|
||||
class _U1 = _T1, class _U2 = _T2,
|
||||
#else
|
||||
class _U1, class _U2,
|
||||
#endif
|
||||
typename enable_if<_CheckArgs::template __enable_implicit<_U1, _U2>()>::type* = nullptr
|
||||
>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair(_U1&& __u1, _U2&& __u2)
|
||||
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
|
||||
is_nothrow_constructible<second_type, _U2>::value))
|
||||
: first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) {}
|
||||
|
||||
#if _LIBCPP_STD_VER >= 23
|
||||
template<class _U1, class _U2, __enable_if_t<
|
||||
_CheckArgs::template __is_pair_constructible<_U1&, _U2&>()
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
explicit(!_CheckArgs::template __is_implicit<_U1&, _U2&>()) pair(pair<_U1, _U2>& __p)
|
||||
noexcept((is_nothrow_constructible<first_type, _U1&>::value &&
|
||||
is_nothrow_constructible<second_type, _U2&>::value))
|
||||
: first(__p.first), second(__p.second) {}
|
||||
#endif
|
||||
|
||||
template<class _U1, class _U2, typename enable_if<
|
||||
_CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
|
||||
>::type* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
explicit pair(pair<_U1, _U2> const& __p)
|
||||
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
|
||||
is_nothrow_constructible<second_type, _U2 const&>::value))
|
||||
: first(__p.first), second(__p.second) {}
|
||||
|
||||
template<class _U1, class _U2, typename enable_if<
|
||||
_CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
|
||||
>::type* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair(pair<_U1, _U2> const& __p)
|
||||
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
|
||||
is_nothrow_constructible<second_type, _U2 const&>::value))
|
||||
: first(__p.first), second(__p.second) {}
|
||||
|
||||
template<class _U1, class _U2, typename enable_if<
|
||||
_CheckArgs::template __enable_explicit<_U1, _U2>()
|
||||
>::type* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
explicit pair(pair<_U1, _U2>&&__p)
|
||||
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
|
||||
is_nothrow_constructible<second_type, _U2&&>::value))
|
||||
: first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {}
|
||||
|
||||
template<class _U1, class _U2, typename enable_if<
|
||||
_CheckArgs::template __enable_implicit<_U1, _U2>()
|
||||
>::type* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair(pair<_U1, _U2>&& __p)
|
||||
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
|
||||
is_nothrow_constructible<second_type, _U2&&>::value))
|
||||
: first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {}
|
||||
|
||||
#if _LIBCPP_STD_VER >= 23
|
||||
template<class _U1, class _U2, __enable_if_t<
|
||||
_CheckArgs::template __is_pair_constructible<const _U1&&, const _U2&&>()
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
explicit(!_CheckArgs::template __is_implicit<const _U1&&, const _U2&&>())
|
||||
pair(const pair<_U1, _U2>&& __p)
|
||||
noexcept(is_nothrow_constructible<first_type, const _U1&&>::value &&
|
||||
is_nothrow_constructible<second_type, const _U2&&>::value)
|
||||
: first(std::move(__p.first)), second(std::move(__p.second)) {}
|
||||
#endif
|
||||
|
||||
# if _LIBCPP_STD_VER >= 23
|
||||
// This is a workaround for http://llvm.org/PR60710. We should be able to remove it once Clang is fixed.
|
||||
template <class _PairLike, bool _Enable = tuple_size<remove_cvref_t<_PairLike>>::value == 2>
|
||||
_LIBCPP_HIDE_FROM_ABI static constexpr bool __pair_like_explicit_wknd() {
|
||||
if constexpr (tuple_size<remove_cvref_t<_PairLike>>::value == 2) {
|
||||
return !is_convertible_v<decltype(std::get<0>(std::declval<_PairLike&&>())), first_type> ||
|
||||
!is_convertible_v<decltype(std::get<1>(std::declval<_PairLike&&>())), second_type>;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <__pair_like _PairLike>
|
||||
requires(is_constructible_v<first_type, decltype(std::get<0>(std::declval<_PairLike&&>()))> &&
|
||||
is_constructible_v<second_type, decltype(std::get<1>(std::declval<_PairLike&&>()))>)
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr explicit(__pair_like_explicit_wknd<_PairLike>())
|
||||
pair(_PairLike&& __p)
|
||||
: first(std::get<0>(std::forward<_PairLike>(__p))), second(std::get<1>(std::forward<_PairLike>(__p))) {}
|
||||
# endif
|
||||
|
||||
template <class... _Args1, class... _Args2>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
|
||||
pair(piecewise_construct_t __pc,
|
||||
tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
|
||||
_NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value &&
|
||||
is_nothrow_constructible<second_type, _Args2...>::value))
|
||||
: pair(__pc, __first_args, __second_args,
|
||||
typename __make_tuple_indices<sizeof...(_Args1)>::type(),
|
||||
typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
|
||||
pair& operator=(__conditional_t<
|
||||
is_copy_assignable<first_type>::value &&
|
||||
is_copy_assignable<second_type>::value,
|
||||
pair, __nat> const& __p)
|
||||
_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
|
||||
is_nothrow_copy_assignable<second_type>::value)
|
||||
{
|
||||
first = __p.first;
|
||||
second = __p.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
|
||||
pair& operator=(__conditional_t<
|
||||
is_move_assignable<first_type>::value &&
|
||||
is_move_assignable<second_type>::value,
|
||||
pair, __nat>&& __p)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
|
||||
is_nothrow_move_assignable<second_type>::value)
|
||||
{
|
||||
first = std::forward<first_type>(__p.first);
|
||||
second = std::forward<second_type>(__p.second);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class _U1, class _U2, __enable_if_t<
|
||||
is_assignable<first_type&, _U1 const&>::value &&
|
||||
is_assignable<second_type&, _U2 const&>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
|
||||
pair& operator=(pair<_U1, _U2> const& __p) {
|
||||
first = __p.first;
|
||||
second = __p.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class _U1, class _U2, __enable_if_t<
|
||||
is_assignable<first_type&, _U1>::value &&
|
||||
is_assignable<second_type&, _U2>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
|
||||
pair& operator=(pair<_U1, _U2>&& __p) {
|
||||
first = std::forward<_U1>(__p.first);
|
||||
second = std::forward<_U2>(__p.second);
|
||||
return *this;
|
||||
}
|
||||
|
||||
# if _LIBCPP_STD_VER >= 23
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
const pair& operator=(pair const& __p) const
|
||||
noexcept(is_nothrow_copy_assignable_v<const first_type> &&
|
||||
is_nothrow_copy_assignable_v<const second_type>)
|
||||
requires(is_copy_assignable_v<const first_type> &&
|
||||
is_copy_assignable_v<const second_type>) {
|
||||
first = __p.first;
|
||||
second = __p.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
const pair& operator=(pair&& __p) const
|
||||
noexcept(is_nothrow_assignable_v<const first_type&, first_type> &&
|
||||
is_nothrow_assignable_v<const second_type&, second_type>)
|
||||
requires(is_assignable_v<const first_type&, first_type> &&
|
||||
is_assignable_v<const second_type&, second_type>) {
|
||||
first = std::forward<first_type>(__p.first);
|
||||
second = std::forward<second_type>(__p.second);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class _U1, class _U2>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
const pair& operator=(const pair<_U1, _U2>& __p) const
|
||||
requires(is_assignable_v<const first_type&, const _U1&> &&
|
||||
is_assignable_v<const second_type&, const _U2&>) {
|
||||
first = __p.first;
|
||||
second = __p.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class _U1, class _U2>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
const pair& operator=(pair<_U1, _U2>&& __p) const
|
||||
requires(is_assignable_v<const first_type&, _U1> &&
|
||||
is_assignable_v<const second_type&, _U2>) {
|
||||
first = std::forward<_U1>(__p.first);
|
||||
second = std::forward<_U2>(__p.second);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <__pair_like _PairLike>
|
||||
requires(__different_from<_PairLike, pair> &&
|
||||
!__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value &&
|
||||
is_assignable_v<first_type&, decltype(std::get<0>(std::declval<_PairLike>()))> &&
|
||||
is_assignable_v<second_type&, decltype(std::get<1>(std::declval<_PairLike>()))>)
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(_PairLike&& __p) {
|
||||
first = std::get<0>(std::forward<_PairLike>(__p));
|
||||
second = std::get<1>(std::forward<_PairLike>(__p));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <__pair_like _PairLike>
|
||||
requires(__different_from<_PairLike, pair> &&
|
||||
!__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value &&
|
||||
is_assignable_v<first_type const&, decltype(std::get<0>(std::declval<_PairLike>()))> &&
|
||||
is_assignable_v<second_type const&, decltype(std::get<1>(std::declval<_PairLike>()))>)
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr pair const& operator=(_PairLike&& __p) const {
|
||||
first = std::get<0>(std::forward<_PairLike>(__p));
|
||||
second = std::get<1>(std::forward<_PairLike>(__p));
|
||||
return *this;
|
||||
}
|
||||
# endif // _LIBCPP_STD_VER >= 23
|
||||
|
||||
// Prior to C++23, we provide an approximation of constructors and assignment operators from
|
||||
// pair-like types. This was historically provided as an extension.
|
||||
#if _LIBCPP_STD_VER < 23
|
||||
// from std::tuple
|
||||
template<class _U1, class _U2, __enable_if_t<
|
||||
is_convertible<_U1 const&, _T1>::value &&
|
||||
is_convertible<_U2 const&, _T2>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair(tuple<_U1, _U2> const& __p)
|
||||
: first(std::get<0>(__p)),
|
||||
second(std::get<1>(__p)) {}
|
||||
|
||||
template<class _U1, class _U2, __enable_if_t<
|
||||
is_constructible<_T1, _U1 const&>::value &&
|
||||
is_constructible<_T2, _U2 const&>::value &&
|
||||
!(is_convertible<_U1 const&, _T1>::value &&
|
||||
is_convertible<_U2 const&, _T2>::value)
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
explicit
|
||||
pair(tuple<_U1, _U2> const& __p)
|
||||
: first(std::get<0>(__p)),
|
||||
second(std::get<1>(__p)) {}
|
||||
|
||||
template<class _U1, class _U2, __enable_if_t<
|
||||
is_convertible<_U1, _T1>::value &&
|
||||
is_convertible<_U2, _T2>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair(tuple<_U1, _U2>&& __p)
|
||||
: first(std::get<0>(std::move(__p))),
|
||||
second(std::get<1>(std::move(__p))) {}
|
||||
|
||||
template<class _U1, class _U2, __enable_if_t<
|
||||
is_constructible<_T1, _U1>::value &&
|
||||
is_constructible<_T2, _U2>::value &&
|
||||
!(is_convertible<_U1, _T1>::value &&
|
||||
is_convertible<_U2, _T2>::value)
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
explicit
|
||||
pair(tuple<_U1, _U2>&& __p)
|
||||
: first(std::get<0>(std::move(__p))),
|
||||
second(std::get<1>(std::move(__p))) {}
|
||||
|
||||
|
||||
template<class _U1, class _U2, __enable_if_t<
|
||||
is_assignable<_T1&, _U1 const&>::value &&
|
||||
is_assignable<_T2&, _U2 const&>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair& operator=(tuple<_U1, _U2> const& __p) {
|
||||
first = std::get<0>(__p);
|
||||
second = std::get<1>(__p);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class _U1, class _U2, __enable_if_t<
|
||||
is_assignable<_T1&, _U1&&>::value &&
|
||||
is_assignable<_T2&, _U2&&>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair& operator=(tuple<_U1, _U2>&& __p) {
|
||||
first = std::get<0>(std::move(__p));
|
||||
second = std::get<1>(std::move(__p));
|
||||
return *this;
|
||||
}
|
||||
|
||||
// from std::array
|
||||
template<class _Up, __enable_if_t<
|
||||
is_convertible<_Up const&, _T1>::value &&
|
||||
is_convertible<_Up const&, _T2>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair(array<_Up, 2> const& __p)
|
||||
: first(__p[0]),
|
||||
second(__p[1]) {}
|
||||
|
||||
template<class _Up, __enable_if_t<
|
||||
is_constructible<_T1, _Up const&>::value &&
|
||||
is_constructible<_T2, _Up const&>::value &&
|
||||
!(is_convertible<_Up const&, _T1>::value &&
|
||||
is_convertible<_Up const&, _T2>::value)
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
explicit
|
||||
pair(array<_Up, 2> const& __p)
|
||||
: first(__p[0]),
|
||||
second(__p[1]) {}
|
||||
|
||||
template<class _Up, __enable_if_t<
|
||||
is_convertible<_Up, _T1>::value &&
|
||||
is_convertible<_Up, _T2>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair(array<_Up, 2>&& __p)
|
||||
: first(std::move(__p)[0]),
|
||||
second(std::move(__p)[1]) {}
|
||||
|
||||
template<class _Up, __enable_if_t<
|
||||
is_constructible<_T1, _Up>::value &&
|
||||
is_constructible<_T2, _Up>::value &&
|
||||
!(is_convertible<_Up, _T1>::value &&
|
||||
is_convertible<_Up, _T2>::value)
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
explicit
|
||||
pair(array<_Up, 2>&& __p)
|
||||
: first(std::move(__p)[0]),
|
||||
second(std::move(__p)[1]) {}
|
||||
|
||||
|
||||
template<class _Up, __enable_if_t<
|
||||
is_assignable<_T1&, _Up const&>::value &&
|
||||
is_assignable<_T2&, _Up const&>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair& operator=(array<_Up, 2> const& __p) {
|
||||
first = std::get<0>(__p);
|
||||
second = std::get<1>(__p);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class _Up, __enable_if_t<
|
||||
is_assignable<_T1&, _Up>::value &&
|
||||
is_assignable<_T2&, _Up>::value
|
||||
>* = nullptr>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair& operator=(array<_Up, 2>&& __p) {
|
||||
first = std::get<0>(std::move(__p));
|
||||
second = std::get<1>(std::move(__p));
|
||||
return *this;
|
||||
}
|
||||
#endif // _LIBCPP_STD_VER < 23
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
|
||||
void
|
||||
swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
|
||||
__is_nothrow_swappable<second_type>::value)
|
||||
{
|
||||
using std::swap;
|
||||
swap(first, __p.first);
|
||||
swap(second, __p.second);
|
||||
}
|
||||
|
||||
#if _LIBCPP_STD_VER >= 23
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
void swap(const pair& __p) const
|
||||
noexcept(__is_nothrow_swappable<const first_type>::value &&
|
||||
__is_nothrow_swappable<const second_type>::value)
|
||||
{
|
||||
using std::swap;
|
||||
swap(first, __p.first);
|
||||
swap(second, __p.second);
|
||||
}
|
||||
#endif
|
||||
private:
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
|
||||
pair(piecewise_construct_t,
|
||||
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
|
||||
__tuple_indices<_I1...>, __tuple_indices<_I2...>);
|
||||
#endif
|
||||
};
|
||||
|
||||
#if _LIBCPP_STD_VER >= 17
|
||||
template<class _T1, class _T2>
|
||||
pair(_T1, _T2) -> pair<_T1, _T2>;
|
||||
#endif
|
||||
|
||||
// [pairs.spec], specialized algorithms
|
||||
|
||||
template <class _T1, class _T2, class _U1, class _U2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
bool
|
||||
operator==(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
|
||||
{
|
||||
return __x.first == __y.first && __x.second == __y.second;
|
||||
}
|
||||
|
||||
#if _LIBCPP_STD_VER >= 20
|
||||
|
||||
template <class _T1, class _T2, class _U1, class _U2>
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
common_comparison_category_t<
|
||||
__synth_three_way_result<_T1, _U1>,
|
||||
__synth_three_way_result<_T2, _U2> >
|
||||
operator<=>(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
|
||||
{
|
||||
if (auto __c = std::__synth_three_way(__x.first, __y.first); __c != 0) {
|
||||
return __c;
|
||||
}
|
||||
return std::__synth_three_way(__x.second, __y.second);
|
||||
}
|
||||
|
||||
#else // _LIBCPP_STD_VER >= 20
|
||||
|
||||
template <class _T1, class _T2, class _U1, class _U2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
bool
|
||||
operator!=(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
|
||||
{
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _T1, class _T2, class _U1, class _U2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
bool
|
||||
operator< (const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
|
||||
{
|
||||
return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
|
||||
}
|
||||
|
||||
template <class _T1, class _T2, class _U1, class _U2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
bool
|
||||
operator> (const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
|
||||
{
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
template <class _T1, class _T2, class _U1, class _U2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
bool
|
||||
operator>=(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
|
||||
{
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
template <class _T1, class _T2, class _U1, class _U2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
bool
|
||||
operator<=(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
|
||||
{
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_STD_VER >= 20
|
||||
|
||||
#if _LIBCPP_STD_VER >= 23
|
||||
template <class _T1, class _T2, class _U1, class _U2, template<class> class _TQual, template<class> class _UQual>
|
||||
requires requires { typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
|
||||
common_reference_t<_TQual<_T2>, _UQual<_U2>>>; }
|
||||
struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual> {
|
||||
using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
|
||||
common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
|
||||
};
|
||||
|
||||
template <class _T1, class _T2, class _U1, class _U2>
|
||||
requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; }
|
||||
struct common_type<pair<_T1, _T2>, pair<_U1, _U2>> {
|
||||
using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>;
|
||||
};
|
||||
#endif // _LIBCPP_STD_VER >= 23
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
|
||||
typename enable_if
|
||||
<
|
||||
__is_swappable<_T1>::value &&
|
||||
__is_swappable<_T2>::value,
|
||||
void
|
||||
>::type
|
||||
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
|
||||
_NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
|
||||
__is_nothrow_swappable<_T2>::value))
|
||||
{
|
||||
__x.swap(__y);
|
||||
}
|
||||
|
||||
#if _LIBCPP_STD_VER >= 23
|
||||
template <class _T1, class _T2>
|
||||
requires (__is_swappable<const _T1>::value &&
|
||||
__is_swappable<const _T2>::value)
|
||||
_LIBCPP_HIDE_FROM_ABI constexpr
|
||||
void swap(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
|
||||
noexcept(noexcept(__x.swap(__y)))
|
||||
{
|
||||
__x.swap(__y);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
|
||||
make_pair(_T1&& __t1, _T2&& __t2)
|
||||
{
|
||||
return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
|
||||
(std::forward<_T1>(__t1), std::forward<_T2>(__t2));
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
|
||||
: public integral_constant<size_t, 2> {};
|
||||
|
||||
template <size_t _Ip, class _T1, class _T2>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
|
||||
{
|
||||
static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
|
||||
};
|
||||
|
||||
template <class _T1, class _T2>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
|
||||
{
|
||||
using type _LIBCPP_NODEBUG = _T1;
|
||||
};
|
||||
|
||||
template <class _T1, class _T2>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
|
||||
{
|
||||
using type _LIBCPP_NODEBUG = _T2;
|
||||
};
|
||||
|
||||
template <size_t _Ip> struct __get_pair;
|
||||
|
||||
template <>
|
||||
struct __get_pair<0>
|
||||
{
|
||||
template <class _T1, class _T2>
|
||||
static
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
_T1&
|
||||
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
static
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
const _T1&
|
||||
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
static
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
_T1&&
|
||||
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<_T1>(__p.first);}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
static
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
const _T1&&
|
||||
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<const _T1>(__p.first);}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct __get_pair<1>
|
||||
{
|
||||
template <class _T1, class _T2>
|
||||
static
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
_T2&
|
||||
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
static
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
const _T2&
|
||||
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
static
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
_T2&&
|
||||
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<_T2>(__p.second);}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
static
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
const _T2&&
|
||||
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<const _T2>(__p.second);}
|
||||
};
|
||||
|
||||
template <size_t _Ip, class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
typename tuple_element<_Ip, pair<_T1, _T2> >::type&
|
||||
get(pair<_T1, _T2>& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<_Ip>::get(__p);
|
||||
}
|
||||
|
||||
template <size_t _Ip, class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
|
||||
get(const pair<_T1, _T2>& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<_Ip>::get(__p);
|
||||
}
|
||||
|
||||
template <size_t _Ip, class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
|
||||
get(pair<_T1, _T2>&& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<_Ip>::get(std::move(__p));
|
||||
}
|
||||
|
||||
template <size_t _Ip, class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
|
||||
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
|
||||
get(const pair<_T1, _T2>&& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<_Ip>::get(std::move(__p));
|
||||
}
|
||||
|
||||
#if _LIBCPP_STD_VER >= 14
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI
|
||||
constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<0>::get(__p);
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI
|
||||
constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<0>::get(__p);
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI
|
||||
constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<0>::get(std::move(__p));
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI
|
||||
constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<0>::get(std::move(__p));
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI
|
||||
constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<1>::get(__p);
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI
|
||||
constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<1>::get(__p);
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI
|
||||
constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<1>::get(std::move(__p));
|
||||
}
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline _LIBCPP_HIDE_FROM_ABI
|
||||
constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
|
||||
{
|
||||
return __get_pair<1>::get(std::move(__p));
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_STD_VER >= 14
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP___UTILITY_PAIR_H
|
||||
Loading…
Add table
Add a link
Reference in a new issue