diff options
Diffstat (limited to 'third_party/libcxx/include/c++/v1/__utility')
30 files changed, 0 insertions, 2384 deletions
diff --git a/third_party/libcxx/include/c++/v1/__utility/as_const.h b/third_party/libcxx/include/c++/v1/__utility/as_const.h deleted file mode 100644 index 0f54b98..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/as_const.h +++ /dev/null @@ -1,32 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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> - -#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 const _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/third_party/libcxx/include/c++/v1/__utility/as_lvalue.h b/third_party/libcxx/include/c++/v1/__utility/as_lvalue.h deleted file mode 100644 index 159f45d..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/as_lvalue.h +++ /dev/null @@ -1,37 +0,0 @@ -// -*- 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/third_party/libcxx/include/c++/v1/__utility/auto_cast.h b/third_party/libcxx/include/c++/v1/__utility/auto_cast.h deleted file mode 100644 index 06715b3..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/auto_cast.h +++ /dev/null @@ -1,22 +0,0 @@ -// -*- 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/third_party/libcxx/include/c++/v1/__utility/cmp.h b/third_party/libcxx/include/c++/v1/__utility/cmp.h deleted file mode 100644 index 7cfe640..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/cmp.h +++ /dev/null @@ -1,93 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 <__config> -#include <__type_traits/integer_traits.h> -#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 <typename _Tp, typename _Ip> -concept __comparison_can_promote_to = - sizeof(_Tp) < sizeof(_Ip) || (sizeof(_Tp) == sizeof(_Ip) && __signed_integer<_Tp>); - -template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up> -[[nodiscard]] _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 (__comparison_can_promote_to<_Tp, int> && __comparison_can_promote_to<_Up, int>) - return static_cast<int>(__t) == static_cast<int>(__u); - else if constexpr (__comparison_can_promote_to<_Tp, long long> && __comparison_can_promote_to<_Up, long long>) - return static_cast<long long>(__t) == static_cast<long long>(__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 <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up> -[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept { - return !std::cmp_equal(__t, __u); -} - -template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up> -[[nodiscard]] _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 (__comparison_can_promote_to<_Tp, int> && __comparison_can_promote_to<_Up, int>) - return static_cast<int>(__t) < static_cast<int>(__u); - else if constexpr (__comparison_can_promote_to<_Tp, long long> && __comparison_can_promote_to<_Up, long long>) - return static_cast<long long>(__t) < static_cast<long long>(__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 <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up> -[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept { - return std::cmp_less(__u, __t); -} - -template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up> -[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept { - return !std::cmp_greater(__t, __u); -} - -template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up> -[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept { - return !std::cmp_less(__t, __u); -} - -template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up> -[[nodiscard]] _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/third_party/libcxx/include/c++/v1/__utility/convert_to_integral.h b/third_party/libcxx/include/c++/v1/__utility/convert_to_integral.h deleted file mode 100644 index c8149b7..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/convert_to_integral.h +++ /dev/null @@ -1,68 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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; -} - -#if _LIBCPP_HAS_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 { - using type = __underlying_type_t<_Tp>; - 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/third_party/libcxx/include/c++/v1/__utility/declval.h b/third_party/libcxx/include/c++/v1/__utility/declval.h deleted file mode 100644 index d0856b8..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/declval.h +++ /dev/null @@ -1,38 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/third_party/libcxx/include/c++/v1/__utility/default_three_way_comparator.h b/third_party/libcxx/include/c++/v1/__utility/default_three_way_comparator.h deleted file mode 100644 index 92cdce6..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/default_three_way_comparator.h +++ /dev/null @@ -1,70 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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_DEFAULT_THREE_WAY_COMPARATOR_H -#define _LIBCPP___UTILITY_DEFAULT_THREE_WAY_COMPARATOR_H - -#include <__config> -#include <__type_traits/enable_if.h> -#include <__type_traits/is_arithmetic.h> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_STD - -// This struct can be specialized to provide a three way comparator between _LHS and _RHS. -// The return value should be -// - less than zero if (lhs_val < rhs_val) -// - greater than zero if (rhs_val < lhs_val) -// - zero otherwise -template <class _LHS, class _RHS, class = void> -struct __default_three_way_comparator; - -template <class _LHS, class _RHS> -struct __default_three_way_comparator<_LHS, - _RHS, - __enable_if_t<is_arithmetic<_LHS>::value && is_arithmetic<_RHS>::value> > { - _LIBCPP_HIDE_FROM_ABI static int operator()(_LHS __lhs, _RHS __rhs) { - if (__lhs < __rhs) - return -1; - if (__lhs > __rhs) - return 1; - return 0; - } -}; - -#if _LIBCPP_STD_VER >= 20 && __has_builtin(__builtin_lt_synthesizes_from_spaceship) -template <class _LHS, class _RHS> -struct __default_three_way_comparator< - _LHS, - _RHS, - __enable_if_t<!(is_arithmetic<_LHS>::value && is_arithmetic<_RHS>::value) && - __builtin_lt_synthesizes_from_spaceship(const _LHS&, const _RHS&)>> { - _LIBCPP_HIDE_FROM_ABI static int operator()(const _LHS& __lhs, const _RHS& __rhs) { - auto __res = __lhs <=> __rhs; - if (__res < 0) - return -1; - if (__res > 0) - return 1; - return 0; - } -}; -#endif - -template <class _LHS, class _RHS, bool = true> -struct __has_default_three_way_comparator : false_type {}; - -template <class _LHS, class _RHS> -struct __has_default_three_way_comparator<_LHS, _RHS, sizeof(__default_three_way_comparator<_LHS, _RHS>) >= 0> - : true_type {}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP___UTILITY_DEFAULT_THREE_WAY_COMPARATOR_H diff --git a/third_party/libcxx/include/c++/v1/__utility/element_count.h b/third_party/libcxx/include/c++/v1/__utility/element_count.h deleted file mode 100644 index 82b05a7..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/element_count.h +++ /dev/null @@ -1,27 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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_ELEMENT_COUNT_H -#define _LIBCPP___UTILITY_ELEMENT_COUNT_H - -#include <__config> -#include <__cstddef/size_t.h> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_STD - -// Type used to encode that a function takes an integer that represents a number -// of elements as opposed to a number of bytes. -enum class __element_count : size_t {}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP___UTILITY_ELEMENT_COUNT_H diff --git a/third_party/libcxx/include/c++/v1/__utility/empty.h b/third_party/libcxx/include/c++/v1/__utility/empty.h deleted file mode 100644 index 8cca197..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/empty.h +++ /dev/null @@ -1,24 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/third_party/libcxx/include/c++/v1/__utility/exception_guard.h b/third_party/libcxx/include/c++/v1/__utility/exception_guard.h deleted file mode 100644 index 6fa744e..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/exception_guard.h +++ /dev/null @@ -1,143 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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_EXCEPTION_GUARD_H -#define _LIBCPP___UTILITY_EXCEPTION_GUARD_H - -#include <__assert> -#include <__config> -#include <__type_traits/is_nothrow_constructible.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_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_NODEBUG _LIBCPP_HIDE_FROM_ABI - _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __exception_guard_noexceptions(_Rollback) {} - - _LIBCPP_NODEBUG _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 - __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_NODEBUG _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __complete() _NOEXCEPT { - __completed_ = true; - } - - _LIBCPP_NODEBUG _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__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); - -#if !_LIBCPP_HAS_EXCEPTIONS -template <class _Rollback> -using __exception_guard _LIBCPP_NODEBUG = __exception_guard_noexceptions<_Rollback>; -#else -template <class _Rollback> -using __exception_guard _LIBCPP_NODEBUG = __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_EXCEPTION_GUARD_H diff --git a/third_party/libcxx/include/c++/v1/__utility/exchange.h b/third_party/libcxx/include/c++/v1/__utility/exchange.h deleted file mode 100644 index 957e9d0..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/exchange.h +++ /dev/null @@ -1,41 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/third_party/libcxx/include/c++/v1/__utility/forward.h b/third_party/libcxx/include/c++/v1/__utility/forward.h deleted file mode 100644 index 6674066..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/forward.h +++ /dev/null @@ -1,38 +0,0 @@ -// -*- 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> -[[__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> -[[__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/third_party/libcxx/include/c++/v1/__utility/forward_like.h b/third_party/libcxx/include/c++/v1/__utility/forward_like.h deleted file mode 100644 index 409f716..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/forward_like.h +++ /dev/null @@ -1,63 +0,0 @@ -// -*- 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_base_of.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 _LIBCPP_NODEBUG = _If<is_const_v<_Ap>, const _Bp, _Bp>; - -template <class _Ap, class _Bp> -using _OverrideRef _LIBCPP_NODEBUG = _If<is_rvalue_reference_v<_Ap>, remove_reference_t<_Bp>&&, _Bp&>; - -template <class _Ap, class _Bp> -using _ForwardLike _LIBCPP_NODEBUG = _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); -} - -// This function is used for `deducing this` cases where you want to make sure the operation is performed on the class -// itself and not on a derived class. For example -// struct S { -// template <class Self> -// void func(Self&& self) { -// // This will always call `do_something` of S instead of any class derived from S. -// std::__forward_as<Self, S>(self).do_something(); -// } -// }; -template <class _Tp, class _As, class _Up> -[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _ForwardLike<_Tp, _As> -__forward_as(_LIBCPP_LIFETIMEBOUND _Up&& __val) noexcept { - static_assert(is_base_of_v<_As, remove_reference_t<_Up>>); - return static_cast<_ForwardLike<_Tp, _As>>(__val); -} - -#endif // _LIBCPP_STD_VER >= 23 - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP___UTILITY_FORWARD_LIKE_H diff --git a/third_party/libcxx/include/c++/v1/__utility/in_place.h b/third_party/libcxx/include/c++/v1/__utility/in_place.h deleted file mode 100644 index c5bfa94..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/in_place.h +++ /dev/null @@ -1,64 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 <__cstddef/size_t.h> -#include <__type_traits/integral_constant.h> -#include <__type_traits/remove_cvref.h> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_STD - -#if _LIBCPP_STD_VER >= 17 - -struct in_place_t { - explicit in_place_t() = default; -}; -inline constexpr in_place_t in_place{}; - -template <class _Tp> -struct 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 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 _LIBCPP_NODEBUG = __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 _LIBCPP_NODEBUG = __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/third_party/libcxx/include/c++/v1/__utility/integer_sequence.h b/third_party/libcxx/include/c++/v1/__utility/integer_sequence.h deleted file mode 100644 index a84f572..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/integer_sequence.h +++ /dev/null @@ -1,105 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 <__cstddef/size_t.h> -#include <__tuple/tuple_element.h> -#include <__tuple/tuple_size.h> -#include <__type_traits/is_integral.h> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -#ifndef _LIBCPP_CXX03_LANG - -_LIBCPP_BEGIN_NAMESPACE_STD - -# if __has_builtin(__make_integer_seq) -template <template <class _Tp, _Tp...> class _BaseType, class _Tp, _Tp _SequenceSize> -using __make_integer_sequence_impl _LIBCPP_NODEBUG = __make_integer_seq<_BaseType, _Tp, _SequenceSize>; -# else -template <template <class _Tp, _Tp...> class _BaseType, class _Tp, _Tp _SequenceSize> -using __make_integer_sequence_impl _LIBCPP_NODEBUG = _BaseType<_Tp, __integer_pack(_SequenceSize)...>; -# endif - -template <class _Tp, _Tp... _Indices> -struct __integer_sequence { - using value_type = _Tp; - static_assert(is_integral<_Tp>::value, "std::integer_sequence can only be instantiated with an integral type"); - [[__nodiscard__]] static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return sizeof...(_Indices); } -}; - -template <size_t... _Indices> -using __index_sequence _LIBCPP_NODEBUG = __integer_sequence<size_t, _Indices...>; - -template <size_t _SequenceSize> -using __make_index_sequence _LIBCPP_NODEBUG = __make_integer_sequence_impl<__integer_sequence, size_t, _SequenceSize>; - -template <class... _Args> -using __index_sequence_for _LIBCPP_NODEBUG = __make_index_sequence<sizeof...(_Args)>; - -# if _LIBCPP_STD_VER >= 14 - -template <class _Tp, _Tp... _Indices> -struct integer_sequence : __integer_sequence<_Tp, _Indices...> {}; - -template <size_t... _Ip> -using index_sequence = integer_sequence<size_t, _Ip...>; - -template <class _Tp, _Tp _Ep> -using make_integer_sequence _LIBCPP_NODEBUG = __make_integer_sequence_impl<integer_sequence, _Tp, _Ep>; - -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 - -# if _LIBCPP_STD_VER >= 26 -// [intseq.binding], structured binding support -template <class _Tp, _Tp... _Indices> -struct tuple_size<integer_sequence<_Tp, _Indices...>> : integral_constant<size_t, sizeof...(_Indices)> {}; - -template <size_t _Ip, class _Tp, _Tp... _Indices> -struct tuple_element<_Ip, integer_sequence<_Tp, _Indices...>> { - static_assert(_Ip < sizeof...(_Indices), "Index out of bounds in std::tuple_element<> (std::integer_sequence)"); - using type _LIBCPP_NODEBUG = _Tp; -}; - -template <size_t _Ip, class _Tp, _Tp... _Indices> -struct tuple_element<_Ip, const integer_sequence<_Tp, _Indices...>> { - static_assert(_Ip < sizeof...(_Indices), "Index out of bounds in std::tuple_element<> (const std::integer_sequence)"); - using type _LIBCPP_NODEBUG = _Tp; -}; - -template <size_t _Ip, class _Tp, _Tp... _Indices> -[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp get(integer_sequence<_Tp, _Indices...>) noexcept { - static_assert(_Ip < sizeof...(_Indices), "Index out of bounds in std::get<> (std::integer_sequence)"); - return _Indices...[_Ip]; -} -# endif // _LIBCPP_STD_VER >= 26 - -# endif // _LIBCPP_STD_VER >= 14 - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP_CXX03_LANG - -#endif // _LIBCPP___UTILITY_INTEGER_SEQUENCE_H diff --git a/third_party/libcxx/include/c++/v1/__utility/is_pointer_in_range.h b/third_party/libcxx/include/c++/v1/__utility/is_pointer_in_range.h deleted file mode 100644 index 8e1b86b..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/is_pointer_in_range.h +++ /dev/null @@ -1,70 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 <__memory/valid_range.h> -#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> - -#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); -} - -template <class _Tp, class _Up> -_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool -__is_overlapping_range(const _Tp* __begin, const _Tp* __end, const _Up* __begin2) { - auto __size = __end - __begin; - auto __end2 = __begin2 + __size; - return std::__is_pointer_in_range(__begin, __end, __begin2) || std::__is_pointer_in_range(__begin2, __end2, __begin); -} - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP___UTILITY_IS_POINTER_IN_RANGE_H diff --git a/third_party/libcxx/include/c++/v1/__utility/lazy_synth_three_way_comparator.h b/third_party/libcxx/include/c++/v1/__utility/lazy_synth_three_way_comparator.h deleted file mode 100644 index 906166b..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/lazy_synth_three_way_comparator.h +++ /dev/null @@ -1,120 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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_LAZY_SYNTH_THREE_WAY_COMPARATOR_H -#define _LIBCPP___UTILITY_LAZY_SYNTH_THREE_WAY_COMPARATOR_H - -#include <__assert> -#include <__config> -#include <__type_traits/conjunction.h> -#include <__type_traits/desugars_to.h> -#include <__type_traits/enable_if.h> -#include <__utility/default_three_way_comparator.h> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -// This file implements a __lazy_synth_three_way_comparator, which tries to build an efficient three way comparison from -// a binary comparator. That is done in multiple steps: -// 1) Check whether the comparator desugars to a less-than operator -// If that is the case, check whether there exists a specialization of `__default_three_way_comparator`, which -// can be specialized to implement a three way comparator for the specific types. -// 2) Fall back to doing a lazy less than/greater than comparison - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _Comparator, class _LHS, class _RHS> -struct __lazy_compare_result { - const _Comparator& __comp_; - const _LHS& __lhs_; - const _RHS& __rhs_; - - _LIBCPP_HIDE_FROM_ABI - __lazy_compare_result(_LIBCPP_CTOR_LIFETIMEBOUND const _Comparator& __comp, - _LIBCPP_CTOR_LIFETIMEBOUND const _LHS& __lhs, - _LIBCPP_CTOR_LIFETIMEBOUND const _RHS& __rhs) - : __comp_(__comp), __lhs_(__lhs), __rhs_(__rhs) {} - - _LIBCPP_HIDE_FROM_ABI bool __less() const { - bool __result = __comp_(__lhs_, __rhs_); - _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(__result ? !static_cast<bool>(__comp_(__rhs_, __lhs_)) : true, - "Comparator does not induce a strict weak ordering"); - return __result; - } - - _LIBCPP_HIDE_FROM_ABI bool __greater() const { - bool __result = __comp_(__rhs_, __lhs_); - _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(__result ? !static_cast<bool>(__comp_(__lhs_, __rhs_)) : true, - "Comparator does not induce a strict weak ordering"); - return __result; - } -}; - -// This class provides three way comparison between _LHS and _RHS as efficiently as possible. This can be specialized if -// a comparator only compares part of the object, potentially allowing an efficient three way comparison between the -// subobjects. The specialization should use the __lazy_synth_three_way_comparator for the subobjects to achieve this. -template <class _Comparator, class _LHS, class _RHS, class = void> -struct __lazy_synth_three_way_comparator { - const _Comparator& __comp_; - - _LIBCPP_HIDE_FROM_ABI __lazy_synth_three_way_comparator(_LIBCPP_CTOR_LIFETIMEBOUND const _Comparator& __comp) - : __comp_(__comp) {} - - _LIBCPP_HIDE_FROM_ABI __lazy_compare_result<_Comparator, _LHS, _RHS> - operator()(_LIBCPP_LIFETIMEBOUND const _LHS& __lhs, _LIBCPP_LIFETIMEBOUND const _RHS& __rhs) const { - return __lazy_compare_result<_Comparator, _LHS, _RHS>(__comp_, __lhs, __rhs); - } -}; - -struct __eager_compare_result { - int __res_; - - _LIBCPP_HIDE_FROM_ABI explicit __eager_compare_result(int __res) : __res_(__res) {} - - _LIBCPP_HIDE_FROM_ABI bool __less() const { return __res_ < 0; } - _LIBCPP_HIDE_FROM_ABI bool __greater() const { return __res_ > 0; } -}; - -template <class _Comparator, class _LHS, class _RHS> -struct __lazy_synth_three_way_comparator<_Comparator, - _LHS, - _RHS, - __enable_if_t<_And<__desugars_to<__less_tag, _Comparator, _LHS, _RHS>, - __has_default_three_way_comparator<_LHS, _RHS> >::value> > { - // This lifetimebound annotation is technically incorrect, but other specializations actually capture the lifetime of - // the comparator. - _LIBCPP_HIDE_FROM_ABI __lazy_synth_three_way_comparator(_LIBCPP_CTOR_LIFETIMEBOUND const _Comparator&) {} - - // Same comment as above. - _LIBCPP_HIDE_FROM_ABI static __eager_compare_result - operator()(_LIBCPP_LIFETIMEBOUND const _LHS& __lhs, _LIBCPP_LIFETIMEBOUND const _RHS& __rhs) { - return __eager_compare_result(__default_three_way_comparator<_LHS, _RHS>()(__lhs, __rhs)); - } -}; - -template <class _Comparator, class _LHS, class _RHS> -struct __lazy_synth_three_way_comparator<_Comparator, - _LHS, - _RHS, - __enable_if_t<_And<__desugars_to<__greater_tag, _Comparator, _LHS, _RHS>, - __has_default_three_way_comparator<_LHS, _RHS> >::value> > { - // This lifetimebound annotation is technically incorrect, but other specializations actually capture the lifetime of - // the comparator. - _LIBCPP_HIDE_FROM_ABI __lazy_synth_three_way_comparator(_LIBCPP_CTOR_LIFETIMEBOUND const _Comparator&) {} - - // Same comment as above. - _LIBCPP_HIDE_FROM_ABI static __eager_compare_result - operator()(_LIBCPP_LIFETIMEBOUND const _LHS& __lhs, _LIBCPP_LIFETIMEBOUND const _RHS& __rhs) { - return __eager_compare_result(-__default_three_way_comparator<_LHS, _RHS>()(__lhs, __rhs)); - } -}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP___UTILITY_LAZY_SYNTH_THREE_WAY_COMPARATOR_H diff --git a/third_party/libcxx/include/c++/v1/__utility/move.h b/third_party/libcxx/include/c++/v1/__utility/move.h deleted file mode 100644 index bc16697..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/move.h +++ /dev/null @@ -1,49 +0,0 @@ -// -*- 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> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __libcpp_remove_reference_t<_Tp>&& -move(_LIBCPP_LIFETIMEBOUND _Tp&& __t) _NOEXCEPT { - using _Up _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tp>; - return static_cast<_Up&&>(__t); -} - -template <class _Tp> -using __move_if_noexcept_result_t _LIBCPP_NODEBUG = - __conditional_t<!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&, _Tp&&>; - -template <class _Tp> -[[__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/third_party/libcxx/include/c++/v1/__utility/no_destroy.h b/third_party/libcxx/include/c++/v1/__utility/no_destroy.h deleted file mode 100644 index e1eccb3..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/no_destroy.h +++ /dev/null @@ -1,53 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 <__new/placement_new_delete.h> -#include <__utility/forward.h> - -#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/third_party/libcxx/include/c++/v1/__utility/pair.h b/third_party/libcxx/include/c++/v1/__utility/pair.h deleted file mode 100644 index a8232bc..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/pair.h +++ /dev/null @@ -1,689 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/boolean_testable.h> -#include <__concepts/different_from.h> -#include <__config> -#include <__cstddef/size_t.h> -#include <__fwd/array.h> -#include <__fwd/pair.h> -#include <__fwd/tuple.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/enable_if.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_swappable.h> -#include <__type_traits/is_trivially_relocatable.h> -#include <__type_traits/nat.h> -#include <__type_traits/unwrap_ref.h> -#include <__utility/declval.h> -#include <__utility/forward.h> -#include <__utility/integer_sequence.h> -#include <__utility/move.h> -#include <__utility/piecewise_construct.h> - -#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 _T1, class _T2> -struct __check_pair_construction { - 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<_T1, _U1>::value && is_constructible<_T2, _U2>::value; - } - - template <class _U1, class _U2> - static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_implicit() { - return is_convertible<_U1, _T1>::value && is_convertible<_U2, _T2>::value; - } -}; - -#endif - -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 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 _LIBCPP_NODEBUG = - __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; - -#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 - template <class _CheckArgsDep = __check_pair_construction<_T1, _T2>, - __enable_if_t<_CheckArgsDep::__enable_default(), int> = 0> - explicit(!_CheckArgsDep::__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 <class _CheckArgsDep = __check_pair_construction<_T1, _T2>, - __enable_if_t<_CheckArgsDep::template __is_pair_constructible<_T1 const&, _T2 const&>(), int> = 0> - _LIBCPP_HIDE_FROM_ABI - _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!_CheckArgsDep::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<__check_pair_construction<_T1, _T2>::template __is_pair_constructible<_U1, _U2>(), int> = 0 > - _LIBCPP_HIDE_FROM_ABI - _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!__check_pair_construction<_T1, _T2>::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<__check_pair_construction<_T1, _T2>::template __is_pair_constructible<_U1&, _U2&>(), int> = 0> - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!__check_pair_construction<_T1, _T2>::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<__check_pair_construction<_T1, _T2>::template __is_pair_constructible<_U1 const&, _U2 const&>(), - int> = 0> - _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit( - !__check_pair_construction<_T1, _T2>::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<__check_pair_construction<_T1, _T2>::template __is_pair_constructible<_U1, _U2>(), int> = 0> - _LIBCPP_HIDE_FROM_ABI - _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!__check_pair_construction<_T1, _T2>::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<__check_pair_construction<_T1, _T2>::template __is_pair_constructible<const _U1&&, const _U2&&>(), - int> = 0> - _LIBCPP_HIDE_FROM_ABI constexpr explicit( - !__check_pair_construction<_T1, _T2>::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 - 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( - !is_convertible_v<decltype(std::get<0>(std::declval<_PairLike&&>())), first_type> || - !is_convertible_v<decltype(std::get<1>(std::declval<_PairLike&&>())), second_type>) 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, __index_sequence_for<_Args1...>(), __index_sequence_for<_Args2...>()) {} - - _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& - operator=(__conditional_t<is_copy_assignable<first_type>::value && is_copy_assignable<second_type>::value, - pair, - __nat> const& __p) noexcept(is_nothrow_copy_assignable<first_type>::value && - is_nothrow_copy_assignable<second_type>::value) { - first = __p.first; - second = __p.second; - return *this; - } - - _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& operator=( - __conditional_t<is_move_assignable<first_type>::value && is_move_assignable<second_type>::value, pair, __nat>&& - __p) noexcept(is_nothrow_move_assignable<first_type>::value && - is_nothrow_move_assignable<second_type>::value) { - first = std::forward<first_type>(__p.first); - second = std::forward<second_type>(__p.second); - return *this; - } - - template < - class _U1, - class _U2, - __enable_if_t<is_assignable<first_type&, _U1 const&>::value && is_assignable<second_type&, _U2 const&>::value, - 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, - __index_sequence<_I1...>, - __index_sequence<_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) -#if _LIBCPP_STD_VER >= 26 - requires requires { - { __x.first == __y.first } -> __boolean_testable; - { __x.second == __y.second } -> __boolean_testable; - } -#endif -{ - 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 _LIBCPP_NODEBUG = - 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 _LIBCPP_NODEBUG = 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> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 -pair<__unwrap_ref_decay_t<_T1>, __unwrap_ref_decay_t<_T2> > make_pair(_T1&& __t1, _T2&& __t2) { - return pair<__unwrap_ref_decay_t<_T1>, __unwrap_ref_decay_t<_T2> >(std::forward<_T1>(__t1), std::forward<_T2>(__t2)); -} - -template <class _T1, class _T2> -struct tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {}; - -template <size_t _Ip, class _T1, class _T2> -struct 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 tuple_element<0, pair<_T1, _T2> > { - using type _LIBCPP_NODEBUG = _T1; -}; - -template <class _T1, class _T2> -struct 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> -[[__nodiscard__]] 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> -[[__nodiscard__]] 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> -[[__nodiscard__]] 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> -[[__nodiscard__]] 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> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT { - return __p.first; -} - -template <class _T1, class _T2> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT { - return __p.first; -} - -template <class _T1, class _T2> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT { - return std::forward<_T1&&>(__p.first); -} - -template <class _T1, class _T2> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT { - return std::forward<_T1 const&&>(__p.first); -} - -template <class _T2, class _T1> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T2& get(pair<_T1, _T2>& __p) _NOEXCEPT { - return __p.second; -} - -template <class _T2, class _T1> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T2 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT { - return __p.second; -} - -template <class _T2, class _T1> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T2&& get(pair<_T1, _T2>&& __p) _NOEXCEPT { - return std::forward<_T2&&>(__p.second); -} - -template <class _T2, class _T1> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T2 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT { - return std::forward<_T2 const&&>(__p.second); -} - -#endif // _LIBCPP_STD_VER >= 14 - -_LIBCPP_END_NAMESPACE_STD - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP___UTILITY_PAIR_H diff --git a/third_party/libcxx/include/c++/v1/__utility/piecewise_construct.h b/third_party/libcxx/include/c++/v1/__utility/piecewise_construct.h deleted file mode 100644 index 9823b70..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/piecewise_construct.h +++ /dev/null @@ -1,32 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 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/third_party/libcxx/include/c++/v1/__utility/priority_tag.h b/third_party/libcxx/include/c++/v1/__utility/priority_tag.h deleted file mode 100644 index ef7cf16..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/priority_tag.h +++ /dev/null @@ -1,28 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/size_t.h> - -#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/third_party/libcxx/include/c++/v1/__utility/private_constructor_tag.h b/third_party/libcxx/include/c++/v1/__utility/private_constructor_tag.h deleted file mode 100644 index 462cab4..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/private_constructor_tag.h +++ /dev/null @@ -1,28 +0,0 @@ -// -*- 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/third_party/libcxx/include/c++/v1/__utility/rel_ops.h b/third_party/libcxx/include/c++/v1/__utility/rel_ops.h deleted file mode 100644 index a8caf5b..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/rel_ops.h +++ /dev/null @@ -1,46 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/third_party/libcxx/include/c++/v1/__utility/scope_guard.h b/third_party/libcxx/include/c++/v1/__utility/scope_guard.h deleted file mode 100644 index db4f0e4..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/scope_guard.h +++ /dev/null @@ -1,57 +0,0 @@ -// -*- 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_SCOPE_GUARD_H -#define _LIBCPP___UTILITY_SCOPE_GUARD_H - -#include <__config> -#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 - -template <class _Func> -class __scope_guard { - _Func __func_; - -public: - _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __scope_guard(_Func __func) : __func_(std::move(__func)) {} - _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__scope_guard() { __func_(); } - - __scope_guard(const __scope_guard&) = delete; - __scope_guard& operator=(const __scope_guard&) = delete; - __scope_guard& operator=(__scope_guard&&) = delete; - -// C++14 doesn't have mandatory RVO, so we have to provide a declaration even though no compiler will ever generate -// a call to the move constructor. -#if _LIBCPP_STD_VER <= 14 - __scope_guard(__scope_guard&&); -#else - __scope_guard(__scope_guard&&) = delete; -#endif -}; - -_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__scope_guard); - -template <class _Func> -_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __scope_guard<_Func> __make_scope_guard(_Func __func) { - return __scope_guard<_Func>(std::move(__func)); -} - -_LIBCPP_END_NAMESPACE_STD - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP___UTILITY_SCOPE_GUARD_H diff --git a/third_party/libcxx/include/c++/v1/__utility/small_buffer.h b/third_party/libcxx/include/c++/v1/__utility/small_buffer.h deleted file mode 100644 index 132a57f..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/small_buffer.h +++ /dev/null @@ -1,101 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 <__cstddef/byte.h> -#include <__cstddef/size_t.h> -#include <__memory/construct_at.h> -#include <__new/allocate.h> -#include <__new/launder.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> - -#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 = reinterpret_cast<byte*>(std::__libcpp_allocate<_Stored>(__element_count(1))); - 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>) - std::__libcpp_deallocate<_Stored>(__get<_Stored>(), __element_count(1)); - } - - 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/third_party/libcxx/include/c++/v1/__utility/swap.h b/third_party/libcxx/include/c++/v1/__utility/swap.h deleted file mode 100644 index d374825..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/swap.h +++ /dev/null @@ -1,60 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 <__cstddef/size_t.h> -#include <__type_traits/enable_if.h> -#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/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 - -#ifndef _LIBCPP_CXX03_LANG -template <class _Tp> -using __swap_result_t _LIBCPP_NODEBUG = - __enable_if_t<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>; -#else -template <class> -using __swap_result_t _LIBCPP_NODEBUG = 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/third_party/libcxx/include/c++/v1/__utility/to_underlying.h b/third_party/libcxx/include/c++/v1/__utility/to_underlying.h deleted file mode 100644 index 3e9d405..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/to_underlying.h +++ /dev/null @@ -1,38 +0,0 @@ -// -*- 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> -[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr __underlying_type_t<_Tp> __to_underlying(_Tp __val) noexcept { - return static_cast<__underlying_type_t<_Tp>>(__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/third_party/libcxx/include/c++/v1/__utility/try_key_extraction.h b/third_party/libcxx/include/c++/v1/__utility/try_key_extraction.h deleted file mode 100644 index 755c082..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/try_key_extraction.h +++ /dev/null @@ -1,114 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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_TRY_EXTRACT_KEY_H -#define _LIBCPP___UTILITY_TRY_EXTRACT_KEY_H - -#include <__config> -#include <__fwd/pair.h> -#include <__fwd/tuple.h> -#include <__type_traits/enable_if.h> -#include <__type_traits/is_same.h> -#include <__type_traits/remove_const.h> -#include <__type_traits/remove_const_ref.h> -#include <__utility/declval.h> -#include <__utility/forward.h> -#include <__utility/piecewise_construct.h> -#include <__utility/priority_tag.h> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _KeyT, class _Ret, class _WithKey, class _WithoutKey, class... _Args> -_LIBCPP_HIDE_FROM_ABI _Ret -__try_key_extraction_impl(__priority_tag<0>, _WithKey, _WithoutKey __without_key, _Args&&... __args) { - return __without_key(std::forward<_Args>(__args)...); -} - -template <class _KeyT, - class _Ret, - class _WithKey, - class _WithoutKey, - class _Arg, - __enable_if_t<is_same<_KeyT, __remove_const_ref_t<_Arg> >::value, int> = 0> -_LIBCPP_HIDE_FROM_ABI _Ret -__try_key_extraction_impl(__priority_tag<1>, _WithKey __with_key, _WithoutKey, _Arg&& __arg) { - return __with_key(__arg, std::forward<_Arg>(__arg)); -} - -template <class _KeyT, - class _Ret, - class _WithKey, - class _WithoutKey, - class _Arg, - __enable_if_t<__is_pair_v<__remove_const_ref_t<_Arg> > && - is_same<__remove_const_t<typename __remove_const_ref_t<_Arg>::first_type>, _KeyT>::value, - int> = 0> -_LIBCPP_HIDE_FROM_ABI _Ret -__try_key_extraction_impl(__priority_tag<1>, _WithKey __with_key, _WithoutKey, _Arg&& __arg) { - return __with_key(__arg.first, std::forward<_Arg>(__arg)); -} - -template <class _KeyT, - class _Ret, - class _WithKey, - class _WithoutKey, - class _Arg1, - class _Arg2, - __enable_if_t<is_same<_KeyT, __remove_const_ref_t<_Arg1> >::value, int> = 0> -_LIBCPP_HIDE_FROM_ABI _Ret -__try_key_extraction_impl(__priority_tag<1>, _WithKey __with_key, _WithoutKey, _Arg1&& __arg1, _Arg2&& __arg2) { - return __with_key(__arg1, std::forward<_Arg1>(__arg1), std::forward<_Arg2>(__arg2)); -} - -#ifndef _LIBCPP_CXX03_LANG -template <class _KeyT, - class _Ret, - class _WithKey, - class _WithoutKey, - class _PiecewiseConstruct, - class _Tuple1, - class _Tuple2, - __enable_if_t<is_same<__remove_const_ref_t<_PiecewiseConstruct>, piecewise_construct_t>::value && - __is_tuple_v<_Tuple1> && tuple_size<_Tuple1>::value == 1 && - is_same<__remove_const_ref_t<typename tuple_element<0, _Tuple1>::type>, _KeyT>::value, - int> = 0> -_LIBCPP_HIDE_FROM_ABI _Ret __try_key_extraction_impl( - __priority_tag<1>, - _WithKey __with_key, - _WithoutKey, - _PiecewiseConstruct&& __pc, - _Tuple1&& __tuple1, - _Tuple2&& __tuple2) { - return __with_key( - std::get<0>(__tuple1), - std::forward<_PiecewiseConstruct>(__pc), - std::forward<_Tuple1>(__tuple1), - std::forward<_Tuple2>(__tuple2)); -} -#endif // _LIBCPP_CXX03_LANG - -// This function tries extracting the given _KeyT from _Args... -// If it succeeds to extract the key, it calls the `__with_key` function with the extracted key and all of the -// arguments. Otherwise it calls the `__without_key` function with all of the arguments. -// -// Both `__with_key` and `__without_key` must take all arguments by reference. -template <class _KeyT, class _WithKey, class _WithoutKey, class... _Args> -_LIBCPP_HIDE_FROM_ABI decltype(std::declval<_WithoutKey>()(std::declval<_Args>()...)) -__try_key_extraction(_WithKey __with_key, _WithoutKey __without_key, _Args&&... __args) { - using _Ret = decltype(__without_key(std::forward<_Args>(__args)...)); - return std::__try_key_extraction_impl<_KeyT, _Ret>( - __priority_tag<1>(), __with_key, __without_key, std::forward<_Args>(__args)...); -} - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP___UTILITY_TRY_EXTRACT_KEY_H diff --git a/third_party/libcxx/include/c++/v1/__utility/unreachable.h b/third_party/libcxx/include/c++/v1/__utility/unreachable.h deleted file mode 100644 index 5525452..0000000 --- a/third_party/libcxx/include/c++/v1/__utility/unreachable.h +++ /dev/null @@ -1,34 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 - -[[__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 |