diff options
Diffstat (limited to 'contrib/llvm-project/libcxx/include/__utility')
26 files changed, 2011 insertions, 0 deletions
diff --git a/contrib/llvm-project/libcxx/include/__utility/as_const.h b/contrib/llvm-project/libcxx/include/__utility/as_const.h new file mode 100644 index 000000000000..582dd42f4079 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/as_const.h @@ -0,0 +1,35 @@ +//===----------------------------------------------------------------------===// +// +// 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_AS_CONST_H +#define _LIBCPP___UTILITY_AS_CONST_H + +#include <__config> +#include <__type_traits/add_const.h> +#include <__utility/forward.h> +#include <__utility/move.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER >= 17 +template <class _Tp> +[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { + return __t; +} + +template <class _Tp> +void as_const(const _Tp&&) = delete; +#endif + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_AS_CONST_H diff --git a/contrib/llvm-project/libcxx/include/__utility/as_lvalue.h b/contrib/llvm-project/libcxx/include/__utility/as_lvalue.h new file mode 100644 index 000000000000..159f45dad4d4 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/as_lvalue.h @@ -0,0 +1,37 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// 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_AS_LVALUE_H +#define _LIBCPP___UTILITY_AS_LVALUE_H + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +#ifndef _LIBCPP_CXX03_LANG + +template <class _Tp> +_LIBCPP_HIDE_FROM_ABI constexpr _Tp& __as_lvalue(_LIBCPP_LIFETIMEBOUND _Tp&& __t) { + return static_cast<_Tp&>(__t); +} + +#endif // !_LIBCPP_CXX03_LANG + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___UTILITY_AS_LVALUE_H diff --git a/contrib/llvm-project/libcxx/include/__utility/auto_cast.h b/contrib/llvm-project/libcxx/include/__utility/auto_cast.h new file mode 100644 index 000000000000..06715b3438f9 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/auto_cast.h @@ -0,0 +1,22 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// 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_AUTO_CAST_H +#define _LIBCPP___UTILITY_AUTO_CAST_H + +#include <__config> +#include <__type_traits/decay.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +#define _LIBCPP_AUTO_CAST(expr) static_cast<::std::__decay_t<decltype((expr))> >(expr) + +#endif // _LIBCPP___UTILITY_AUTO_CAST_H diff --git a/contrib/llvm-project/libcxx/include/__utility/cmp.h b/contrib/llvm-project/libcxx/include/__utility/cmp.h new file mode 100644 index 000000000000..b7c1ed614dfc --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/cmp.h @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// +// 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_CMP_H +#define _LIBCPP___UTILITY_CMP_H + +#include <__concepts/arithmetic.h> +#include <__config> +#include <__type_traits/is_signed.h> +#include <__type_traits/make_unsigned.h> +#include <limits> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER >= 20 + +template <__libcpp_integer _Tp, __libcpp_integer _Up> +_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept { + if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>) + return __t == __u; + else if constexpr (is_signed_v<_Tp>) + return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u; + else + return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u); +} + +template <__libcpp_integer _Tp, __libcpp_integer _Up> +_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept { + return !std::cmp_equal(__t, __u); +} + +template <__libcpp_integer _Tp, __libcpp_integer _Up> +_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept { + if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>) + return __t < __u; + else if constexpr (is_signed_v<_Tp>) + return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u; + else + return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u); +} + +template <__libcpp_integer _Tp, __libcpp_integer _Up> +_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept { + return std::cmp_less(__u, __t); +} + +template <__libcpp_integer _Tp, __libcpp_integer _Up> +_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept { + return !std::cmp_greater(__t, __u); +} + +template <__libcpp_integer _Tp, __libcpp_integer _Up> +_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept { + return !std::cmp_less(__t, __u); +} + +template <__libcpp_integer _Tp, __libcpp_integer _Up> +_LIBCPP_HIDE_FROM_ABI constexpr bool in_range(_Up __u) noexcept { + return std::cmp_less_equal(__u, numeric_limits<_Tp>::max()) && + std::cmp_greater_equal(__u, numeric_limits<_Tp>::min()); +} + +#endif // _LIBCPP_STD_VER >= 20 + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___UTILITY_CMP_H diff --git a/contrib/llvm-project/libcxx/include/__utility/convert_to_integral.h b/contrib/llvm-project/libcxx/include/__utility/convert_to_integral.h new file mode 100644 index 000000000000..f1fcdd98010c --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/convert_to_integral.h @@ -0,0 +1,68 @@ +//===----------------------------------------------------------------------===// +// +// 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_CONVERT_TO_INTEGRAL_H +#define _LIBCPP___UTILITY_CONVERT_TO_INTEGRAL_H + +#include <__config> +#include <__type_traits/enable_if.h> +#include <__type_traits/is_enum.h> +#include <__type_traits/is_floating_point.h> +#include <__type_traits/underlying_type.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __convert_to_integral(int __val) { return __val; } + +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned __convert_to_integral(unsigned __val) { return __val; } + +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long __convert_to_integral(long __val) { return __val; } + +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned long __convert_to_integral(unsigned long __val) { + return __val; +} + +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long long __convert_to_integral(long long __val) { return __val; } + +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned long long __convert_to_integral(unsigned long long __val) { + return __val; +} + +template <typename _Fp, __enable_if_t<is_floating_point<_Fp>::value, int> = 0> +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long long __convert_to_integral(_Fp __val) { + return __val; +} + +#ifndef _LIBCPP_HAS_NO_INT128 +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __int128_t __convert_to_integral(__int128_t __val) { return __val; } + +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __uint128_t __convert_to_integral(__uint128_t __val) { return __val; } +#endif + +template <class _Tp, bool = is_enum<_Tp>::value> +struct __sfinae_underlying_type { + typedef typename underlying_type<_Tp>::type type; + typedef decltype(((type)1) + 0) __promoted_type; +}; + +template <class _Tp> +struct __sfinae_underlying_type<_Tp, false> {}; + +template <class _Tp> +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename __sfinae_underlying_type<_Tp>::__promoted_type +__convert_to_integral(_Tp __val) { + return __val; +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_CONVERT_TO_INTEGRAL_H diff --git a/contrib/llvm-project/libcxx/include/__utility/declval.h b/contrib/llvm-project/libcxx/include/__utility/declval.h new file mode 100644 index 000000000000..d0856b8afa4d --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/declval.h @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// 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_DECLVAL_H +#define _LIBCPP___UTILITY_DECLVAL_H + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +// Suppress deprecation notice for volatile-qualified return type resulting +// from volatile-qualified types _Tp. +_LIBCPP_SUPPRESS_DEPRECATED_PUSH +template <class _Tp> +_Tp&& __declval(int); +template <class _Tp> +_Tp __declval(long); +_LIBCPP_SUPPRESS_DEPRECATED_POP + +template <class _Tp> +_LIBCPP_HIDE_FROM_ABI decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT { + static_assert(!__is_same(_Tp, _Tp), + "std::declval can only be used in an unevaluated context. " + "It's likely that your current usage is trying to extract a value from the function."); +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_DECLVAL_H diff --git a/contrib/llvm-project/libcxx/include/__utility/empty.h b/contrib/llvm-project/libcxx/include/__utility/empty.h new file mode 100644 index 000000000000..8cca197145c7 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/empty.h @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// 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_EMPTY_H +#define _LIBCPP___UTILITY_EMPTY_H + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +struct __empty {}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_EMPTY_H diff --git a/contrib/llvm-project/libcxx/include/__utility/exception_guard.h b/contrib/llvm-project/libcxx/include/__utility/exception_guard.h new file mode 100644 index 000000000000..9f732ca265c8 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/exception_guard.h @@ -0,0 +1,144 @@ +//===----------------------------------------------------------------------===// +// +// 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_TRANSACTION_H +#define _LIBCPP___UTILITY_TRANSACTION_H + +#include <__assert> +#include <__config> +#include <__type_traits/is_nothrow_constructible.h> +#include <__utility/exchange.h> +#include <__utility/move.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +// __exception_guard is a helper class for writing code with the strong exception guarantee. +// +// When writing code that can throw an exception, one can store rollback instructions in an +// exception guard so that if an exception is thrown at any point during the lifetime of the +// exception guard, it will be rolled back automatically. When the exception guard is done, one +// must mark it as being complete so it isn't rolled back when the exception guard is destroyed. +// +// Exception guards are not default constructible, they can't be copied or assigned to, but +// they can be moved around for convenience. +// +// __exception_guard is a no-op in -fno-exceptions mode to produce better code-gen. This means +// that we don't provide the strong exception guarantees. However, Clang doesn't generate cleanup +// code with exceptions disabled, so even if we wanted to provide the strong exception guarantees +// we couldn't. This is also only relevant for constructs with a stack of +// -fexceptions > -fno-exceptions > -fexceptions code, since the exception can't be caught where +// exceptions are disabled. While -fexceptions > -fno-exceptions is quite common +// (e.g. libc++.dylib > -fno-exceptions), having another layer with exceptions enabled seems a lot +// less common, especially one that tries to catch an exception through -fno-exceptions code. +// +// __exception_guard can help greatly simplify code that would normally be cluttered by +// `#if _LIBCPP_HAS_NO_EXCEPTIONS`. For example: +// +// template <class Iterator, class Size, class OutputIterator> +// Iterator uninitialized_copy_n(Iterator iter, Size n, OutputIterator out) { +// typedef typename iterator_traits<Iterator>::value_type value_type; +// __exception_guard guard([start=out, &out] { +// std::destroy(start, out); +// }); +// +// for (; n > 0; ++iter, ++out, --n) { +// ::new ((void*)std::addressof(*out)) value_type(*iter); +// } +// guard.__complete(); +// return out; +// } +// + +template <class _Rollback> +struct __exception_guard_exceptions { + __exception_guard_exceptions() = delete; + + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __exception_guard_exceptions(_Rollback __rollback) + : __rollback_(std::move(__rollback)), __completed_(false) {} + + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 + __exception_guard_exceptions(__exception_guard_exceptions&& __other) + _NOEXCEPT_(is_nothrow_move_constructible<_Rollback>::value) + : __rollback_(std::move(__other.__rollback_)), __completed_(__other.__completed_) { + __other.__completed_ = true; + } + + __exception_guard_exceptions(__exception_guard_exceptions const&) = delete; + __exception_guard_exceptions& operator=(__exception_guard_exceptions const&) = delete; + __exception_guard_exceptions& operator=(__exception_guard_exceptions&&) = delete; + + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __complete() _NOEXCEPT { __completed_ = true; } + + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__exception_guard_exceptions() { + if (!__completed_) + __rollback_(); + } + +private: + _Rollback __rollback_; + bool __completed_; +}; + +_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__exception_guard_exceptions); + +template <class _Rollback> +struct __exception_guard_noexceptions { + __exception_guard_noexceptions() = delete; + _LIBCPP_HIDE_FROM_ABI + _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NODEBUG explicit __exception_guard_noexceptions(_Rollback) {} + + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NODEBUG + __exception_guard_noexceptions(__exception_guard_noexceptions&& __other) + _NOEXCEPT_(is_nothrow_move_constructible<_Rollback>::value) + : __completed_(__other.__completed_) { + __other.__completed_ = true; + } + + __exception_guard_noexceptions(__exception_guard_noexceptions const&) = delete; + __exception_guard_noexceptions& operator=(__exception_guard_noexceptions const&) = delete; + __exception_guard_noexceptions& operator=(__exception_guard_noexceptions&&) = delete; + + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NODEBUG void __complete() _NOEXCEPT { + __completed_ = true; + } + + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NODEBUG ~__exception_guard_noexceptions() { + _LIBCPP_ASSERT_INTERNAL(__completed_, "__exception_guard not completed with exceptions disabled"); + } + +private: + bool __completed_ = false; +}; + +_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__exception_guard_noexceptions); + +#ifdef _LIBCPP_HAS_NO_EXCEPTIONS +template <class _Rollback> +using __exception_guard = __exception_guard_noexceptions<_Rollback>; +#else +template <class _Rollback> +using __exception_guard = __exception_guard_exceptions<_Rollback>; +#endif + +template <class _Rollback> +_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard<_Rollback> __make_exception_guard(_Rollback __rollback) { + return __exception_guard<_Rollback>(std::move(__rollback)); +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___UTILITY_TRANSACTION_H diff --git a/contrib/llvm-project/libcxx/include/__utility/exchange.h b/contrib/llvm-project/libcxx/include/__utility/exchange.h new file mode 100644 index 000000000000..957e9d0acaa6 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/exchange.h @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// 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_EXCHANGE_H +#define _LIBCPP___UTILITY_EXCHANGE_H + +#include <__config> +#include <__type_traits/is_nothrow_assignable.h> +#include <__type_traits/is_nothrow_constructible.h> +#include <__utility/forward.h> +#include <__utility/move.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER >= 14 +template <class _T1, class _T2 = _T1> +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _T1 exchange(_T1& __obj, _T2&& __new_value) noexcept( + is_nothrow_move_constructible<_T1>::value && is_nothrow_assignable<_T1&, _T2>::value) { + _T1 __old_value = std::move(__obj); + __obj = std::forward<_T2>(__new_value); + return __old_value; +} +#endif // _LIBCPP_STD_VER >= 14 + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___UTILITY_EXCHANGE_H diff --git a/contrib/llvm-project/libcxx/include/__utility/forward.h b/contrib/llvm-project/libcxx/include/__utility/forward.h new file mode 100644 index 000000000000..d5275dcbd0ed --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/forward.h @@ -0,0 +1,38 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// 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_FORWARD_H +#define _LIBCPP___UTILITY_FORWARD_H + +#include <__config> +#include <__type_traits/is_reference.h> +#include <__type_traits/remove_reference.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Tp> +_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp&& +forward(_LIBCPP_LIFETIMEBOUND __libcpp_remove_reference_t<_Tp>& __t) _NOEXCEPT { + return static_cast<_Tp&&>(__t); +} + +template <class _Tp> +_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp&& +forward(_LIBCPP_LIFETIMEBOUND __libcpp_remove_reference_t<_Tp>&& __t) _NOEXCEPT { + static_assert(!is_lvalue_reference<_Tp>::value, "cannot forward an rvalue as an lvalue"); + return static_cast<_Tp&&>(__t); +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_FORWARD_H diff --git a/contrib/llvm-project/libcxx/include/__utility/forward_like.h b/contrib/llvm-project/libcxx/include/__utility/forward_like.h new file mode 100644 index 000000000000..0206ce23a566 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/forward_like.h @@ -0,0 +1,46 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// 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_FORWARD_LIKE_H +#define _LIBCPP___UTILITY_FORWARD_LIKE_H + +#include <__config> +#include <__type_traits/conditional.h> +#include <__type_traits/is_const.h> +#include <__type_traits/is_reference.h> +#include <__type_traits/remove_reference.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER >= 23 + +template <class _Ap, class _Bp> +using _CopyConst = _If<is_const_v<_Ap>, const _Bp, _Bp>; + +template <class _Ap, class _Bp> +using _OverrideRef = _If<is_rvalue_reference_v<_Ap>, remove_reference_t<_Bp>&&, _Bp&>; + +template <class _Ap, class _Bp> +using _ForwardLike = _OverrideRef<_Ap&&, _CopyConst<remove_reference_t<_Ap>, remove_reference_t<_Bp>>>; + +template <class _Tp, class _Up> +[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto +forward_like(_LIBCPP_LIFETIMEBOUND _Up&& __ux) noexcept -> _ForwardLike<_Tp, _Up> { + return static_cast<_ForwardLike<_Tp, _Up>>(__ux); +} + +#endif // _LIBCPP_STD_VER >= 23 + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_FORWARD_LIKE_H diff --git a/contrib/llvm-project/libcxx/include/__utility/in_place.h b/contrib/llvm-project/libcxx/include/__utility/in_place.h new file mode 100644 index 000000000000..fa7a2f4bfd4a --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/in_place.h @@ -0,0 +1,63 @@ +//===----------------------------------------------------------------------===// +// +// 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_IN_PLACE_H +#define _LIBCPP___UTILITY_IN_PLACE_H + +#include <__config> +#include <__type_traits/remove_cvref.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER >= 17 + +struct _LIBCPP_EXPORTED_FROM_ABI in_place_t { + explicit in_place_t() = default; +}; +inline constexpr in_place_t in_place{}; + +template <class _Tp> +struct _LIBCPP_TEMPLATE_VIS in_place_type_t { + _LIBCPP_HIDE_FROM_ABI explicit in_place_type_t() = default; +}; +template <class _Tp> +inline constexpr in_place_type_t<_Tp> in_place_type{}; + +template <size_t _Idx> +struct _LIBCPP_TEMPLATE_VIS in_place_index_t { + _LIBCPP_HIDE_FROM_ABI explicit in_place_index_t() = default; +}; +template <size_t _Idx> +inline constexpr in_place_index_t<_Idx> in_place_index{}; + +template <class _Tp> +struct __is_inplace_type_imp : false_type {}; +template <class _Tp> +struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {}; + +template <class _Tp> +using __is_inplace_type = __is_inplace_type_imp<__remove_cvref_t<_Tp>>; + +template <class _Tp> +struct __is_inplace_index_imp : false_type {}; +template <size_t _Idx> +struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {}; + +template <class _Tp> +using __is_inplace_index = __is_inplace_index_imp<__remove_cvref_t<_Tp>>; + +#endif // _LIBCPP_STD_VER >= 17 + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_IN_PLACE_H diff --git a/contrib/llvm-project/libcxx/include/__utility/integer_sequence.h b/contrib/llvm-project/libcxx/include/__utility/integer_sequence.h new file mode 100644 index 000000000000..ccce9433e7a8 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/integer_sequence.h @@ -0,0 +1,90 @@ +//===----------------------------------------------------------------------===// +// +// 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_INTEGER_SEQUENCE_H +#define _LIBCPP___UTILITY_INTEGER_SEQUENCE_H + +#include <__config> +#include <__type_traits/is_integral.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <size_t...> +struct __tuple_indices; + +template <class _IdxType, _IdxType... _Values> +struct __integer_sequence { + template <template <class _OIdxType, _OIdxType...> class _ToIndexSeq, class _ToIndexType> + using __convert = _ToIndexSeq<_ToIndexType, _Values...>; + + template <size_t _Sp> + using __to_tuple_indices = __tuple_indices<(_Values + _Sp)...>; +}; + +#if __has_builtin(__make_integer_seq) +template <size_t _Ep, size_t _Sp> +using __make_indices_imp = + typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template __to_tuple_indices<_Sp>; +#elif __has_builtin(__integer_pack) +template <size_t _Ep, size_t _Sp> +using __make_indices_imp = + typename __integer_sequence<size_t, __integer_pack(_Ep - _Sp)...>::template __to_tuple_indices<_Sp>; +#else +# error "No known way to get an integer pack from the compiler" +#endif + +#if _LIBCPP_STD_VER >= 14 + +template <class _Tp, _Tp... _Ip> +struct _LIBCPP_TEMPLATE_VIS integer_sequence { + typedef _Tp value_type; + static_assert(is_integral<_Tp>::value, "std::integer_sequence can only be instantiated with an integral type"); + static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return sizeof...(_Ip); } +}; + +template <size_t... _Ip> +using index_sequence = integer_sequence<size_t, _Ip...>; + +# if __has_builtin(__make_integer_seq) + +template <class _Tp, _Tp _Ep> +using make_integer_sequence _LIBCPP_NODEBUG = __make_integer_seq<integer_sequence, _Tp, _Ep>; + +# elif __has_builtin(__integer_pack) + +template <class _Tp, _Tp _SequenceSize> +using make_integer_sequence _LIBCPP_NODEBUG = integer_sequence<_Tp, __integer_pack(_SequenceSize)...>; + +# else +# error "No known way to get an integer pack from the compiler" +# endif + +template <size_t _Np> +using make_index_sequence = make_integer_sequence<size_t, _Np>; + +template <class... _Tp> +using index_sequence_for = make_index_sequence<sizeof...(_Tp)>; + +# if _LIBCPP_STD_VER >= 20 +// Executes __func for every element in an index_sequence. +template <size_t... _Index, class _Function> +_LIBCPP_HIDE_FROM_ABI constexpr void __for_each_index_sequence(index_sequence<_Index...>, _Function __func) { + (__func.template operator()<_Index>(), ...); +} +# endif // _LIBCPP_STD_VER >= 20 + +#endif // _LIBCPP_STD_VER >= 14 + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_INTEGER_SEQUENCE_H diff --git a/contrib/llvm-project/libcxx/include/__utility/is_pointer_in_range.h b/contrib/llvm-project/libcxx/include/__utility/is_pointer_in_range.h new file mode 100644 index 000000000000..4130b4ac7070 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/is_pointer_in_range.h @@ -0,0 +1,62 @@ +//===----------------------------------------------------------------------===// +// +// 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_IS_POINTER_IN_RANGE_H +#define _LIBCPP___UTILITY_IS_POINTER_IN_RANGE_H + +#include <__algorithm/comp.h> +#include <__assert> +#include <__config> +#include <__type_traits/enable_if.h> +#include <__type_traits/integral_constant.h> +#include <__type_traits/is_constant_evaluated.h> +#include <__type_traits/void_t.h> +#include <__utility/declval.h> +#include <__utility/is_valid_range.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Tp, class _Up, class = void> +struct __is_less_than_comparable : false_type {}; + +template <class _Tp, class _Up> +struct __is_less_than_comparable<_Tp, _Up, __void_t<decltype(std::declval<_Tp>() < std::declval<_Up>())> > : true_type { +}; + +template <class _Tp, class _Up, __enable_if_t<__is_less_than_comparable<const _Tp*, const _Up*>::value, int> = 0> +_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") bool +__is_pointer_in_range(const _Tp* __begin, const _Tp* __end, const _Up* __ptr) { + _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__begin, __end), "[__begin, __end) is not a valid range"); + + if (__libcpp_is_constant_evaluated()) { + // If this is not a constant during constant evaluation we know that __ptr is not part of the allocation where + // [__begin, __end) is. + if (!__builtin_constant_p(__begin <= __ptr && __ptr < __end)) + return false; + } + + return !__less<>()(__ptr, __begin) && __less<>()(__ptr, __end); +} + +template <class _Tp, class _Up, __enable_if_t<!__is_less_than_comparable<const _Tp*, const _Up*>::value, int> = 0> +_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") bool +__is_pointer_in_range(const _Tp* __begin, const _Tp* __end, const _Up* __ptr) { + if (__libcpp_is_constant_evaluated()) + return false; + + return reinterpret_cast<const char*>(__begin) <= reinterpret_cast<const char*>(__ptr) && + reinterpret_cast<const char*>(__ptr) < reinterpret_cast<const char*>(__end); +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_IS_POINTER_IN_RANGE_H diff --git a/contrib/llvm-project/libcxx/include/__utility/is_valid_range.h b/contrib/llvm-project/libcxx/include/__utility/is_valid_range.h new file mode 100644 index 000000000000..7286662dbf30 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/is_valid_range.h @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// 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_IS_VALID_RANGE_H +#define _LIBCPP___UTILITY_IS_VALID_RANGE_H + +#include <__algorithm/comp.h> +#include <__config> +#include <__type_traits/is_constant_evaluated.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Tp> +_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") bool +__is_valid_range(const _Tp* __first, const _Tp* __last) { + if (__libcpp_is_constant_evaluated()) { + // If this is not a constant during constant evaluation, that is because __first and __last are not + // part of the same allocation. If they are part of the same allocation, we must still make sure they + // are ordered properly. + return __builtin_constant_p(__first <= __last) && __first <= __last; + } + + return !__less<>()(__last, __first); +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_IS_VALID_RANGE_H diff --git a/contrib/llvm-project/libcxx/include/__utility/move.h b/contrib/llvm-project/libcxx/include/__utility/move.h new file mode 100644 index 000000000000..b6a42db0545e --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/move.h @@ -0,0 +1,49 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// 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_MOVE_H +#define _LIBCPP___UTILITY_MOVE_H + +#include <__config> +#include <__type_traits/conditional.h> +#include <__type_traits/is_constructible.h> +#include <__type_traits/is_nothrow_constructible.h> +#include <__type_traits/remove_reference.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Tp> +_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __libcpp_remove_reference_t<_Tp>&& +move(_LIBCPP_LIFETIMEBOUND _Tp&& __t) _NOEXCEPT { + typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up; + return static_cast<_Up&&>(__t); +} + +template <class _Tp> +using __move_if_noexcept_result_t = + __conditional_t<!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&, _Tp&&>; + +template <class _Tp> +_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __move_if_noexcept_result_t<_Tp> +move_if_noexcept(_LIBCPP_LIFETIMEBOUND _Tp& __x) _NOEXCEPT { + return std::move(__x); +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___UTILITY_MOVE_H diff --git a/contrib/llvm-project/libcxx/include/__utility/no_destroy.h b/contrib/llvm-project/libcxx/include/__utility/no_destroy.h new file mode 100644 index 000000000000..8edd194577d7 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/no_destroy.h @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// 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_NO_DESTROY_H +#define _LIBCPP___UTILITY_NO_DESTROY_H + +#include <__config> +#include <__type_traits/is_constant_evaluated.h> +#include <__utility/forward.h> +#include <new> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +struct __uninitialized_tag {}; + +// This class stores an object of type _Tp but never destroys it. +// +// This is akin to using __attribute__((no_destroy)), except that it is possible +// to control the lifetime of the object with more flexibility by deciding e.g. +// whether to initialize the object at construction or to defer to a later +// initialization using __emplace. +template <class _Tp> +struct __no_destroy { + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __no_destroy(__uninitialized_tag) : __obj_() {} + + template <class... _Args> + _LIBCPP_HIDE_FROM_ABI explicit __no_destroy(_Args&&... __args) { + ::new ((void*)__obj_) _Tp(std::forward<_Args>(__args)...); + } + + template <class... _Args> + _LIBCPP_HIDE_FROM_ABI _Tp& __emplace(_Args&&... __args) { + return *(::new ((void*)__obj_) _Tp(std::forward<_Args>(__args)...)); + } + + _LIBCPP_HIDE_FROM_ABI _Tp& __get() { return *reinterpret_cast<_Tp*>(__obj_); } + _LIBCPP_HIDE_FROM_ABI _Tp const& __get() const { return *reinterpret_cast<const _Tp*>(__obj_); } + +private: + _ALIGNAS_TYPE(_Tp) char __obj_[sizeof(_Tp)]; +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_NO_DESTROY_H diff --git a/contrib/llvm-project/libcxx/include/__utility/pair.h b/contrib/llvm-project/libcxx/include/__utility/pair.h new file mode 100644 index 000000000000..c0002b7abb3c --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/pair.h @@ -0,0 +1,718 @@ +//===----------------------------------------------------------------------===// +// +// 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/pair.h> +#include <__fwd/tuple.h> +#include <__tuple/sfinae_helpers.h> +#include <__tuple/tuple_element.h> +#include <__tuple/tuple_indices.h> +#include <__tuple/tuple_like_no_subrange.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_implicitly_default_constructible.h> +#include <__type_traits/is_nothrow_assignable.h> +#include <__type_traits/is_nothrow_constructible.h> +#include <__type_traits/is_reference.h> +#include <__type_traits/is_same.h> +#include <__type_traits/is_swappable.h> +#include <__type_traits/is_trivially_relocatable.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_PUSH_MACROS +#include <__undef_macros> + +_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 {} +}; + +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; + + using __trivially_relocatable = + __conditional_t<__libcpp_is_trivially_relocatable<_T1>::value && __libcpp_is_trivially_relocatable<_T2>::value, + pair, + void>; + + _LIBCPP_HIDE_FROM_ABI pair(pair const&) = default; + _LIBCPP_HIDE_FROM_ABI pair(pair&&) = default; + + // When we are requested for pair to be trivially copyable by the ABI macro, we use defaulted members + // if it is both legal to do it (i.e. no references) and we have a way to actually implement it, which requires + // the __enable_if__ attribute before C++20. +#ifdef _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR + // FIXME: This should really just be a static constexpr variable. It's in a struct to avoid gdb printing the value + // when printing a pair + struct __has_defaulted_members { + static const bool value = !is_reference<first_type>::value && !is_reference<second_type>::value; + }; +# if _LIBCPP_STD_VER >= 20 + _LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(const pair&) + requires __has_defaulted_members::value + = default; + + _LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(pair&&) + requires __has_defaulted_members::value + = default; +# elif __has_attribute(__enable_if__) + _LIBCPP_HIDE_FROM_ABI pair& operator=(const pair&) + __attribute__((__enable_if__(__has_defaulted_members::value, ""))) = default; + + _LIBCPP_HIDE_FROM_ABI pair& operator=(pair&&) + __attribute__((__enable_if__(__has_defaulted_members::value, ""))) = default; +# else +# error "_LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR isn't supported with this compiler" +# endif +#else + struct __has_defaulted_members { + static const bool value = false; + }; +#endif // defined(_LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR) && __has_attribute(__enable_if__) + +#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, + __enable_if_t<is_assignable<first_type&, _U1 const&>::value && is_assignable<second_type&, _U2 const&>::value, + int> = 0> + _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_implicit_default() { + return __is_implicitly_default_constructible<_T1>::value && __is_implicitly_default_constructible<_T2>::value; + } + + template <int&...> + static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_default() { + return is_default_constructible<_T1>::value && is_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 <bool _MaybeEnable> + using _CheckArgsDep _LIBCPP_NODEBUG = + typename conditional< _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type; + + template <bool _Dummy = true, __enable_if_t<_CheckArgsDep<_Dummy>::__enable_default(), int> = 0> + explicit(!_CheckArgsDep<_Dummy>::__enable_implicit_default()) _LIBCPP_HIDE_FROM_ABI constexpr pair() noexcept( + is_nothrow_default_constructible<first_type>::value && is_nothrow_default_constructible<second_type>::value) + : first(), second() {} + + template <bool _Dummy = true, + __enable_if_t<_CheckArgsDep<_Dummy>::template __is_pair_constructible<_T1 const&, _T2 const&>(), int> = 0> + _LIBCPP_HIDE_FROM_ABI + _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!_CheckArgsDep<_Dummy>::template __is_implicit<_T1 const&, _T2 const&>()) + 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 + __enable_if_t<_CheckArgs::template __is_pair_constructible<_U1, _U2>(), int> = 0 > + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!_CheckArgs::template __is_implicit<_U1, _U2>()) + 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&>(), int> = 0> + _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, + __enable_if_t<_CheckArgs::template __is_pair_constructible<_U1 const&, _U2 const&>(), int> = 0> + _LIBCPP_HIDE_FROM_ABI + _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!_CheckArgs::template __is_implicit<_U1 const&, _U2 const&>()) + 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, __enable_if_t<_CheckArgs::template __is_pair_constructible<_U1, _U2>(), int> = 0> + _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 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(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&&>(), int> = 0> + _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 + // TODO: Remove this workaround in LLVM 20. The bug got fixed in Clang 18. + // This is a workaround for http://llvm.org/PR60710. We should be able to remove it once Clang is fixed. + template <class _PairLike> + _LIBCPP_HIDE_FROM_ABI static constexpr bool __pair_like_explicit_wknd() { + if constexpr (__pair_like_no_subrange<_PairLike>) { + 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_no_subrange _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<!__has_defaulted_members::value && 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<!__has_defaulted_members::value && 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, + int> = 0> + _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, int> = 0> + _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 + template <class = void> + _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; + } + + template <class = void> + _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_no_subrange _PairLike> + requires(__different_from<_PairLike, pair> && + 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_no_subrange _PairLike> + requires(__different_from<_PairLike, pair> && + 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, int> = 0> + _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), + int> = 0> + _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, int> = 0> + _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) > = 0> + _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, int> = 0> + _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, int> = 0> + _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, int> = 0> + _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), + int> = 0> + _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, int> = 0> + _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), + int> = 0> + _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, int> = 0> + _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, int> = 0> + _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_v<first_type>&& __is_nothrow_swappable_v<second_type>) { + 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_v<const first_type> && __is_nothrow_swappable_v<const second_type>) { + 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...>) + : first(std::forward<_Args1>(std::get<_I1>(__first_args))...), + second(std::forward<_Args2>(std::get<_I2>(__second_args))...) {} +#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, __enable_if_t<__is_swappable_v<_T1> && __is_swappable_v<_T2>, int> = 0> +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + _NOEXCEPT_(__is_nothrow_swappable_v<_T1>&& __is_nothrow_swappable_v<_T2>) { + __x.swap(__y); +} + +#if _LIBCPP_STD_VER >= 23 +template <class _T1, class _T2> + requires(__is_swappable_v<const _T1> && __is_swappable_v<const _T2>) +_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 + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___UTILITY_PAIR_H diff --git a/contrib/llvm-project/libcxx/include/__utility/piecewise_construct.h b/contrib/llvm-project/libcxx/include/__utility/piecewise_construct.h new file mode 100644 index 000000000000..52b19d791e10 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/piecewise_construct.h @@ -0,0 +1,32 @@ +//===----------------------------------------------------------------------===// +// +// 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_PIECEWISE_CONSTRUCT_H +#define _LIBCPP___UTILITY_PIECEWISE_CONSTRUCT_H + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { + explicit piecewise_construct_t() = default; +}; + +#if _LIBCPP_STD_VER >= 17 +inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); +#elif !defined(_LIBCPP_CXX03_LANG) +constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); +#endif + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_PIECEWISE_CONSTRUCT_H diff --git a/contrib/llvm-project/libcxx/include/__utility/priority_tag.h b/contrib/llvm-project/libcxx/include/__utility/priority_tag.h new file mode 100644 index 000000000000..a159ce7f1afb --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/priority_tag.h @@ -0,0 +1,28 @@ +//===----------------------------------------------------------------------===// +// +// 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_PRIORITY_TAG_H +#define _LIBCPP___UTILITY_PRIORITY_TAG_H + +#include <__config> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <size_t _Ip> +struct __priority_tag : __priority_tag<_Ip - 1> {}; +template <> +struct __priority_tag<0> {}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_PRIORITY_TAG_H diff --git a/contrib/llvm-project/libcxx/include/__utility/private_constructor_tag.h b/contrib/llvm-project/libcxx/include/__utility/private_constructor_tag.h new file mode 100644 index 000000000000..462cab48c9ed --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/private_constructor_tag.h @@ -0,0 +1,28 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// 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_PRIVATE_CONSTRUCTOR_TAG_H +#define _LIBCPP__UTILITY_PRIVATE_CONSTRUCTOR_TAG_H + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +// This tag allows defining non-standard exposition-only constructors while +// preventing users from being able to use them, since this reserved-name tag +// needs to be used. +struct __private_constructor_tag {}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP__UTILITY_PRIVATE_CONSTRUCTOR_TAG_H diff --git a/contrib/llvm-project/libcxx/include/__utility/rel_ops.h b/contrib/llvm-project/libcxx/include/__utility/rel_ops.h new file mode 100644 index 000000000000..a8caf5bdeaf2 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/rel_ops.h @@ -0,0 +1,46 @@ +//===----------------------------------------------------------------------===// +// +// 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_REL_OPS_H +#define _LIBCPP___UTILITY_REL_OPS_H + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +namespace rel_ops { + +template <class _Tp> +inline _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI bool operator!=(const _Tp& __x, const _Tp& __y) { + return !(__x == __y); +} + +template <class _Tp> +inline _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI bool operator>(const _Tp& __x, const _Tp& __y) { + return __y < __x; +} + +template <class _Tp> +inline _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI bool operator<=(const _Tp& __x, const _Tp& __y) { + return !(__y < __x); +} + +template <class _Tp> +inline _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI bool operator>=(const _Tp& __x, const _Tp& __y) { + return !(__x < __y); +} + +} // namespace rel_ops + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_REL_OPS_H diff --git a/contrib/llvm-project/libcxx/include/__utility/small_buffer.h b/contrib/llvm-project/libcxx/include/__utility/small_buffer.h new file mode 100644 index 000000000000..9e13797573d2 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/small_buffer.h @@ -0,0 +1,99 @@ +//===----------------------------------------------------------------------===// +// +// 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_SMALL_BUFFER_H +#define _LIBCPP___UTILITY_SMALL_BUFFER_H + +#include <__config> +#include <__memory/construct_at.h> +#include <__type_traits/decay.h> +#include <__type_traits/is_trivially_constructible.h> +#include <__type_traits/is_trivially_destructible.h> +#include <__utility/exception_guard.h> +#include <__utility/forward.h> +#include <cstddef> +#include <new> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +#if _LIBCPP_STD_VER >= 23 + +// __small_buffer is a helper class to perform the well known SBO (small buffer optimization). It is mainly useful to +// allow type-erasing classes like move_only_function to store small objects in a local buffer without requiring an +// allocation. +// +// This small buffer class only allows storing trivially relocatable objects inside the local storage to allow +// __small_buffer to be trivially relocatable itself. Since the buffer doesn't know what's stored inside it, the user +// has to manage the object's lifetime, in particular the destruction of the object. + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <size_t _BufferSize, size_t _BufferAlignment> + requires(_BufferSize > 0 && _BufferAlignment > 0) +class __small_buffer { +public: + template <class _Tp, class _Decayed = decay_t<_Tp>> + static constexpr bool __fits_in_buffer = + is_trivially_move_constructible_v<_Decayed> && is_trivially_destructible_v<_Decayed> && + sizeof(_Decayed) <= _BufferSize && alignof(_Decayed) <= _BufferAlignment; + + _LIBCPP_HIDE_FROM_ABI __small_buffer() = default; + __small_buffer(const __small_buffer&) = delete; + __small_buffer& operator=(const __small_buffer&) = delete; + _LIBCPP_HIDE_FROM_ABI ~__small_buffer() = default; + + // Relocates the buffer - __delete() should never be called on a moved-from __small_buffer + _LIBCPP_HIDE_FROM_ABI __small_buffer(__small_buffer&&) = default; + _LIBCPP_HIDE_FROM_ABI __small_buffer& operator=(__small_buffer&&) = default; + + template <class _Stored> + _LIBCPP_HIDE_FROM_ABI _Stored* __get() { + if constexpr (__fits_in_buffer<_Stored>) + return std::launder(reinterpret_cast<_Stored*>(__buffer_)); + else + return *std::launder(reinterpret_cast<_Stored**>(__buffer_)); + } + + template <class _Stored> + _LIBCPP_HIDE_FROM_ABI _Stored* __alloc() { + if constexpr (__fits_in_buffer<_Stored>) { + return std::launder(reinterpret_cast<_Stored*>(__buffer_)); + } else { + byte* __allocation = static_cast<byte*>(::operator new[](sizeof(_Stored), align_val_t{alignof(_Stored)})); + std::construct_at(reinterpret_cast<byte**>(__buffer_), __allocation); + return std::launder(reinterpret_cast<_Stored*>(__allocation)); + } + } + + template <class _Stored> + _LIBCPP_HIDE_FROM_ABI void __dealloc() noexcept { + if constexpr (!__fits_in_buffer<_Stored>) + ::operator delete[](*reinterpret_cast<void**>(__buffer_), sizeof(_Stored), align_val_t{alignof(_Stored)}); + } + + template <class _Stored, class... _Args> + _LIBCPP_HIDE_FROM_ABI void __construct(_Args&&... __args) { + _Stored* __buffer = __alloc<_Stored>(); + auto __guard = std::__make_exception_guard([&] { __dealloc<_Stored>(); }); + std::construct_at(__buffer, std::forward<_Args>(__args)...); + __guard.__complete(); + } + +private: + alignas(_BufferAlignment) byte __buffer_[_BufferSize]; +}; + +# undef _LIBCPP_SMALL_BUFFER_TRIVIAL_ABI + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STD_VER >= 23 + +#endif // _LIBCPP___UTILITY_SMALL_BUFFER_H diff --git a/contrib/llvm-project/libcxx/include/__utility/swap.h b/contrib/llvm-project/libcxx/include/__utility/swap.h new file mode 100644 index 000000000000..ab88b8e0a0b5 --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/swap.h @@ -0,0 +1,59 @@ +//===----------------------------------------------------------------------===// +// +// 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_SWAP_H +#define _LIBCPP___UTILITY_SWAP_H + +#include <__config> +#include <__type_traits/is_assignable.h> +#include <__type_traits/is_constructible.h> +#include <__type_traits/is_nothrow_assignable.h> +#include <__type_traits/is_nothrow_constructible.h> +#include <__type_traits/is_swappable.h> +#include <__utility/declval.h> +#include <__utility/move.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +#ifndef _LIBCPP_CXX03_LANG +template <class _Tp> +using __swap_result_t = __enable_if_t<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>; +#else +template <class> +using __swap_result_t = void; +#endif + +template <class _Tp> +inline _LIBCPP_HIDE_FROM_ABI __swap_result_t<_Tp> _LIBCPP_CONSTEXPR_SINCE_CXX20 swap(_Tp& __x, _Tp& __y) + _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value&& is_nothrow_move_assignable<_Tp>::value) { + _Tp __t(std::move(__x)); + __x = std::move(__y); + __y = std::move(__t); +} + +template <class _Tp, size_t _Np, __enable_if_t<__is_swappable_v<_Tp>, int> > +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) + _NOEXCEPT_(__is_nothrow_swappable_v<_Tp>) { + for (size_t __i = 0; __i != _Np; ++__i) { + swap(__a[__i], __b[__i]); + } +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___UTILITY_SWAP_H diff --git a/contrib/llvm-project/libcxx/include/__utility/to_underlying.h b/contrib/llvm-project/libcxx/include/__utility/to_underlying.h new file mode 100644 index 000000000000..77587108f20d --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/to_underlying.h @@ -0,0 +1,38 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// 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_TO_UNDERLYING_H +#define _LIBCPP___UTILITY_TO_UNDERLYING_H + +#include <__config> +#include <__type_traits/underlying_type.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#ifndef _LIBCPP_CXX03_LANG +template <class _Tp> +_LIBCPP_HIDE_FROM_ABI constexpr typename underlying_type<_Tp>::type __to_underlying(_Tp __val) noexcept { + return static_cast<typename underlying_type<_Tp>::type>(__val); +} +#endif // !_LIBCPP_CXX03_LANG + +#if _LIBCPP_STD_VER >= 23 +template <class _Tp> +[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr underlying_type_t<_Tp> to_underlying(_Tp __val) noexcept { + return std::__to_underlying(__val); +} +#endif + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_TO_UNDERLYING_H diff --git a/contrib/llvm-project/libcxx/include/__utility/unreachable.h b/contrib/llvm-project/libcxx/include/__utility/unreachable.h new file mode 100644 index 000000000000..d833f74c2e4f --- /dev/null +++ b/contrib/llvm-project/libcxx/include/__utility/unreachable.h @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// 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_UNREACHABLE_H +#define _LIBCPP___UTILITY_UNREACHABLE_H + +#include <__assert> +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __libcpp_unreachable() { + _LIBCPP_ASSERT_INTERNAL(false, "std::unreachable() was reached"); + __builtin_unreachable(); +} + +#if _LIBCPP_STD_VER >= 23 + +[[noreturn]] _LIBCPP_HIDE_FROM_ABI inline void unreachable() { __libcpp_unreachable(); } + +#endif + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___UTILITY_UNREACHABLE_H |