diff options
Diffstat (limited to 'third_party/libcxx/include/c++/v1/__expected')
4 files changed, 0 insertions, 2141 deletions
diff --git a/third_party/libcxx/include/c++/v1/__expected/bad_expected_access.h b/third_party/libcxx/include/c++/v1/__expected/bad_expected_access.h deleted file mode 100644 index b195810..0000000 --- a/third_party/libcxx/include/c++/v1/__expected/bad_expected_access.h +++ /dev/null @@ -1,75 +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___EXPECTED_BAD_EXPECTED_ACCESS_H -#define _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H - -#include <__config> -#include <__exception/exception.h> -#include <__utility/move.h> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - -#if _LIBCPP_STD_VER >= 23 - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _Err> -class bad_expected_access; - -_LIBCPP_DIAGNOSTIC_PUSH -# if !_LIBCPP_AVAILABILITY_HAS_BAD_EXPECTED_ACCESS_KEY_FUNCTION -_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables") -# endif -template <> -class _LIBCPP_EXPORTED_FROM_ABI bad_expected_access<void> : public exception { -protected: - _LIBCPP_HIDE_FROM_ABI bad_expected_access() noexcept = default; - _LIBCPP_HIDE_FROM_ABI bad_expected_access(const bad_expected_access&) noexcept = default; - _LIBCPP_HIDE_FROM_ABI bad_expected_access(bad_expected_access&&) noexcept = default; - _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(const bad_expected_access&) noexcept = default; - _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(bad_expected_access&&) noexcept = default; - _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~bad_expected_access() override = default; - -public: -# if _LIBCPP_AVAILABILITY_HAS_BAD_EXPECTED_ACCESS_KEY_FUNCTION - [[nodiscard]] const char* what() const noexcept override; -# else - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI_VIRTUAL const char* what() const noexcept override { - return "bad access to std::expected"; - } -# endif -}; -_LIBCPP_DIAGNOSTIC_POP - -template <class _Err> -class bad_expected_access : public bad_expected_access<void> { -public: - _LIBCPP_HIDE_FROM_ABI explicit bad_expected_access(_Err __e) : __unex_(std::move(__e)) {} - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Err& error() & noexcept { return __unex_; } - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const _Err& error() const& noexcept { return __unex_; } - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Err&& error() && noexcept { return std::move(__unex_); } - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const _Err&& error() const&& noexcept { return std::move(__unex_); } - -private: - _Err __unex_; -}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP_STD_VER >= 23 - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H diff --git a/third_party/libcxx/include/c++/v1/__expected/expected.h b/third_party/libcxx/include/c++/v1/__expected/expected.h deleted file mode 100644 index 24ae33d..0000000 --- a/third_party/libcxx/include/c++/v1/__expected/expected.h +++ /dev/null @@ -1,1907 +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___EXPECTED_EXPECTED_H -#define _LIBCPP___EXPECTED_EXPECTED_H - -#include <__assert> -#include <__config> -#include <__expected/bad_expected_access.h> -#include <__expected/unexpect.h> -#include <__expected/unexpected.h> -#include <__functional/invoke.h> -#include <__memory/addressof.h> -#include <__memory/construct_at.h> -#include <__type_traits/conditional.h> -#include <__type_traits/conjunction.h> -#include <__type_traits/disjunction.h> -#include <__type_traits/integral_constant.h> -#include <__type_traits/invoke.h> -#include <__type_traits/is_assignable.h> -#include <__type_traits/is_constructible.h> -#include <__type_traits/is_convertible.h> -#include <__type_traits/is_core_convertible.h> -#include <__type_traits/is_function.h> -#include <__type_traits/is_nothrow_assignable.h> -#include <__type_traits/is_nothrow_constructible.h> -#include <__type_traits/is_reference.h> -#include <__type_traits/is_same.h> -#include <__type_traits/is_swappable.h> -#include <__type_traits/is_trivially_constructible.h> -#include <__type_traits/is_trivially_destructible.h> -#include <__type_traits/is_trivially_relocatable.h> -#include <__type_traits/is_void.h> -#include <__type_traits/lazy.h> -#include <__type_traits/negation.h> -#include <__type_traits/remove_cv.h> -#include <__type_traits/remove_cvref.h> -#include <__utility/as_const.h> -#include <__utility/exception_guard.h> -#include <__utility/forward.h> -#include <__utility/in_place.h> -#include <__utility/move.h> -#include <__utility/swap.h> -#include <__verbose_abort> -#include <initializer_list> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - -#if _LIBCPP_STD_VER >= 23 - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _Tp, class _Err> -class expected; - -template <class _Tp> -struct __is_std_expected : false_type {}; - -template <class _Tp, class _Err> -struct __is_std_expected<expected<_Tp, _Err>> : true_type {}; - -struct __expected_construct_in_place_from_invoke_tag {}; -struct __expected_construct_unexpected_from_invoke_tag {}; - -template <class _Err, class _Arg> -_LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) { -# if _LIBCPP_HAS_EXCEPTIONS - throw bad_expected_access<_Err>(std::forward<_Arg>(__arg)); -# else - (void)__arg; - _LIBCPP_VERBOSE_ABORT("bad_expected_access was thrown in -fno-exceptions mode"); -# endif -} - -// If parameter type `_Tp` of `__conditional_no_unique_address` is neither -// copyable nor movable, a constructor with this tag is provided. For that -// constructor, the user has to provide a function and arguments. The function -// must return an object of type `_Tp`. When the function is invoked by the -// constructor, guaranteed copy elision kicks in and the `_Tp` is constructed -// in place. -struct __conditional_no_unique_address_invoke_tag {}; - -// This class implements an object with `[[no_unique_address]]` conditionally applied to it, -// based on the value of `_NoUnique`. -// -// A member of this class must always have `[[no_unique_address]]` applied to -// it. Otherwise, the `[[no_unique_address]]` in the "`_NoUnique == true`" case -// would not have any effect. In the `false` case, the `__v` is not -// `[[no_unique_address]]`, so nullifies the effects of the "outer" -// `[[no_unique_address]]` regarding data layout. -// -// If we had a language feature, this class would basically be replaced by `[[no_unique_address(condition)]]`. -template <bool _NoUnique, class _Tp> -struct __conditional_no_unique_address; - -template <class _Tp> -struct __conditional_no_unique_address<true, _Tp> { - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __conditional_no_unique_address(in_place_t, _Args&&... __args) - : __v(std::forward<_Args>(__args)...) {} - - template <class _Func, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __conditional_no_unique_address( - __conditional_no_unique_address_invoke_tag, _Func&& __f, _Args&&... __args) - : __v(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} - - _LIBCPP_NO_UNIQUE_ADDRESS _Tp __v; -}; - -template <class _Tp> -struct __conditional_no_unique_address<false, _Tp> { - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __conditional_no_unique_address(in_place_t, _Args&&... __args) - : __v(std::forward<_Args>(__args)...) {} - - template <class _Func, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __conditional_no_unique_address( - __conditional_no_unique_address_invoke_tag, _Func&& __f, _Args&&... __args) - : __v(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} - - _Tp __v; -}; - -// This function returns whether the type `_Second` can be stuffed into the tail padding -// of the `_First` type if both of them are given `[[no_unique_address]]`. -template <class _First, class _Second> -inline constexpr bool __fits_in_tail_padding = []() { - struct __x { - _LIBCPP_NO_UNIQUE_ADDRESS _First __first; - _LIBCPP_NO_UNIQUE_ADDRESS _Second __second; - }; - return sizeof(__x) == sizeof(_First); -}(); - -// This class implements the storage used by `std::expected`. We have a few -// goals for this storage: -// 1. Whenever the underlying {_Tp | _Unex} combination has free bytes in its -// tail padding, we should reuse it to store the bool discriminator of the -// expected, so as to save space. -// 2. Whenever the `expected<_Tp, _Unex>` as a whole has free bytes in its tail -// padding, we should allow an object following the expected to be stored in -// its tail padding. -// 3. However, we never want a user object (say `X`) that would follow an -// `expected<_Tp, _Unex>` to be stored in the padding bytes of the -// underlying {_Tp | _Unex} union, if any. That is because we use -// `construct_at` on that union, which would end up overwriting the `X` -// member if it is stored in the tail padding of the union. -// -// To achieve this, `__expected_base`'s logic is implemented in an inner -// `__repr` class. `__expected_base` holds one `__repr` member which is -// conditionally `[[no_unique_address]]`. The `__repr` class holds the -// underlying {_Tp | _Unex} union and a boolean "has value" flag. -// -// Which one of the `__repr_`/`__union_` members is `[[no_unique_address]]` -// depends on whether the "has value" boolean fits into the tail padding of -// the underlying {_Tp | _Unex} union: -// -// - In case the "has value" bool fits into the tail padding of the union, the -// whole `__repr_` member is _not_ `[[no_unique_address]]` as it needs to be -// transparently replaced on `emplace()`/`swap()` etc. -// - In case the "has value" bool does not fit into the tail padding of the -// union, only the union member must be transparently replaced (therefore is -// _not_ `[[no_unique_address]]`) and the "has value" flag must be adjusted -// manually. -// -// This way, the member that is transparently replaced on mutating operations -// is never `[[no_unique_address]]`, satisfying the requirements from -// "[basic.life]" in the standard. -// -// Stripped away of all superfluous elements, the layout of `__expected_base` -// then looks like this: -// -// template <class Tp, class Err> -// class expected_base { -// union union_t { -// [[no_unique_address]] Tp val; -// [[no_unique_address]] Err unex; -// }; -// -// static constexpr bool put_flag_in_tail = fits_in_tail_padding<union_t, bool>; -// static constexpr bool allow_reusing_expected_tail_padding = !put_flag_in_tail; -// -// struct repr { -// private: -// // If "has value" fits into the tail, this should be -// // `[[no_unique_address]]`, otherwise not. -// [[no_unique_address]] conditional_no_unique_address< -// put_flag_in_tail, -// union_t>::type union_; -// [[no_unique_address]] bool has_val_; -// }; -// -// protected: -// // If "has value" fits into the tail, this must _not_ be -// // `[[no_unique_address]]` so that we fill out the -// // complete `expected` object. -// [[no_unique_address]] conditional_no_unique_address< -// allow_reusing_expected_tail_padding, -// repr>::type repr_; -// }; -// -template <class _Tp, class _Err> -class __expected_base { - // use named union because [[no_unique_address]] cannot be applied to an unnamed union, - // also guaranteed elision into a potentially-overlapping subobject is unsettled (and - // it's not clear that it's implementable, given that the function is allowed to clobber - // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107. - union __union_t { - _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) - requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> && - is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>) - = default; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t(__union_t&&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t(__union_t&&) - requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> && - is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>) - = default; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(const __union_t&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(__union_t&&) = delete; - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(in_place_t, _Args&&... __args) - : __val_(std::forward<_Args>(__args)...) {} - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(unexpect_t, _Args&&... __args) - : __unex_(std::forward<_Args>(__args)...) {} - - template <class _Func, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( - std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args) - : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} - - template <class _Func, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( - std::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args) - : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} - - _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() - requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>) - = default; - - // __repr's destructor handles this - _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() {} - - _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_; - _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_; - }; - - static constexpr bool __put_flag_in_tail = __fits_in_tail_padding<__union_t, bool>; - static constexpr bool __allow_reusing_expected_tail_padding = !__put_flag_in_tail; - - struct __repr { - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr() = delete; - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(in_place_t __tag, _Args&&... __args) - : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(true) {} - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(unexpect_t __tag, _Args&&... __args) - : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(false) {} - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(std::__expected_construct_in_place_from_invoke_tag __tag, - _Args&&... __args) - : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(true) {} - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(std::__expected_construct_unexpected_from_invoke_tag __tag, - _Args&&... __args) - : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(false) {} - - // The return value of `__make_union` must be constructed in place in the - // `__v` member of `__union_`, relying on guaranteed copy elision. To do - // this, the `__conditional_no_unique_address_invoke_tag` constructor is - // called with a lambda that is immediately called inside - // `__conditional_no_unique_address`'s constructor. - template <class _OtherUnion> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(bool __has_val, _OtherUnion&& __other) - requires(__allow_reusing_expected_tail_padding) - : __union_(__conditional_no_unique_address_invoke_tag{}, - [&] { return __make_union(__has_val, std::forward<_OtherUnion>(__other)); }), - __has_val_(__has_val) {} - - _LIBCPP_HIDE_FROM_ABI constexpr __repr(const __repr&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __repr(const __repr&) - requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> && - is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>) - = default; - _LIBCPP_HIDE_FROM_ABI constexpr __repr(__repr&&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __repr(__repr&&) - requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> && - is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>) - = default; - - _LIBCPP_HIDE_FROM_ABI constexpr __repr& operator=(const __repr&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __repr& operator=(__repr&&) = delete; - - _LIBCPP_HIDE_FROM_ABI constexpr ~__repr() - requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>) - = default; - - _LIBCPP_HIDE_FROM_ABI constexpr ~__repr() - requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>) - { - __destroy_union_member(); - } - - _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union() - requires(__allow_reusing_expected_tail_padding && - (is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)) - { - // Note: Since the destructor of the union is trivial, this does nothing - // except to end the lifetime of the union. - std::destroy_at(&__union_.__v); - } - - _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union() - requires(__allow_reusing_expected_tail_padding && - (!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>)) - { - __destroy_union_member(); - std::destroy_at(&__union_.__v); - } - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr void __construct_union(in_place_t, _Args&&... __args) - requires(__allow_reusing_expected_tail_padding) - { - std::construct_at(&__union_.__v, in_place, std::forward<_Args>(__args)...); - __has_val_ = true; - } - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr void __construct_union(unexpect_t, _Args&&... __args) - requires(__allow_reusing_expected_tail_padding) - { - std::construct_at(&__union_.__v, unexpect, std::forward<_Args>(__args)...); - __has_val_ = false; - } - - private: - template <class, class> - friend class __expected_base; - - _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union_member() - requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>) - { - if (__has_val_) { - std::destroy_at(std::addressof(__union_.__v.__val_)); - } else { - std::destroy_at(std::addressof(__union_.__v.__unex_)); - } - } - - template <class _OtherUnion> - _LIBCPP_HIDE_FROM_ABI static constexpr __union_t __make_union(bool __has_val, _OtherUnion&& __other) - requires(__allow_reusing_expected_tail_padding) - { - if (__has_val) - return __union_t(in_place, std::forward<_OtherUnion>(__other).__val_); - else - return __union_t(unexpect, std::forward<_OtherUnion>(__other).__unex_); - } - - _LIBCPP_NO_UNIQUE_ADDRESS __conditional_no_unique_address<__put_flag_in_tail, __union_t> __union_; - _LIBCPP_NO_UNIQUE_ADDRESS bool __has_val_; - }; - - template <class _OtherUnion> - _LIBCPP_HIDE_FROM_ABI static constexpr __repr __make_repr(bool __has_val, _OtherUnion&& __other) - requires(__put_flag_in_tail) - { - if (__has_val) - return __repr(in_place, std::forward<_OtherUnion>(__other).__val_); - else - return __repr(unexpect, std::forward<_OtherUnion>(__other).__unex_); - } - -protected: - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __expected_base(_Args&&... __args) - : __repr_(in_place, std::forward<_Args>(__args)...) {} - - // In case we copy/move construct from another `expected` we need to create - // our `expected` so that it either has a value or not, depending on the "has - // value" flag of the other `expected`. To do this without falling back on - // `std::construct_at` we rely on guaranteed copy elision using two helper - // functions `__make_repr` and `__make_union`. There have to be two since - // there are two data layouts with different members being - // `[[no_unique_address]]`. GCC (as of version 13) does not do guaranteed - // copy elision when initializing `[[no_unique_address]]` members. The two - // cases are: - // - // - `__make_repr`: This is used when the "has value" flag lives in the tail - // of the union. In this case, the `__repr` member is _not_ - // `[[no_unique_address]]`. - // - `__make_union`: When the "has value" flag does _not_ fit in the tail of - // the union, the `__repr` member is `[[no_unique_address]]` and the union - // is not. - // - // This constructor "catches" the first case and leaves the second case to - // `__union_t`, its constructors and `__make_union`. - template <class _OtherUnion> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __expected_base(bool __has_val, _OtherUnion&& __other) - requires(__put_flag_in_tail) - : __repr_(__conditional_no_unique_address_invoke_tag{}, - [&] { return __make_repr(__has_val, std::forward<_OtherUnion>(__other)); }) {} - - _LIBCPP_HIDE_FROM_ABI constexpr void __destroy() { - if constexpr (__put_flag_in_tail) - std::destroy_at(&__repr_.__v); - else - __repr_.__v.__destroy_union(); - } - - template <class _Tag, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr void __construct(_Tag __tag, _Args&&... __args) { - if constexpr (__put_flag_in_tail) - std::construct_at(&__repr_.__v, __tag, std::forward<_Args>(__args)...); - else - __repr_.__v.__construct_union(__tag, std::forward<_Args>(__args)...); - } - - _LIBCPP_HIDE_FROM_ABI constexpr bool __has_val() const { return __repr_.__v.__has_val_; } - _LIBCPP_HIDE_FROM_ABI constexpr __union_t& __union() { return __repr_.__v.__union_.__v; } - _LIBCPP_HIDE_FROM_ABI constexpr const __union_t& __union() const { return __repr_.__v.__union_.__v; } - _LIBCPP_HIDE_FROM_ABI constexpr _Tp& __val() { return __repr_.__v.__union_.__v.__val_; } - _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& __val() const { return __repr_.__v.__union_.__v.__val_; } - _LIBCPP_HIDE_FROM_ABI constexpr _Err& __unex() { return __repr_.__v.__union_.__v.__unex_; } - _LIBCPP_HIDE_FROM_ABI constexpr const _Err& __unex() const { return __repr_.__v.__union_.__v.__unex_; } - -private: - _LIBCPP_NO_UNIQUE_ADDRESS __conditional_no_unique_address<__allow_reusing_expected_tail_padding, __repr> __repr_; -}; - -template <class _Tp, class _Err> -class expected : private __expected_base<_Tp, _Err> { - static_assert(!is_reference_v<_Tp> && !is_function_v<_Tp> && !is_same_v<remove_cv_t<_Tp>, in_place_t> && - !is_same_v<remove_cv_t<_Tp>, unexpect_t> && !__is_std_unexpected<remove_cv_t<_Tp>>::value && - __valid_std_unexpected<_Err>::value, - "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a " - "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a " - "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the " - "definition of the template expected<T, E> with a type for the E parameter that is not a valid " - "template argument for unexpected is ill-formed."); - - template <class _Up, class _OtherErr> - friend class expected; - - using __base _LIBCPP_NODEBUG = __expected_base<_Tp, _Err>; - -public: - using value_type = _Tp; - using error_type = _Err; - using unexpected_type = unexpected<_Err>; - - using __trivially_relocatable _LIBCPP_NODEBUG = - __conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value && __libcpp_is_trivially_relocatable<_Err>::value, - expected, - void>; - - template <class _Up> - using rebind = expected<_Up, error_type>; - - // [expected.object.ctor], constructors - _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept(is_nothrow_default_constructible_v<_Tp>) // strengthened - requires is_default_constructible_v<_Tp> - : __base(in_place) {} - - _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete; - - _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) - requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Tp> && - is_trivially_copy_constructible_v<_Err>) - = default; - - _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __other) noexcept( - is_nothrow_copy_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Err>) // strengthened - requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> && - !(is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>)) - : __base(__other.__has_val(), __other.__union()) {} - - _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&) - requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Tp> && - is_trivially_move_constructible_v<_Err>) - = default; - - _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __other) noexcept( - is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_constructible_v<_Err>) - requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> && - !(is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>)) - : __base(__other.__has_val(), std::move(__other.__union())) {} - -private: - template <class _Up, class _OtherErr, class _UfQual, class _OtherErrQual> - using __can_convert _LIBCPP_NODEBUG = _And< - is_constructible<_Tp, _UfQual>, - is_constructible<_Err, _OtherErrQual>, - _If<_Not<is_same<remove_cv_t<_Tp>, bool>>::value, - _And< _Not<_And<is_same<_Tp, _Up>, is_same<_Err, _OtherErr>>>, // use the copy constructor instead, see #92676 - _Not<is_constructible<_Tp, expected<_Up, _OtherErr>&>>, - _Not<is_constructible<_Tp, expected<_Up, _OtherErr>>>, - _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>&>>, - _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>>>, - _Not<is_convertible<expected<_Up, _OtherErr>&, _Tp>>, - _Not<is_convertible<expected<_Up, _OtherErr>&&, _Tp>>, - _Not<is_convertible<const expected<_Up, _OtherErr>&, _Tp>>, - _Not<is_convertible<const expected<_Up, _OtherErr>&&, _Tp>>>, - true_type>, - _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>, - _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>, - _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>, - _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>> >; - - template <class _Func, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected( - std::__expected_construct_in_place_from_invoke_tag __tag, _Func&& __f, _Args&&... __args) - : __base(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...) {} - - template <class _Func, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected( - std::__expected_construct_unexpected_from_invoke_tag __tag, _Func&& __f, _Args&&... __args) - : __base(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...) {} - -public: - template <class _Up, class _OtherErr> - requires __can_convert<_Up, _OtherErr, const _Up&, const _OtherErr&>::value - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _Up&, _Tp> || - !is_convertible_v<const _OtherErr&, _Err>) - expected(const expected<_Up, _OtherErr>& __other) noexcept( - is_nothrow_constructible_v<_Tp, const _Up&> && - is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened - : __base(__other.__has_val(), __other.__union()) {} - - template <class _Up, class _OtherErr> - requires __can_convert<_Up, _OtherErr, _Up, _OtherErr>::value - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp> || !is_convertible_v<_OtherErr, _Err>) - expected(expected<_Up, _OtherErr>&& __other) noexcept( - is_nothrow_constructible_v<_Tp, _Up> && is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened - : __base(__other.__has_val(), std::move(__other.__union())) {} - - template <class _Up = remove_cv_t<_Tp>> - requires(!is_same_v<remove_cvref_t<_Up>, in_place_t> && !is_same_v<expected, remove_cvref_t<_Up>> && - !is_same_v<remove_cvref_t<_Up>, unexpect_t> && is_constructible_v<_Tp, _Up> && - !__is_std_unexpected<remove_cvref_t<_Up>>::value && - (!is_same_v<remove_cv_t<_Tp>, bool> || !__is_std_expected<remove_cvref_t<_Up>>::value)) - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp>) - expected(_Up&& __u) noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened - : __base(in_place, std::forward<_Up>(__u)) {} - - template <class _OtherErr> - requires is_constructible_v<_Err, const _OtherErr&> - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>) expected( - const unexpected<_OtherErr>& __unex) noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened - : __base(unexpect, __unex.error()) {} - - template <class _OtherErr> - requires is_constructible_v<_Err, _OtherErr> - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>) - expected(unexpected<_OtherErr>&& __unex) noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened - : __base(unexpect, std::move(__unex.error())) {} - - template <class... _Args> - requires is_constructible_v<_Tp, _Args...> - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Tp, _Args...>) // strengthened - : __base(in_place, std::forward<_Args>(__args)...) {} - - template <class _Up, class... _Args> - requires is_constructible_v< _Tp, initializer_list<_Up>&, _Args... > - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) // strengthened - : __base(in_place, __il, std::forward<_Args>(__args)...) {} - - template <class... _Args> - requires is_constructible_v<_Err, _Args...> - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Err, _Args...>) // strengthened - : __base(unexpect, std::forward<_Args>(__args)...) {} - - template <class _Up, class... _Args> - requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... > - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened - : __base(unexpect, __il, std::forward<_Args>(__args)...) {} - - // [expected.object.dtor], destructor - - _LIBCPP_HIDE_FROM_ABI constexpr ~expected() = default; - -private: - template <class _Tag, class _OtherTag, class _T1, class _T2, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr void __reinit_expected(_T2& __oldval, _Args&&... __args) { - if constexpr (is_nothrow_constructible_v<_T1, _Args...>) { - this->__destroy(); - this->__construct(_Tag{}, std::forward<_Args>(__args)...); - } else if constexpr (is_nothrow_move_constructible_v<_T1>) { - _T1 __tmp(std::forward<_Args>(__args)...); - this->__destroy(); - this->__construct(_Tag{}, std::move(__tmp)); - } else { - static_assert( - is_nothrow_move_constructible_v<_T2>, - "To provide strong exception guarantee, T2 has to satisfy `is_nothrow_move_constructible_v` so that it can " - "be reverted to the previous state in case an exception is thrown during the assignment."); - _T2 __tmp(std::move(__oldval)); - this->__destroy(); - auto __trans = std::__make_exception_guard([&] { this->__construct(_OtherTag{}, std::move(__tmp)); }); - this->__construct(_Tag{}, std::forward<_Args>(__args)...); - __trans.__complete(); - } - } - -public: - // [expected.object.assign], assignment - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete; - - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs) noexcept( - is_nothrow_copy_assignable_v<_Tp> && is_nothrow_copy_constructible_v<_Tp> && is_nothrow_copy_assignable_v<_Err> && - is_nothrow_copy_constructible_v<_Err>) // strengthened - requires(is_copy_assignable_v<_Tp> && is_copy_constructible_v<_Tp> && is_copy_assignable_v<_Err> && - is_copy_constructible_v<_Err> && - (is_nothrow_move_constructible_v<_Tp> || is_nothrow_move_constructible_v<_Err>)) - { - if (this->__has_val() && __rhs.__has_val()) { - this->__val() = __rhs.__val(); - } else if (this->__has_val()) { - __reinit_expected<unexpect_t, in_place_t, _Err, _Tp>(this->__val(), __rhs.__unex()); - } else if (__rhs.__has_val()) { - __reinit_expected<in_place_t, unexpect_t, _Tp, _Err>(this->__unex(), __rhs.__val()); - } else { - this->__unex() = __rhs.__unex(); - } - return *this; - } - - _LIBCPP_HIDE_FROM_ABI constexpr expected& - operator=(expected&& __rhs) noexcept(is_nothrow_move_assignable_v<_Tp> && is_nothrow_move_constructible_v<_Tp> && - is_nothrow_move_assignable_v<_Err> && is_nothrow_move_constructible_v<_Err>) - requires(is_move_constructible_v<_Tp> && is_move_assignable_v<_Tp> && is_move_constructible_v<_Err> && - is_move_assignable_v<_Err> && - (is_nothrow_move_constructible_v<_Tp> || is_nothrow_move_constructible_v<_Err>)) - { - if (this->__has_val() && __rhs.__has_val()) { - this->__val() = std::move(__rhs.__val()); - } else if (this->__has_val()) { - __reinit_expected<unexpect_t, in_place_t, _Err, _Tp>(this->__val(), std::move(__rhs.__unex())); - } else if (__rhs.__has_val()) { - __reinit_expected<in_place_t, unexpect_t, _Tp, _Err>(this->__unex(), std::move(__rhs.__val())); - } else { - this->__unex() = std::move(__rhs.__unex()); - } - return *this; - } - - template <class _Up = remove_cv_t<_Tp>> - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(_Up&& __v) - requires(!is_same_v<expected, remove_cvref_t<_Up>> && !__is_std_unexpected<remove_cvref_t<_Up>>::value && - is_constructible_v<_Tp, _Up> && is_assignable_v<_Tp&, _Up> && - (is_nothrow_constructible_v<_Tp, _Up> || is_nothrow_move_constructible_v<_Tp> || - is_nothrow_move_constructible_v<_Err>)) - { - if (this->__has_val()) { - this->__val() = std::forward<_Up>(__v); - } else { - __reinit_expected<in_place_t, unexpect_t, _Tp, _Err>(this->__unex(), std::forward<_Up>(__v)); - } - return *this; - } - -private: - template <class _OtherErrQual> - static constexpr bool __can_assign_from_unexpected = - _And< is_constructible<_Err, _OtherErrQual>, - is_assignable<_Err&, _OtherErrQual>, - _Lazy<_Or, - is_nothrow_constructible<_Err, _OtherErrQual>, - is_nothrow_move_constructible<_Tp>, - is_nothrow_move_constructible<_Err>> >::value; - -public: - template <class _OtherErr> - requires(__can_assign_from_unexpected<const _OtherErr&>) - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) { - if (this->__has_val()) { - __reinit_expected<unexpect_t, in_place_t, _Err, _Tp>(this->__val(), __un.error()); - } else { - this->__unex() = __un.error(); - } - return *this; - } - - template <class _OtherErr> - requires(__can_assign_from_unexpected<_OtherErr>) - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) { - if (this->__has_val()) { - __reinit_expected<unexpect_t, in_place_t, _Err, _Tp>(this->__val(), std::move(__un.error())); - } else { - this->__unex() = std::move(__un.error()); - } - return *this; - } - - template <class... _Args> - requires is_nothrow_constructible_v<_Tp, _Args...> - _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(_Args&&... __args) noexcept { - this->__destroy(); - this->__construct(in_place, std::forward<_Args>(__args)...); - return this->__val(); - } - - template <class _Up, class... _Args> - requires is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...> - _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept { - this->__destroy(); - this->__construct(in_place, __il, std::forward<_Args>(__args)...); - return this->__val(); - } - -public: - // [expected.object.swap], swap - _LIBCPP_HIDE_FROM_ABI constexpr void - swap(expected& __rhs) noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp> && - is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>) - requires(is_swappable_v<_Tp> && is_swappable_v<_Err> && is_move_constructible_v<_Tp> && - is_move_constructible_v<_Err> && - (is_nothrow_move_constructible_v<_Tp> || is_nothrow_move_constructible_v<_Err>)) - { - auto __swap_val_unex_impl = [](expected& __with_val, expected& __with_err) { - if constexpr (is_nothrow_move_constructible_v<_Err>) { - _Err __tmp(std::move(__with_err.__unex())); - __with_err.__destroy(); - auto __trans = std::__make_exception_guard([&] { __with_err.__construct(unexpect, std::move(__tmp)); }); - __with_err.__construct(in_place, std::move(__with_val.__val())); - __trans.__complete(); - __with_val.__destroy(); - __with_val.__construct(unexpect, std::move(__tmp)); - } else { - static_assert(is_nothrow_move_constructible_v<_Tp>, - "To provide strong exception guarantee, Tp has to satisfy `is_nothrow_move_constructible_v` so " - "that it can be reverted to the previous state in case an exception is thrown during swap."); - _Tp __tmp(std::move(__with_val.__val())); - __with_val.__destroy(); - auto __trans = std::__make_exception_guard([&] { __with_val.__construct(in_place, std::move(__tmp)); }); - __with_val.__construct(unexpect, std::move(__with_err.__unex())); - __trans.__complete(); - __with_err.__destroy(); - __with_err.__construct(in_place, std::move(__tmp)); - } - }; - - if (this->__has_val()) { - if (__rhs.__has_val()) { - using std::swap; - swap(this->__val(), __rhs.__val()); - } else { - __swap_val_unex_impl(*this, __rhs); - } - } else { - if (__rhs.__has_val()) { - __swap_val_unex_impl(__rhs, *this); - } else { - using std::swap; - swap(this->__unex(), __rhs.__unex()); - } - } - } - - _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y) noexcept(noexcept(__x.swap(__y))) - requires requires { __x.swap(__y); } - { - __x.swap(__y); - } - - // [expected.object.obs], observers - _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - this->__has_val(), "expected::operator-> requires the expected to contain a value"); - return std::addressof(this->__val()); - } - - _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - this->__has_val(), "expected::operator-> requires the expected to contain a value"); - return std::addressof(this->__val()); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const& noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - this->__has_val(), "expected::operator* requires the expected to contain a value"); - return this->__val(); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - this->__has_val(), "expected::operator* requires the expected to contain a value"); - return this->__val(); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& operator*() const&& noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - this->__has_val(), "expected::operator* requires the expected to contain a value"); - return std::move(this->__val()); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator*() && noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - this->__has_val(), "expected::operator* requires the expected to contain a value"); - return std::move(this->__val()); - } - - _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return this->__has_val(); } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__has_val(); } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& value() const& { - static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible"); - if (!this->__has_val()) { - std::__throw_bad_expected_access<_Err>(std::as_const(error())); - } - return this->__val(); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() & { - static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible"); - if (!this->__has_val()) { - std::__throw_bad_expected_access<_Err>(std::as_const(error())); - } - return this->__val(); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& value() const&& { - static_assert(is_copy_constructible_v<_Err> && is_constructible_v<_Err, decltype(std::move(error()))>, - "error_type has to be both copy constructible and constructible from decltype(std::move(error()))"); - if (!this->__has_val()) { - std::__throw_bad_expected_access<_Err>(std::move(error())); - } - return std::move(this->__val()); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() && { - static_assert(is_copy_constructible_v<_Err> && is_constructible_v<_Err, decltype(std::move(error()))>, - "error_type has to be both copy constructible and constructible from decltype(std::move(error()))"); - if (!this->__has_val()) { - std::__throw_bad_expected_access<_Err>(std::move(error())); - } - return std::move(this->__val()); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - !this->__has_val(), "expected::error requires the expected to contain an error"); - return this->__unex(); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - !this->__has_val(), "expected::error requires the expected to contain an error"); - return this->__unex(); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - !this->__has_val(), "expected::error requires the expected to contain an error"); - return std::move(this->__unex()); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - !this->__has_val(), "expected::error requires the expected to contain an error"); - return std::move(this->__unex()); - } - - template <class _Up = remove_cv_t<_Tp>> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& { - static_assert(is_copy_constructible_v<_Tp>, "value_type has to be copy constructible"); - static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type"); - return this->__has_val() ? this->__val() : static_cast<_Tp>(std::forward<_Up>(__v)); - } - - template <class _Up = remove_cv_t<_Tp>> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && { - static_assert(is_move_constructible_v<_Tp>, "value_type has to be move constructible"); - static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type"); - return this->__has_val() ? std::move(this->__val()) : static_cast<_Tp>(std::forward<_Up>(__v)); - } - - template <class _Up = _Err> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) const& { - static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible"); - static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type"); - if (has_value()) - return std::forward<_Up>(__error); - return error(); - } - - template <class _Up = _Err> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) && { - static_assert(is_move_constructible_v<_Err>, "error_type has to be move constructible"); - static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type"); - if (has_value()) - return std::forward<_Up>(__error); - return std::move(error()); - } - - // [expected.void.monadic], monadic - template <class _Func> - requires is_constructible_v<_Err, _Err&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & { - using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>; - static_assert(__is_std_expected<_Up>::value, "The result of f(value()) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Up::error_type, _Err>, - "The result of f(value()) must have the same error_type as this expected"); - if (has_value()) { - return std::invoke(std::forward<_Func>(__f), this->__val()); - } - return _Up(unexpect, error()); - } - - template <class _Func> - requires is_constructible_v<_Err, const _Err&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& { - using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&>>; - static_assert(__is_std_expected<_Up>::value, "The result of f(value()) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Up::error_type, _Err>, - "The result of f(value()) must have the same error_type as this expected"); - if (has_value()) { - return std::invoke(std::forward<_Func>(__f), this->__val()); - } - return _Up(unexpect, error()); - } - - template <class _Func> - requires is_constructible_v<_Err, _Err&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && { - using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&&>>; - static_assert( - __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Up::error_type, _Err>, - "The result of f(std::move(value())) must have the same error_type as this expected"); - if (has_value()) { - return std::invoke(std::forward<_Func>(__f), std::move(this->__val())); - } - return _Up(unexpect, std::move(error())); - } - - template <class _Func> - requires is_constructible_v<_Err, const _Err&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& { - using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&&>>; - static_assert( - __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Up::error_type, _Err>, - "The result of f(std::move(value())) must have the same error_type as this expected"); - if (has_value()) { - return std::invoke(std::forward<_Func>(__f), std::move(this->__val())); - } - return _Up(unexpect, std::move(error())); - } - - template <class _Func> - requires is_constructible_v<_Tp, _Tp&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & { - using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&>>; - static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Gp::value_type, _Tp>, - "The result of f(error()) must have the same value_type as this expected"); - if (has_value()) { - return _Gp(in_place, this->__val()); - } - return std::invoke(std::forward<_Func>(__f), error()); - } - - template <class _Func> - requires is_constructible_v<_Tp, const _Tp&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& { - using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&>>; - static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Gp::value_type, _Tp>, - "The result of f(error()) must have the same value_type as this expected"); - if (has_value()) { - return _Gp(in_place, this->__val()); - } - return std::invoke(std::forward<_Func>(__f), error()); - } - - template <class _Func> - requires is_constructible_v<_Tp, _Tp&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && { - using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&&>>; - static_assert( - __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Gp::value_type, _Tp>, - "The result of f(std::move(error())) must have the same value_type as this expected"); - if (has_value()) { - return _Gp(in_place, std::move(this->__val())); - } - return std::invoke(std::forward<_Func>(__f), std::move(error())); - } - - template <class _Func> - requires is_constructible_v<_Tp, const _Tp&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& { - using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>; - static_assert( - __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Gp::value_type, _Tp>, - "The result of f(std::move(error())) must have the same value_type as this expected"); - if (has_value()) { - return _Gp(in_place, std::move(this->__val())); - } - return std::invoke(std::forward<_Func>(__f), std::move(error())); - } - - template <class _Func> - requires is_constructible_v<_Err, _Err&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & { - using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>; - if (!has_value()) { - return expected<_Up, _Err>(unexpect, error()); - } - if constexpr (!is_void_v<_Up>) { - return expected<_Up, _Err>( - __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), this->__val()); - } else { - std::invoke(std::forward<_Func>(__f), this->__val()); - return expected<_Up, _Err>(); - } - } - - template <class _Func> - requires is_constructible_v<_Err, const _Err&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& { - using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>; - if (!has_value()) { - return expected<_Up, _Err>(unexpect, error()); - } - if constexpr (!is_void_v<_Up>) { - return expected<_Up, _Err>( - __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), this->__val()); - } else { - std::invoke(std::forward<_Func>(__f), this->__val()); - return expected<_Up, _Err>(); - } - } - - template <class _Func> - requires is_constructible_v<_Err, _Err&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && { - using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>; - if (!has_value()) { - return expected<_Up, _Err>(unexpect, std::move(error())); - } - if constexpr (!is_void_v<_Up>) { - return expected<_Up, _Err>( - __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(this->__val())); - } else { - std::invoke(std::forward<_Func>(__f), std::move(this->__val())); - return expected<_Up, _Err>(); - } - } - - template <class _Func> - requires is_constructible_v<_Err, const _Err&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& { - using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>; - if (!has_value()) { - return expected<_Up, _Err>(unexpect, std::move(error())); - } - if constexpr (!is_void_v<_Up>) { - return expected<_Up, _Err>( - __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(this->__val())); - } else { - std::invoke(std::forward<_Func>(__f), std::move(this->__val())); - return expected<_Up, _Err>(); - } - } - - template <class _Func> - requires is_constructible_v<_Tp, _Tp&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & { - using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&>>; - static_assert(__valid_std_unexpected<_Gp>::value, - "The result of f(error()) must be a valid template argument for unexpected"); - if (has_value()) { - return expected<_Tp, _Gp>(in_place, this->__val()); - } - return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error()); - } - - template <class _Func> - requires is_constructible_v<_Tp, const _Tp&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& { - using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&>>; - static_assert(__valid_std_unexpected<_Gp>::value, - "The result of f(error()) must be a valid template argument for unexpected"); - if (has_value()) { - return expected<_Tp, _Gp>(in_place, this->__val()); - } - return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error()); - } - - template <class _Func> - requires is_constructible_v<_Tp, _Tp&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && { - using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&&>>; - static_assert(__valid_std_unexpected<_Gp>::value, - "The result of f(std::move(error())) must be a valid template argument for unexpected"); - if (has_value()) { - return expected<_Tp, _Gp>(in_place, std::move(this->__val())); - } - return expected<_Tp, _Gp>( - __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error())); - } - - template <class _Func> - requires is_constructible_v<_Tp, const _Tp&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& { - using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&&>>; - static_assert(__valid_std_unexpected<_Gp>::value, - "The result of f(std::move(error())) must be a valid template argument for unexpected"); - if (has_value()) { - return expected<_Tp, _Gp>(in_place, std::move(this->__val())); - } - return expected<_Tp, _Gp>( - __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error())); - } - - // [expected.object.eq], equality operators - template <class _T2, class _E2> - _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) - requires(!is_void_v<_T2>) -# if _LIBCPP_STD_VER >= 26 - && requires { - { *__x == *__y } -> __core_convertible_to<bool>; - { __x.error() == __y.error() } -> __core_convertible_to<bool>; - } -# endif - { - if (__x.__has_val() != __y.__has_val()) { - return false; - } else { - if (__x.__has_val()) { - return __x.__val() == __y.__val(); - } else { - return __x.__unex() == __y.__unex(); - } - } - } - - template <class _T2> - _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const _T2& __v) -# if _LIBCPP_STD_VER >= 26 - requires(!__is_std_expected<_T2>::value) && requires { - { *__x == __v } -> __core_convertible_to<bool>; - } -# endif - { - return __x.__has_val() && static_cast<bool>(__x.__val() == __v); - } - - template <class _E2> - _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __e) -# if _LIBCPP_STD_VER >= 26 - requires requires { - { __x.error() == __e.error() } -> __core_convertible_to<bool>; - } -# endif - { - return !__x.__has_val() && static_cast<bool>(__x.__unex() == __e.error()); - } -}; - -template <class _Err> -class __expected_void_base { - struct __empty_t {}; - // use named union because [[no_unique_address]] cannot be applied to an unnamed union, - // also guaranteed elision into a potentially-overlapping subobject is unsettled (and - // it's not clear that it's implementable, given that the function is allowed to clobber - // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107. - union __union_t { - _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) - requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>) - = default; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t(__union_t&&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t(__union_t&&) - requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>) - = default; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(const __union_t&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(__union_t&&) = delete; - - _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(in_place_t) : __empty_() {} - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(unexpect_t, _Args&&... __args) - : __unex_(std::forward<_Args>(__args)...) {} - - template <class _Func, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( - __expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args) - : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} - - _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() - requires(is_trivially_destructible_v<_Err>) - = default; - - // __repr's destructor handles this - _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() - requires(!is_trivially_destructible_v<_Err>) - {} - - _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_; - _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_; - }; - - static constexpr bool __put_flag_in_tail = __fits_in_tail_padding<__union_t, bool>; - static constexpr bool __allow_reusing_expected_tail_padding = !__put_flag_in_tail; - - struct __repr { - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr() = delete; - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(in_place_t __tag) : __union_(in_place, __tag), __has_val_(true) {} - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(unexpect_t __tag, _Args&&... __args) - : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(false) {} - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(std::__expected_construct_unexpected_from_invoke_tag __tag, - _Args&&... __args) - : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(false) {} - - template <class _OtherUnion> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(bool __has_val, _OtherUnion&& __other) - requires(__allow_reusing_expected_tail_padding) - : __union_(__conditional_no_unique_address_invoke_tag{}, - [&] { return __make_union(__has_val, std::forward<_OtherUnion>(__other)); }), - __has_val_(__has_val) {} - - _LIBCPP_HIDE_FROM_ABI constexpr __repr(const __repr&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __repr(const __repr&) - requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>) - = default; - _LIBCPP_HIDE_FROM_ABI constexpr __repr(__repr&&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __repr(__repr&&) - requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>) - = default; - - _LIBCPP_HIDE_FROM_ABI constexpr __repr& operator=(const __repr&) = delete; - _LIBCPP_HIDE_FROM_ABI constexpr __repr& operator=(__repr&&) = delete; - - _LIBCPP_HIDE_FROM_ABI constexpr ~__repr() - requires(is_trivially_destructible_v<_Err>) - = default; - - _LIBCPP_HIDE_FROM_ABI constexpr ~__repr() - requires(!is_trivially_destructible_v<_Err>) - { - __destroy_union_member(); - } - - _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union() - requires(__allow_reusing_expected_tail_padding && is_trivially_destructible_v<_Err>) - { - std::destroy_at(&__union_.__v); - } - - _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union() - requires(__allow_reusing_expected_tail_padding && !is_trivially_destructible_v<_Err>) - { - __destroy_union_member(); - std::destroy_at(&__union_.__v); - } - - _LIBCPP_HIDE_FROM_ABI constexpr void __construct_union(in_place_t) - requires(__allow_reusing_expected_tail_padding) - { - std::construct_at(&__union_.__v, in_place); - __has_val_ = true; - } - - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr void __construct_union(unexpect_t, _Args&&... __args) - requires(__allow_reusing_expected_tail_padding) - { - std::construct_at(&__union_.__v, unexpect, std::forward<_Args>(__args)...); - __has_val_ = false; - } - - private: - template <class> - friend class __expected_void_base; - - _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union_member() - requires(!is_trivially_destructible_v<_Err>) - { - if (!__has_val_) - std::destroy_at(std::addressof(__union_.__v.__unex_)); - } - - template <class _OtherUnion> - _LIBCPP_HIDE_FROM_ABI static constexpr __union_t __make_union(bool __has_val, _OtherUnion&& __other) - requires(__allow_reusing_expected_tail_padding) - { - if (__has_val) - return __union_t(in_place); - else - return __union_t(unexpect, std::forward<_OtherUnion>(__other).__unex_); - } - - _LIBCPP_NO_UNIQUE_ADDRESS __conditional_no_unique_address<__put_flag_in_tail, __union_t> __union_; - _LIBCPP_NO_UNIQUE_ADDRESS bool __has_val_; - }; - - template <class _OtherUnion> - _LIBCPP_HIDE_FROM_ABI static constexpr __repr __make_repr(bool __has_val, _OtherUnion&& __other) - requires(__put_flag_in_tail) - { - if (__has_val) - return __repr(in_place); - else - return __repr(unexpect, std::forward<_OtherUnion>(__other).__unex_); - } - -protected: - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __expected_void_base(_Args&&... __args) - : __repr_(in_place, std::forward<_Args>(__args)...) {} - - template <class _OtherUnion> - _LIBCPP_HIDE_FROM_ABI constexpr explicit __expected_void_base(bool __has_val, _OtherUnion&& __other) - requires(__put_flag_in_tail) - : __repr_(__conditional_no_unique_address_invoke_tag{}, - [&] { return __make_repr(__has_val, std::forward<_OtherUnion>(__other)); }) {} - - _LIBCPP_HIDE_FROM_ABI constexpr void __destroy() { - if constexpr (__put_flag_in_tail) - std::destroy_at(&__repr_.__v); - else - __repr_.__v.__destroy_union(); - } - - template <class _Tag, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr void __construct(_Tag __tag, _Args&&... __args) { - if constexpr (__put_flag_in_tail) - std::construct_at(&__repr_.__v, __tag, std::forward<_Args>(__args)...); - else - __repr_.__v.__construct_union(__tag, std::forward<_Args>(__args)...); - } - - _LIBCPP_HIDE_FROM_ABI constexpr bool __has_val() const { return __repr_.__v.__has_val_; } - _LIBCPP_HIDE_FROM_ABI constexpr __union_t& __union() { return __repr_.__v.__union_.__v; } - _LIBCPP_HIDE_FROM_ABI constexpr const __union_t& __union() const { return __repr_.__v.__union_.__v; } - _LIBCPP_HIDE_FROM_ABI constexpr _Err& __unex() { return __repr_.__v.__union_.__v.__unex_; } - _LIBCPP_HIDE_FROM_ABI constexpr const _Err& __unex() const { return __repr_.__v.__union_.__v.__unex_; } - -private: - _LIBCPP_NO_UNIQUE_ADDRESS __conditional_no_unique_address<__allow_reusing_expected_tail_padding, __repr> __repr_; -}; - -template <class _Tp, class _Err> - requires is_void_v<_Tp> -class expected<_Tp, _Err> : private __expected_void_base<_Err> { - static_assert(__valid_std_unexpected<_Err>::value, - "[expected.void.general] A program that instantiates expected<T, E> with a E that is not a " - "valid argument for unexpected<E> is ill-formed"); - - template <class, class> - friend class expected; - - template <class _Up, class _OtherErr, class _OtherErrQual> - using __can_convert _LIBCPP_NODEBUG = - _And< is_void<_Up>, - is_constructible<_Err, _OtherErrQual>, - _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>, - _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>, - _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>, - _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>>>; - - using __base _LIBCPP_NODEBUG = __expected_void_base<_Err>; - -public: - using value_type = _Tp; - using error_type = _Err; - using unexpected_type = unexpected<_Err>; - - template <class _Up> - using rebind = expected<_Up, error_type>; - - // [expected.void.ctor], constructors - _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept : __base(in_place) {} - - _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete; - - _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) - requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>) - = default; - - _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __rhs) noexcept( - is_nothrow_copy_constructible_v<_Err>) // strengthened - requires(is_copy_constructible_v<_Err> && !is_trivially_copy_constructible_v<_Err>) - : __base(__rhs.__has_val(), __rhs.__union()) {} - - _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&) - requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>) - = default; - - _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __rhs) noexcept(is_nothrow_move_constructible_v<_Err>) - requires(is_move_constructible_v<_Err> && !is_trivially_move_constructible_v<_Err>) - : __base(__rhs.__has_val(), std::move(__rhs.__union())) {} - - template <class _Up, class _OtherErr> - requires __can_convert<_Up, _OtherErr, const _OtherErr&>::value - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>) - expected(const expected<_Up, _OtherErr>& __rhs) noexcept( - is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened - : __base(__rhs.__has_val(), __rhs.__union()) {} - - template <class _Up, class _OtherErr> - requires __can_convert<_Up, _OtherErr, _OtherErr>::value - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>) - expected(expected<_Up, _OtherErr>&& __rhs) noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened - : __base(__rhs.__has_val(), std::move(__rhs.__union())) {} - - template <class _OtherErr> - requires is_constructible_v<_Err, const _OtherErr&> - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>) expected( - const unexpected<_OtherErr>& __unex) noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened - : __base(unexpect, __unex.error()) {} - - template <class _OtherErr> - requires is_constructible_v<_Err, _OtherErr> - _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>) - expected(unexpected<_OtherErr>&& __unex) noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened - : __base(unexpect, std::move(__unex.error())) {} - - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t) noexcept : __base(in_place) {} - - template <class... _Args> - requires is_constructible_v<_Err, _Args...> - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Err, _Args...>) // strengthened - : __base(unexpect, std::forward<_Args>(__args)...) {} - - template <class _Up, class... _Args> - requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... > - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened - : __base(unexpect, __il, std::forward<_Args>(__args)...) {} - -private: - template <class _Func, class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr explicit expected( - __expected_construct_unexpected_from_invoke_tag __tag, _Func&& __f, _Args&&... __args) - : __base(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...) {} - -public: - // [expected.void.dtor], destructor - - _LIBCPP_HIDE_FROM_ABI constexpr ~expected() = default; - -private: - template <class... _Args> - _LIBCPP_HIDE_FROM_ABI constexpr void __reinit_expected(unexpect_t, _Args&&... __args) { - _LIBCPP_ASSERT_INTERNAL(this->__has_val(), "__reinit_expected(unexpect_t, ...) needs value to be set"); - - this->__destroy(); - auto __trans = std::__make_exception_guard([&] { this->__construct(in_place); }); - this->__construct(unexpect, std::forward<_Args>(__args)...); - __trans.__complete(); - } - - _LIBCPP_HIDE_FROM_ABI constexpr void __reinit_expected(in_place_t) { - _LIBCPP_ASSERT_INTERNAL(!this->__has_val(), "__reinit_expected(in_place_t, ...) needs value to be unset"); - - this->__destroy(); - this->__construct(in_place); - } - -public: - // [expected.void.assign], assignment - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete; - - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs) noexcept( - is_nothrow_copy_assignable_v<_Err> && is_nothrow_copy_constructible_v<_Err>) // strengthened - requires(is_copy_assignable_v<_Err> && is_copy_constructible_v<_Err>) - { - if (this->__has_val()) { - if (!__rhs.__has_val()) { - __reinit_expected(unexpect, __rhs.__unex()); - } - } else { - if (__rhs.__has_val()) { - __reinit_expected(in_place); - } else { - this->__unex() = __rhs.__unex(); - } - } - return *this; - } - - _LIBCPP_HIDE_FROM_ABI constexpr expected& - operator=(expected&& __rhs) noexcept(is_nothrow_move_assignable_v<_Err> && is_nothrow_move_constructible_v<_Err>) - requires(is_move_assignable_v<_Err> && is_move_constructible_v<_Err>) - { - if (this->__has_val()) { - if (!__rhs.__has_val()) { - __reinit_expected(unexpect, std::move(__rhs.__unex())); - } - } else { - if (__rhs.__has_val()) { - __reinit_expected(in_place); - } else { - this->__unex() = std::move(__rhs.__unex()); - } - } - return *this; - } - - template <class _OtherErr> - requires(is_constructible_v<_Err, const _OtherErr&> && is_assignable_v<_Err&, const _OtherErr&>) - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) { - if (this->__has_val()) { - __reinit_expected(unexpect, __un.error()); - } else { - this->__unex() = __un.error(); - } - return *this; - } - - template <class _OtherErr> - requires(is_constructible_v<_Err, _OtherErr> && is_assignable_v<_Err&, _OtherErr>) - _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) { - if (this->__has_val()) { - __reinit_expected(unexpect, std::move(__un.error())); - } else { - this->__unex() = std::move(__un.error()); - } - return *this; - } - - _LIBCPP_HIDE_FROM_ABI constexpr void emplace() noexcept { - if (!this->__has_val()) { - __reinit_expected(in_place); - } - } - - // [expected.void.swap], swap - _LIBCPP_HIDE_FROM_ABI constexpr void - swap(expected& __rhs) noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>) - requires(is_swappable_v<_Err> && is_move_constructible_v<_Err>) - { - auto __swap_val_unex_impl = [](expected& __with_val, expected& __with_err) { - // May throw, but will re-engage `__with_val` in that case. - __with_val.__reinit_expected(unexpect, std::move(__with_err.__unex())); - // Will not throw. - __with_err.__reinit_expected(in_place); - }; - - if (this->__has_val()) { - if (!__rhs.__has_val()) { - __swap_val_unex_impl(*this, __rhs); - } - } else { - if (__rhs.__has_val()) { - __swap_val_unex_impl(__rhs, *this); - } else { - using std::swap; - swap(this->__unex(), __rhs.__unex()); - } - } - } - - _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y) noexcept(noexcept(__x.swap(__y))) - requires requires { __x.swap(__y); } - { - __x.swap(__y); - } - - // [expected.void.obs], observers - _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return this->__has_val(); } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__has_val(); } - - _LIBCPP_HIDE_FROM_ABI constexpr void operator*() const noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - this->__has_val(), "expected::operator* requires the expected to contain a value"); - } - - _LIBCPP_HIDE_FROM_ABI constexpr void value() const& { - static_assert(is_copy_constructible_v<_Err>); - if (!this->__has_val()) { - std::__throw_bad_expected_access<_Err>(this->__unex()); - } - } - - _LIBCPP_HIDE_FROM_ABI constexpr void value() && { - static_assert(is_copy_constructible_v<_Err> && is_move_constructible_v<_Err>); - if (!this->__has_val()) { - std::__throw_bad_expected_access<_Err>(std::move(this->__unex())); - } - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - !this->__has_val(), "expected::error requires the expected to contain an error"); - return this->__unex(); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - !this->__has_val(), "expected::error requires the expected to contain an error"); - return this->__unex(); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - !this->__has_val(), "expected::error requires the expected to contain an error"); - return std::move(this->__unex()); - } - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( - !this->__has_val(), "expected::error requires the expected to contain an error"); - return std::move(this->__unex()); - } - - template <class _Up = _Err> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) const& { - static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible"); - static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type"); - if (has_value()) { - return std::forward<_Up>(__error); - } - return error(); - } - - template <class _Up = _Err> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) && { - static_assert(is_move_constructible_v<_Err>, "error_type has to be move constructible"); - static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type"); - if (has_value()) { - return std::forward<_Up>(__error); - } - return std::move(error()); - } - - // [expected.void.monadic], monadic - template <class _Func> - requires is_constructible_v<_Err, _Err&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & { - using _Up = remove_cvref_t<invoke_result_t<_Func>>; - static_assert(__is_std_expected<_Up>::value, "The result of f() must be a specialization of std::expected"); - static_assert( - is_same_v<typename _Up::error_type, _Err>, "The result of f() must have the same error_type as this expected"); - if (has_value()) { - return std::invoke(std::forward<_Func>(__f)); - } - return _Up(unexpect, error()); - } - - template <class _Func> - requires is_constructible_v<_Err, const _Err&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& { - using _Up = remove_cvref_t<invoke_result_t<_Func>>; - static_assert(__is_std_expected<_Up>::value, "The result of f() must be a specialization of std::expected"); - static_assert( - is_same_v<typename _Up::error_type, _Err>, "The result of f() must have the same error_type as this expected"); - if (has_value()) { - return std::invoke(std::forward<_Func>(__f)); - } - return _Up(unexpect, error()); - } - - template <class _Func> - requires is_constructible_v<_Err, _Err&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && { - using _Up = remove_cvref_t<invoke_result_t<_Func>>; - static_assert(__is_std_expected<_Up>::value, "The result of f() must be a specialization of std::expected"); - static_assert( - is_same_v<typename _Up::error_type, _Err>, "The result of f() must have the same error_type as this expected"); - if (has_value()) { - return std::invoke(std::forward<_Func>(__f)); - } - return _Up(unexpect, std::move(error())); - } - - template <class _Func> - requires is_constructible_v<_Err, const _Err&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& { - using _Up = remove_cvref_t<invoke_result_t<_Func>>; - static_assert(__is_std_expected<_Up>::value, "The result of f() must be a specialization of std::expected"); - static_assert( - is_same_v<typename _Up::error_type, _Err>, "The result of f() must have the same error_type as this expected"); - if (has_value()) { - return std::invoke(std::forward<_Func>(__f)); - } - return _Up(unexpect, std::move(error())); - } - - template <class _Func> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & { - using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&>>; - static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Gp::value_type, _Tp>, - "The result of f(error()) must have the same value_type as this expected"); - if (has_value()) { - return _Gp(); - } - return std::invoke(std::forward<_Func>(__f), error()); - } - - template <class _Func> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& { - using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&>>; - static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Gp::value_type, _Tp>, - "The result of f(error()) must have the same value_type as this expected"); - if (has_value()) { - return _Gp(); - } - return std::invoke(std::forward<_Func>(__f), error()); - } - - template <class _Func> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && { - using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&&>>; - static_assert( - __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Gp::value_type, _Tp>, - "The result of f(std::move(error())) must have the same value_type as this expected"); - if (has_value()) { - return _Gp(); - } - return std::invoke(std::forward<_Func>(__f), std::move(error())); - } - - template <class _Func> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& { - using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>; - static_assert( - __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected"); - static_assert(is_same_v<typename _Gp::value_type, _Tp>, - "The result of f(std::move(error())) must have the same value_type as this expected"); - if (has_value()) { - return _Gp(); - } - return std::invoke(std::forward<_Func>(__f), std::move(error())); - } - - template <class _Func> - requires is_constructible_v<_Err, _Err&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & { - using _Up = remove_cv_t<invoke_result_t<_Func>>; - if (!has_value()) { - return expected<_Up, _Err>(unexpect, error()); - } - if constexpr (!is_void_v<_Up>) { - return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f)); - } else { - std::invoke(std::forward<_Func>(__f)); - return expected<_Up, _Err>(); - } - } - - template <class _Func> - requires is_constructible_v<_Err, const _Err&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& { - using _Up = remove_cv_t<invoke_result_t<_Func>>; - if (!has_value()) { - return expected<_Up, _Err>(unexpect, error()); - } - if constexpr (!is_void_v<_Up>) { - return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f)); - } else { - std::invoke(std::forward<_Func>(__f)); - return expected<_Up, _Err>(); - } - } - - template <class _Func> - requires is_constructible_v<_Err, _Err&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && { - using _Up = remove_cv_t<invoke_result_t<_Func>>; - if (!has_value()) { - return expected<_Up, _Err>(unexpect, std::move(error())); - } - if constexpr (!is_void_v<_Up>) { - return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f)); - } else { - std::invoke(std::forward<_Func>(__f)); - return expected<_Up, _Err>(); - } - } - - template <class _Func> - requires is_constructible_v<_Err, const _Err&&> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& { - using _Up = remove_cv_t<invoke_result_t<_Func>>; - if (!has_value()) { - return expected<_Up, _Err>(unexpect, std::move(error())); - } - if constexpr (!is_void_v<_Up>) { - return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f)); - } else { - std::invoke(std::forward<_Func>(__f)); - return expected<_Up, _Err>(); - } - } - - template <class _Func> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & { - using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&>>; - static_assert(__valid_std_unexpected<_Gp>::value, - "The result of f(error()) must be a valid template argument for unexpected"); - if (has_value()) { - return expected<_Tp, _Gp>(); - } - return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error()); - } - - template <class _Func> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& { - using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&>>; - static_assert(__valid_std_unexpected<_Gp>::value, - "The result of f(error()) must be a valid template argument for unexpected"); - if (has_value()) { - return expected<_Tp, _Gp>(); - } - return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error()); - } - - template <class _Func> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && { - using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&&>>; - static_assert(__valid_std_unexpected<_Gp>::value, - "The result of f(std::move(error())) must be a valid template argument for unexpected"); - if (has_value()) { - return expected<_Tp, _Gp>(); - } - return expected<_Tp, _Gp>( - __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error())); - } - - template <class _Func> - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& { - using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&&>>; - static_assert(__valid_std_unexpected<_Gp>::value, - "The result of f(std::move(error())) must be a valid template argument for unexpected"); - if (has_value()) { - return expected<_Tp, _Gp>(); - } - return expected<_Tp, _Gp>( - __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error())); - } - - // [expected.void.eq], equality operators - template <class _T2, class _E2> - requires is_void_v<_T2> - _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) -# if _LIBCPP_STD_VER >= 26 - requires requires { - { __x.error() == __y.error() } -> __core_convertible_to<bool>; - } -# endif - { - if (__x.__has_val() != __y.__has_val()) { - return false; - } else { - return __x.__has_val() || static_cast<bool>(__x.__unex() == __y.__unex()); - } - } - - template <class _E2> - _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __y) -# if _LIBCPP_STD_VER >= 26 - requires requires { - { __x.error() == __y.error() } -> __core_convertible_to<bool>; - } -# endif - { - return !__x.__has_val() && static_cast<bool>(__x.__unex() == __y.error()); - } -}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP_STD_VER >= 23 - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP___EXPECTED_EXPECTED_H diff --git a/third_party/libcxx/include/c++/v1/__expected/unexpect.h b/third_party/libcxx/include/c++/v1/__expected/unexpect.h deleted file mode 100644 index df52787..0000000 --- a/third_party/libcxx/include/c++/v1/__expected/unexpect.h +++ /dev/null @@ -1,32 +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___EXPECTED_UNEXPECT_H -#define _LIBCPP___EXPECTED_UNEXPECT_H - -#include <__config> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -#if _LIBCPP_STD_VER >= 23 - -_LIBCPP_BEGIN_NAMESPACE_STD - -struct unexpect_t { - explicit unexpect_t() = default; -}; - -inline constexpr unexpect_t unexpect{}; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP_STD_VER >= 23 - -#endif // _LIBCPP___EXPECTED_UNEXPECT_H diff --git a/third_party/libcxx/include/c++/v1/__expected/unexpected.h b/third_party/libcxx/include/c++/v1/__expected/unexpected.h deleted file mode 100644 index fc4f52c..0000000 --- a/third_party/libcxx/include/c++/v1/__expected/unexpected.h +++ /dev/null @@ -1,127 +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___EXPECTED_UNEXPECTED_H -#define _LIBCPP___EXPECTED_UNEXPECTED_H - -#include <__config> -#include <__type_traits/conjunction.h> -#include <__type_traits/is_array.h> -#include <__type_traits/is_const.h> -#include <__type_traits/is_constructible.h> -#include <__type_traits/is_nothrow_constructible.h> -#include <__type_traits/is_object.h> -#include <__type_traits/is_same.h> -#include <__type_traits/is_swappable.h> -#include <__type_traits/is_volatile.h> -#include <__type_traits/negation.h> -#include <__type_traits/remove_cvref.h> -#include <__utility/forward.h> -#include <__utility/in_place.h> -#include <__utility/move.h> -#include <__utility/swap.h> -#include <initializer_list> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - -#if _LIBCPP_STD_VER >= 23 - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _Err> -class unexpected; - -template <class _Tp> -struct __is_std_unexpected : false_type {}; - -template <class _Err> -struct __is_std_unexpected<unexpected<_Err>> : true_type {}; - -template <class _Tp> -using __valid_std_unexpected _LIBCPP_NODEBUG = _BoolConstant< // - is_object_v<_Tp> && // - !is_array_v<_Tp> && // - !__is_std_unexpected<_Tp>::value && // - !is_const_v<_Tp> && // - !is_volatile_v<_Tp> // - >; - -template <class _Err> -class unexpected { - static_assert(__valid_std_unexpected<_Err>::value, - "[expected.un.general] states a program that instantiates std::unexpected for a non-object type, an " - "array type, a specialization of unexpected, or a cv-qualified type is ill-formed."); - -public: - _LIBCPP_HIDE_FROM_ABI constexpr unexpected(const unexpected&) = default; - _LIBCPP_HIDE_FROM_ABI constexpr unexpected(unexpected&&) = default; - - template <class _Error = _Err> - requires(!is_same_v<remove_cvref_t<_Error>, unexpected> && // - !is_same_v<remove_cvref_t<_Error>, in_place_t> && // - is_constructible_v<_Err, _Error>) - _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(_Error&& __error) // - noexcept(is_nothrow_constructible_v<_Err, _Error>) // strengthened - : __unex_(std::forward<_Error>(__error)) {} - - template <class... _Args> - requires is_constructible_v<_Err, _Args...> - _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(in_place_t, _Args&&... __args) // - noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened - : __unex_(std::forward<_Args>(__args)...) {} - - template <class _Up, class... _Args> - requires is_constructible_v<_Err, initializer_list<_Up>&, _Args...> - _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) // - noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened - : __unex_(__il, std::forward<_Args>(__args)...) {} - - _LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(const unexpected&) = default; - _LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(unexpected&&) = default; - - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { return __unex_; } - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { return __unex_; } - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { return std::move(__unex_); } - [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { return std::move(__unex_); } - - _LIBCPP_HIDE_FROM_ABI constexpr void swap(unexpected& __other) noexcept(is_nothrow_swappable_v<_Err>) { - static_assert(is_swappable_v<_Err>, "unexpected::swap requires is_swappable_v<E> to be true"); - using std::swap; - swap(__unex_, __other.__unex_); - } - - _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(unexpected& __x, unexpected& __y) noexcept(noexcept(__x.swap(__y))) - requires is_swappable_v<_Err> - { - __x.swap(__y); - } - - template <class _Err2> - _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const unexpected& __x, const unexpected<_Err2>& __y) { - return __x.__unex_ == __y.error(); - } - -private: - _Err __unex_; -}; - -template <class _Err> -unexpected(_Err) -> unexpected<_Err>; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP_STD_VER >= 23 - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP___EXPECTED_UNEXPECTED_H |