maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/__utility/pair.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

610 lines
20 KiB
C
Raw Normal View History

[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
//===----------------------------------------------------------------------===//
//
// 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
[libc++][spaceship] Implement std::pair::operator<=> Implements parts of P1614, including synth-three-way and three way comparison for std::pair. Reviewed By: #libc, Quuxplusone, Mordante Differential Revision: https://reviews.llvm.org/D107721
2021-09-23 13:36:23 +08:00
#include <__compare/common_comparison_category.h>
#include <__compare/synth_three_way.h>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
#include <__config>
#include <__functional/unwrap_ref.h>
#include <__tuple>
#include <__utility/forward.h>
#include <__utility/move.h>
#include <__utility/piecewise_construct.h>
#include <cstddef>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
template <class, class>
struct __non_trivially_copyable_base {
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
__non_trivially_copyable_base() _NOEXCEPT {}
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
__non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
};
#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
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
#if !defined(_LIBCPP_CXX03_LANG)
pair(pair const&) = default;
pair(pair&&) = default;
#else
// Use the implicitly declared copy constructor in C++03
#endif
#ifdef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
pair() : first(), second() {}
_LIBCPP_INLINE_VISIBILITY
pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
template <class _U1, class _U2>
_LIBCPP_INLINE_VISIBILITY
pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
_LIBCPP_INLINE_VISIBILITY
pair& operator=(pair const& __p) {
first = __p.first;
second = __p.second;
return *this;
}
#else
struct _CheckArgs {
template <int&...>
static constexpr bool __enable_explicit_default() {
return is_default_constructible<_T1>::value
&& is_default_constructible<_T2>::value
&& !__enable_implicit_default<>();
}
template <int&...>
static constexpr bool __enable_implicit_default() {
return __is_implicitly_default_constructible<_T1>::value
&& __is_implicitly_default_constructible<_T2>::value;
}
template <class _U1, class _U2>
static constexpr bool __enable_explicit() {
return is_constructible<first_type, _U1>::value
&& is_constructible<second_type, _U2>::value
&& (!is_convertible<_U1, first_type>::value
|| !is_convertible<_U2, second_type>::value);
}
template <class _U1, class _U2>
static constexpr bool __enable_implicit() {
return is_constructible<first_type, _U1>::value
&& is_constructible<second_type, _U2>::value
&& is_convertible<_U1, first_type>::value
&& is_convertible<_U2, second_type>::value;
}
};
template <bool _MaybeEnable>
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using _CheckArgsDep _LIBCPP_NODEBUG = typename conditional<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
struct _CheckTupleLikeConstructor {
template <class _Tuple>
static constexpr bool __enable_implicit() {
return __tuple_convertible<_Tuple, pair>::value;
}
template <class _Tuple>
static constexpr bool __enable_explicit() {
return __tuple_constructible<_Tuple, pair>::value
&& !__tuple_convertible<_Tuple, pair>::value;
}
template <class _Tuple>
static constexpr bool __enable_assign() {
return __tuple_assignable<_Tuple, pair>::value;
}
};
template <class _Tuple>
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using _CheckTLC _LIBCPP_NODEBUG = typename conditional<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
__tuple_like_with_size<_Tuple, 2>::value
&& !is_same<typename decay<_Tuple>::type, pair>::value,
_CheckTupleLikeConstructor,
__check_tuple_constructor_fail
>::type;
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<bool _Dummy = true, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckArgsDep<_Dummy>::__enable_explicit_default()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
is_nothrow_default_constructible<second_type>::value)
: first(), second() {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<bool _Dummy = true, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckArgsDep<_Dummy>::__enable_implicit_default()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
is_nothrow_default_constructible<second_type>::value)
: first(), second() {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template <bool _Dummy = true, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
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) {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<bool _Dummy = true, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
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) {}
[libc++] Do not enable P1951 before C++23, since it's a breaking change In reaction to the issues raised by Richard in https://llvm.org/D109066, this commit does not apply P1951 as a DR in previous standard modes, since it breaks valid code. I do believe it should be applied as a DR, however ideally we'd get some sort of statement from the Committee to this effect (and all implementations would behave consistently). In the meantime, only implement P1951 starting with C++23 -- we can always come back and apply it as a DR if that's what the Committee says. Differential Revision: https://reviews.llvm.org/D110347
2021-09-24 00:47:24 +08:00
template <
#if _LIBCPP_STD_VER > 20 // 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
>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(_U1&& __u1, _U2&& __u2)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
is_nothrow_constructible<second_type, _U2>::value))
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
[libc++] Do not enable P1951 before C++23, since it's a breaking change In reaction to the issues raised by Richard in https://llvm.org/D109066, this commit does not apply P1951 as a DR in previous standard modes, since it breaks valid code. I do believe it should be applied as a DR, however ideally we'd get some sort of statement from the Committee to this effect (and all implementations would behave consistently). In the meantime, only implement P1951 starting with C++23 -- we can always come back and apply it as a DR if that's what the Committee says. Differential Revision: https://reviews.llvm.org/D110347
2021-09-24 00:47:24 +08:00
template <
#if _LIBCPP_STD_VER > 20 // 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
>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(_U1&& __u1, _U2&& __u2)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
is_nothrow_constructible<second_type, _U2>::value))
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<class _U1, class _U2, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
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) {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<class _U1, class _U2, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
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) {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<class _U1, class _U2, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckArgs::template __enable_explicit<_U1, _U2>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(pair<_U1, _U2>&&__p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
is_nothrow_constructible<second_type, _U2&&>::value))
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<class _U1, class _U2, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckArgs::template __enable_implicit<_U1, _U2>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(pair<_U1, _U2>&& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
is_nothrow_constructible<second_type, _U2&&>::value))
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<class _Tuple, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(_Tuple&& __p)
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template<class _Tuple, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(_Tuple&& __p)
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
template <class... _Args1, class... _Args2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
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_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair& operator=(typename conditional<
is_copy_assignable<first_type>::value &&
is_copy_assignable<second_type>::value,
pair, __nat>::type 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_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair& operator=(typename conditional<
is_move_assignable<first_type>::value &&
is_move_assignable<second_type>::value,
pair, __nat>::type&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
is_nothrow_move_assignable<second_type>::value)
{
first = _VSTD::forward<first_type>(__p.first);
second = _VSTD::forward<second_type>(__p.second);
return *this;
}
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
template <class _Tuple, typename enable_if<
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_CheckTLC<_Tuple>::template __enable_assign<_Tuple>()
[libc++][NFC] Use std::enable_if instead of _EnableB helper in pair This doesn't impact the compile-time efficiency, but we get better diagnostics when an overload is disabled.
2021-09-01 22:47:03 +08:00
>::type* = nullptr>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair& operator=(_Tuple&& __p) {
first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
return *this;
}
#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
void
swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
__is_nothrow_swappable<second_type>::value)
{
using _VSTD::swap;
swap(first, __p.first);
swap(second, __p.second);
}
private:
#ifndef _LIBCPP_CXX03_LANG
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>);
#endif
};
[libc++] Remove workarounds for the lack of deduction guides in C++17 All supported compilers have supported deduction guides in C++17 for a while, so this isn't necessary anymore. Differential Revision: https://reviews.llvm.org/D108213
2021-08-17 23:59:07 +08:00
#if _LIBCPP_STD_VER >= 17
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
template<class _T1, class _T2>
pair(_T1, _T2) -> pair<_T1, _T2>;
[libc++] Remove workarounds for the lack of deduction guides in C++17 All supported compilers have supported deduction guides in C++17 for a while, so this isn't necessary anymore. Differential Revision: https://reviews.llvm.org/D108213
2021-08-17 23:59:07 +08:00
#endif
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
[libc++][spaceship] Implement std::pair::operator<=> Implements parts of P1614, including synth-three-way and three way comparison for std::pair. Reviewed By: #libc, Quuxplusone, Mordante Differential Revision: https://reviews.llvm.org/D107721
2021-09-23 13:36:23 +08:00
// [pairs.spec], specialized algorithms
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return __x.first == __y.first && __x.second == __y.second;
}
[libc++] Remove _LIBCPP_HAS_NO_SPACESHIP_OPERATOR All supported compilers support spaceship in C++20 nowadays. Differential Revision: https://reviews.llvm.org/D113938
2021-11-16 05:47:58 +08:00
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
[libc++][spaceship] Implement std::pair::operator<=> Implements parts of P1614, including synth-three-way and three way comparison for std::pair. Reviewed By: #libc, Quuxplusone, Mordante Differential Revision: https://reviews.llvm.org/D107721
2021-09-23 13:36:23 +08:00
template <class _T1, class _T2>
_LIBCPP_HIDE_FROM_ABI constexpr
common_comparison_category_t<
__synth_three_way_result<_T1>,
__synth_three_way_result<_T2> >
operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) {
return __c;
}
return _VSTD::__synth_three_way(__x.second, __y.second);
}
[libc++] Remove _LIBCPP_HAS_NO_SPACESHIP_OPERATOR All supported compilers support spaceship in C++20 nowadays. Differential Revision: https://reviews.llvm.org/D113938
2021-11-16 05:47:58 +08:00
#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
[libc++][spaceship] Implement std::pair::operator<=> Implements parts of P1614, including synth-three-way and three way comparison for std::pair. Reviewed By: #libc, Quuxplusone, Mordante Differential Revision: https://reviews.llvm.org/D107721
2021-09-23 13:36:23 +08:00
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return !(__x == __y);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return __y < __x;
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return !(__x < __y);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool
operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{
return !(__y < __x);
}
[libc++] Remove _LIBCPP_HAS_NO_SPACESHIP_OPERATOR All supported compilers support spaceship in C++20 nowadays. Differential Revision: https://reviews.llvm.org/D113938
2021-11-16 05:47:58 +08:00
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
[libc++][spaceship] Implement std::pair::operator<=> Implements parts of P1614, including synth-three-way and three way comparison for std::pair. Reviewed By: #libc, Quuxplusone, Mordante Differential Revision: https://reviews.llvm.org/D107721
2021-09-23 13:36:23 +08:00
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
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);
}
#ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
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>
(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
}
#else // _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
pair<_T1,_T2>
make_pair(_T1 __x, _T2 __y)
{
return pair<_T1, _T2>(__x, __y);
}
#endif // _LIBCPP_CXX03_LANG
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> >
{
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
typedef _LIBCPP_NODEBUG _T1 type;
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
};
template <class _T1, class _T2>
struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
{
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
typedef _LIBCPP_NODEBUG _T2 type;
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
};
template <size_t _Ip> struct __get_pair;
template <>
struct __get_pair<0>
{
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
_T1&
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const _T1&
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
#ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
_T1&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const _T1&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}
#endif // _LIBCPP_CXX03_LANG
};
template <>
struct __get_pair<1>
{
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
_T2&
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const _T2&
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
#ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
_T2&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
template <class _T1, class _T2>
static
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const _T2&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}
#endif // _LIBCPP_CXX03_LANG
};
template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
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_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
get(const pair<_T1, _T2>& __p) _NOEXCEPT
{
return __get_pair<_Ip>::get(__p);
}
#ifndef _LIBCPP_CXX03_LANG
template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT
{
return __get_pair<_Ip>::get(_VSTD::move(__p));
}
template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT
{
return __get_pair<_Ip>::get(_VSTD::move(__p));
}
#endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 11
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
{
return __get_pair<0>::get(__p);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
{
return __get_pair<0>::get(__p);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
{
return __get_pair<0>::get(_VSTD::move(__p));
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
{
return __get_pair<0>::get(_VSTD::move(__p));
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
{
return __get_pair<1>::get(__p);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
{
return __get_pair<1>::get(__p);
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
{
return __get_pair<1>::get(_VSTD::move(__p));
}
template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY
constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
{
return __get_pair<1>::get(_VSTD::move(__p));
}
#endif
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_PAIR_H