[libcxx-commits] [libcxx] [libc++] Granularize `<optional>` (PR #206644)
A. Jiang via libcxx-commits
libcxx-commits at lists.llvm.org
Tue Jun 30 18:31:42 PDT 2026
================
@@ -330,1367 +296,13 @@ namespace std {
_LIBCPP_PUSH_MACROS
# include <__undef_macros>
-namespace std // purposefully not using versioning namespace
-{
-
-class _LIBCPP_EXPORTED_FROM_ABI bad_optional_access : public exception {
-public:
- _LIBCPP_HIDE_FROM_ABI bad_optional_access() _NOEXCEPT = default;
- _LIBCPP_HIDE_FROM_ABI bad_optional_access(const bad_optional_access&) _NOEXCEPT = default;
- _LIBCPP_HIDE_FROM_ABI bad_optional_access& operator=(const bad_optional_access&) _NOEXCEPT = default;
- // Get the key function ~bad_optional_access() into the dylib
- ~bad_optional_access() _NOEXCEPT override;
- [[__nodiscard__]] const char* what() const _NOEXCEPT override;
-};
-
-} // namespace std
-
# if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD
-[[noreturn]] inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_optional_access() {
-# if _LIBCPP_HAS_EXCEPTIONS
- throw bad_optional_access();
-# else
- _LIBCPP_VERBOSE_ABORT("bad_optional_access was thrown in -fno-exceptions mode");
-# endif
-}
-
-struct nullopt_t {
- struct __secret_tag {
- explicit __secret_tag() = default;
- };
- _LIBCPP_HIDE_FROM_ABI constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
-};
-
-inline constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}};
-
-struct __optional_construct_from_invoke_tag {};
-
-template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
-struct __optional_destruct_base;
-
-template <class _Tp>
-struct __optional_destruct_base<_Tp, false> {
- typedef _Tp value_type;
- static_assert(is_object_v<value_type>, "instantiation of optional with a non-object type is undefined behavior");
- union {
- char __null_state_;
- remove_cv_t<value_type> __val_;
- };
- bool __engaged_;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__optional_destruct_base() {
- if (__engaged_)
- __val_.~value_type();
- }
-
- _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {}
-
- template <class... _Args>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
- : __val_(std::forward<_Args>(__args)...), __engaged_(true) {}
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Fp, class... _Args>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_destruct_base(
- __optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
- : __val_(std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)), __engaged_(true) {}
-# endif
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept {
- if (__engaged_) {
- __val_.~value_type();
- __engaged_ = false;
- }
- }
-};
-
-template <class _Tp>
-struct __optional_destruct_base<_Tp, true> {
- typedef _Tp value_type;
- static_assert(is_object_v<value_type>, "instantiation of optional with a non-object type is undefined behavior");
- union {
- char __null_state_;
- remove_cv_t<value_type> __val_;
- };
- bool __engaged_;
-
- _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {}
-
- template <class... _Args>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
- : __val_(std::forward<_Args>(__args)...), __engaged_(true) {}
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Fp, class... _Args>
- _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base(
- __optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
- : __val_(std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)), __engaged_(true) {}
-# endif
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept {
- if (__engaged_) {
- __engaged_ = false;
- }
- }
-};
-
-template <class _Tp, bool = is_reference<_Tp>::value>
-struct __optional_storage_base : __optional_destruct_base<_Tp> {
- using __base _LIBCPP_NODEBUG = __optional_destruct_base<_Tp>;
- using value_type = _Tp;
- using __base::__base;
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__engaged_; }
-
- _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() & noexcept { return this->__val_; }
- _LIBCPP_HIDE_FROM_ABI constexpr const value_type& __get() const& noexcept { return this->__val_; }
- _LIBCPP_HIDE_FROM_ABI constexpr value_type&& __get() && noexcept { return std::move(this->__val_); }
- _LIBCPP_HIDE_FROM_ABI constexpr const value_type&& __get() const&& noexcept { return std::move(this->__val_); }
-
- template <class... _Args>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_Args&&... __args) {
- _LIBCPP_ASSERT_INTERNAL(!has_value(), "__construct called for engaged __optional_storage");
- std::__construct_at(std::addressof(this->__val_), std::forward<_Args>(__args)...);
- this->__engaged_ = true;
- }
-
- template <class _That>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt) {
- if (__opt.has_value())
- __construct(std::forward<_That>(__opt).__get());
- }
-
- template <class _That>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt) {
- if (this->__engaged_ == __opt.has_value()) {
- if (this->__engaged_)
- static_cast<_Tp&>(this->__val_) = std::forward<_That>(__opt).__get();
- } else {
- if (this->__engaged_)
- this->reset();
- else
- __construct(std::forward<_That>(__opt).__get());
- }
- }
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
- __swap(__optional_storage_base& __rhs) noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>) {
- using std::swap;
- if (this->has_value() == __rhs.has_value()) {
- if (this->has_value())
- swap(this->__get(), __rhs.__get());
- } else {
- if (this->has_value()) {
- __rhs.__construct(std::move(this->__get()));
- this->reset();
- } else {
- this->__construct(std::move(__rhs.__get()));
- __rhs.reset();
- }
- }
- }
-
- // [optional.observe]
- _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp const> operator->() const noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
- return std::addressof(this->__get());
- }
-
- _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> operator->() noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
- return std::addressof(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const& noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator*() && noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return std::move(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& operator*() const&& noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return std::move(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& value() const& {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() & {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() && {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return std::move(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp const&& value() const&& {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return std::move(this->__get());
- }
-};
-
-template <class _Tp>
-struct __optional_storage_base<_Tp, true> {
- using value_type = _Tp;
- using __raw_type _LIBCPP_NODEBUG = remove_reference_t<_Tp>;
- __raw_type* __value_;
-
- _LIBCPP_HIDE_FROM_ABI constexpr __optional_storage_base() noexcept : __value_(nullptr) {}
-
- template <class _Up>
- _LIBCPP_HIDE_FROM_ABI constexpr void __convert_init_ref_val(_Up&& __val) {
- _Tp& __r(std::forward<_Up>(__val));
- __value_ = std::addressof(__r);
- }
-
- template <class _UArg>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) {
- static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
- "Attempted to construct a reference element in optional from a "
- "possible temporary");
- __convert_init_ref_val(std::forward<_UArg>(__uarg));
- }
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Fp, class... _Args>
- constexpr __optional_storage_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) {
- __convert_init_ref_val(std::forward<invoke_result_t<_Fp, _Args...>>(
- std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)));
- }
-# endif
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept { __value_ = nullptr; }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __value_ != nullptr; }
-
- _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() const noexcept { return *__value_; }
-
- template <class _UArg>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_UArg&& __val) {
- static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
- "Attempted to construct a reference element in tuple from a "
- "possible temporary");
- __convert_init_ref_val(std::forward<_UArg>(__val));
- }
-
- template <class _That>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt) {
- if (__opt.has_value())
- __construct(std::forward<_That>(__opt).__get());
- }
-
- template <class _That>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt) {
- if (has_value() == __opt.has_value()) {
- if (has_value())
- *__value_ = std::forward<_That>(__opt).__get();
- } else {
- if (has_value())
- reset();
- else
- __construct(std::forward<_That>(__opt).__get());
- }
- }
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __swap(__optional_storage_base& __rhs) noexcept {
- std::swap(__value_, __rhs.__value_);
- }
-
- // [optional.ref.observe]
- _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> operator->() const noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
- return std::addressof(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() const noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() const {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return this->__get();
- }
-};
-
-template <class _Tp, bool = is_trivially_copy_constructible_v<_Tp>>
-struct __optional_copy_base : __optional_storage_base<_Tp> {
- using __optional_storage_base<_Tp>::__optional_storage_base;
-};
-
-template <class _Tp>
-struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp> {
- using __optional_storage_base<_Tp>::__optional_storage_base;
-
- _LIBCPP_HIDE_FROM_ABI __optional_copy_base() = default;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_base(const __optional_copy_base& __opt) {
- this->__construct_from(__opt);
- }
-
- _LIBCPP_HIDE_FROM_ABI __optional_copy_base(__optional_copy_base&&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_copy_base& operator=(const __optional_copy_base&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_copy_base& operator=(__optional_copy_base&&) = default;
-};
-
-template <class _Tp, bool = is_trivially_move_constructible_v<_Tp>>
-struct __optional_move_base : __optional_copy_base<_Tp> {
- using __optional_copy_base<_Tp>::__optional_copy_base;
-};
-
-template <class _Tp>
-struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp> {
- using value_type = _Tp;
- using __optional_copy_base<_Tp>::__optional_copy_base;
-
- _LIBCPP_HIDE_FROM_ABI __optional_move_base() = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_base(const __optional_move_base&) = default;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
- __optional_move_base(__optional_move_base&& __opt) noexcept(is_nothrow_move_constructible_v<value_type>) {
- this->__construct_from(std::move(__opt));
- }
-
- _LIBCPP_HIDE_FROM_ABI __optional_move_base& operator=(const __optional_move_base&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_base& operator=(__optional_move_base&&) = default;
-};
-
-template <class _Tp,
- bool = (is_trivially_destructible_v<_Tp> && is_trivially_copy_constructible_v<_Tp> &&
- is_trivially_copy_assignable_v<_Tp>)>
-struct __optional_copy_assign_base : __optional_move_base<_Tp> {
- using __optional_move_base<_Tp>::__optional_move_base;
-};
-
-template <class _Tp>
-struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp> {
- using __optional_move_base<_Tp>::__optional_move_base;
-
- _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base() = default;
- _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_assign_base&
- operator=(const __optional_copy_assign_base& __opt) {
- this->__assign_from(__opt);
- return *this;
- }
-
- _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
-};
-
-template <class _Tp,
- bool = (is_trivially_destructible_v<_Tp> && is_trivially_move_constructible_v<_Tp> &&
- is_trivially_move_assignable_v<_Tp>)>
-struct __optional_move_assign_base : __optional_copy_assign_base<_Tp> {
- using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
-};
-
-template <class _Tp>
-struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp> {
- using value_type = _Tp;
- using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
-
- _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base() = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base(__optional_move_assign_base&&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_move_assign_base&
- operator=(__optional_move_assign_base&& __opt) noexcept(
- is_nothrow_move_assignable_v<value_type> && is_nothrow_move_constructible_v<value_type>) {
- this->__assign_from(std::move(__opt));
- return *this;
- }
-};
-
-template <class _Tp>
-using __optional_sfinae_ctor_base_t _LIBCPP_NODEBUG =
- __sfinae_ctor_base< is_copy_constructible<_Tp>::value, is_move_constructible<_Tp>::value >;
-
-template <class _Tp>
-using __optional_sfinae_assign_base_t _LIBCPP_NODEBUG =
- __sfinae_assign_base< (is_copy_constructible_v<_Tp> && is_copy_assignable_v<_Tp>),
- (is_move_constructible_v<_Tp> && is_move_assignable_v<_Tp>)>;
-
-template <class _Tp>
-class optional;
-
-# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
-template <class _Tp>
-constexpr bool ranges::enable_view<optional<_Tp>> = true;
-
-template <class _Tp>
-constexpr range_format format_kind<optional<_Tp>> = range_format::disabled;
-
-template <class _Tp>
-constexpr bool ranges::enable_borrowed_range<optional<_Tp&>> = true;
-
-# endif
-
-# if _LIBCPP_STD_VER >= 20
-
-template <class _Tp>
-concept __is_derived_from_optional = requires(const _Tp& __t) { []<class _Up>(const optional<_Up>&) {}(__t); };
-
-# endif // _LIBCPP_STD_VER >= 20
-
-template <class _Tp>
-struct __is_std_optional : false_type {};
-template <class _Tp>
-struct __is_std_optional<optional<_Tp>> : true_type {};
-
-# if _LIBCPP_STD_VER < 26
-template <class _Tp>
-inline constexpr bool __is_valid_optional_contained_type = is_object_v<_Tp>;
-# else
-template <class _Tp>
-inline constexpr bool __is_valid_optional_contained_type = is_object_v<_Tp> || is_lvalue_reference_v<_Tp>;
-# endif
-
-template <class _Tp>
-struct __optional_iterator_base : __optional_move_assign_base<_Tp> {
- using __optional_move_assign_base<_Tp>::__optional_move_assign_base;
-};
-
-# if _LIBCPP_STD_VER >= 26
-template <class _Tp>
-struct __optional_iterator_base<_Tp&> : __optional_storage_base<_Tp&> {
- using __optional_storage_base<_Tp&>::__optional_storage_base;
-};
-
-# if _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
-
-template <class _Tp>
- requires is_object_v<_Tp>
-struct __optional_iterator_base<_Tp> : __optional_move_assign_base<_Tp> {
-private:
- using __pointer _LIBCPP_NODEBUG = add_pointer_t<_Tp>;
- using __const_pointer _LIBCPP_NODEBUG = add_pointer_t<const _Tp>;
-
-public:
- using __optional_move_assign_base<_Tp>::__optional_move_assign_base;
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- using iterator = __bounded_iter<__pointer>;
- using const_iterator = __bounded_iter<__const_pointer>;
-# else
- using iterator = __capacity_aware_iterator<__pointer, optional<_Tp>, 1>;
- using const_iterator = __capacity_aware_iterator<__const_pointer, optional<_Tp>, 1>;
-# endif
-
- // [optional.iterators], iterator support
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() noexcept {
- auto* __ptr = std::addressof(this->__get());
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
-# else
- return std::__make_capacity_aware_iterator<__pointer, optional<_Tp>, 1>(__ptr);
-# endif
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const noexcept {
- auto* __ptr = std::addressof(this->__get());
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
-# else
- return std::__make_capacity_aware_iterator<__const_pointer, optional<_Tp>, 1>(__ptr);
-# endif
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator end() noexcept {
- return begin() + (this->has_value() ? 1 : 0);
- }
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept {
- return begin() + (this->has_value() ? 1 : 0);
- }
-};
-
-template <class _Tp>
- requires(is_object_v<_Tp> && !__is_unbounded_array_v<_Tp>)
-struct __optional_iterator_base<_Tp&> : __optional_storage_base<_Tp&> {
-private:
- using __pointer _LIBCPP_NODEBUG = add_pointer_t<_Tp>;
-
-public:
- using __optional_storage_base<_Tp&>::__optional_storage_base;
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- using iterator = __bounded_iter<__pointer>;
-# else
- using iterator = __capacity_aware_iterator<__pointer, optional<_Tp&>, 1>;
-# endif
-
- // [optional.ref.iterators], iterator support
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const noexcept {
- auto* __ptr = this->has_value() ? std::addressof(this->__get()) : nullptr;
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
-# else
- return std::__make_capacity_aware_iterator<__pointer, optional<_Tp&>, 1>(__ptr);
-# endif
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const noexcept {
- return begin() + (this->has_value() ? 1 : 0);
- }
-};
-
-# endif // _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
-# endif // _LIBCPP_STD_VER >= 26
-
-template <class _Tp>
-class _LIBCPP_DECLSPEC_EMPTY_BASES optional
- : public __optional_iterator_base<_Tp>,
- private __optional_sfinae_ctor_base_t<_Tp>,
- private __optional_sfinae_assign_base_t<_Tp> {
- using __base _LIBCPP_NODEBUG = __optional_iterator_base<_Tp>;
-
-public:
- using value_type = __libcpp_remove_reference_t<_Tp>;
-
- using __trivially_relocatable _LIBCPP_NODEBUG =
- conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, optional, void>;
-
-private:
- static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
- static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
-# if _LIBCPP_STD_VER >= 26
- static_assert(!is_rvalue_reference_v<_Tp>, "instantiation of optional with an rvalue reference type is ill-formed");
-# else
- static_assert(!is_reference_v<_Tp>, "instantiation of optional with a reference type is ill-formed");
-# endif
- static_assert(is_destructible_v<_Tp>, "instantiation of optional with a non-destructible type is ill-formed");
- static_assert(!is_array_v<_Tp>, "instantiation of optional with an array type is ill-formed");
-
- // LWG2756: conditionally explicit conversion from _Up
- struct _CheckOptionalArgsConstructor {
- template <class _Up>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
- return is_constructible_v<_Tp, _Up&&> && is_convertible_v<_Up&&, _Tp>;
- }
-
- template <class _Up>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
- return is_constructible_v<_Tp, _Up&&> && !is_convertible_v<_Up&&, _Tp>;
- }
- };
- template <class _Up>
- using _CheckOptionalArgsCtor _LIBCPP_NODEBUG =
- _If< _IsNotSame<__remove_cvref_t<_Up>, in_place_t>::value && _IsNotSame<__remove_cvref_t<_Up>, optional>::value &&
- (!is_same_v<remove_cv_t<_Tp>, bool> || !__is_std_optional<__remove_cvref_t<_Up>>::value),
- _CheckOptionalArgsConstructor,
- __check_tuple_constructor_fail >;
- template <class _QualUp>
- struct _CheckOptionalLikeConstructor {
- template <class _Up, class _Opt = optional<_Up>>
- using __check_constructible_from_opt _LIBCPP_NODEBUG =
- _Or< is_constructible<_Tp, _Opt&>,
- is_constructible<_Tp, _Opt const&>,
- is_constructible<_Tp, _Opt&&>,
- is_constructible<_Tp, _Opt const&&>,
- is_convertible<_Opt&, _Tp>,
- is_convertible<_Opt const&, _Tp>,
- is_convertible<_Opt&&, _Tp>,
- is_convertible<_Opt const&&, _Tp> >;
- template <class _Up, class _Opt = optional<_Up>>
- using __check_assignable_from_opt _LIBCPP_NODEBUG =
- _Or< is_assignable<_Tp&, _Opt&>,
- is_assignable<_Tp&, _Opt const&>,
- is_assignable<_Tp&, _Opt&&>,
- is_assignable<_Tp&, _Opt const&&> >;
- template <class _Up, class _QUp = _QualUp>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
- return is_convertible<_QUp, _Tp>::value &&
- (is_same_v<remove_cv_t<_Tp>, bool> || !__check_constructible_from_opt<_Up>::value);
- }
- template <class _Up, class _QUp = _QualUp>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
- return !is_convertible<_QUp, _Tp>::value &&
- (is_same_v<remove_cv_t<_Tp>, bool> || !__check_constructible_from_opt<_Up>::value);
- }
- template <class _Up, class _QUp = _QualUp>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_assign() {
- // Construction and assignability of _QUp to _Tp has already been
- // checked.
- return !__check_constructible_from_opt<_Up>::value && !__check_assignable_from_opt<_Up>::value;
- }
- };
-
- template <class _Up, class _QualUp>
- using _CheckOptionalLikeCtor _LIBCPP_NODEBUG =
- _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp> >::value,
- _CheckOptionalLikeConstructor<_QualUp>,
- __check_tuple_constructor_fail >;
- template <class _Up, class _QualUp>
- using _CheckOptionalLikeAssign _LIBCPP_NODEBUG =
- _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp>, is_assignable<_Tp&, _QualUp> >::value,
- _CheckOptionalLikeConstructor<_QualUp>,
- __check_tuple_constructor_fail >;
-
-public:
- _LIBCPP_HIDE_FROM_ABI constexpr optional() noexcept {}
- _LIBCPP_HIDE_FROM_ABI constexpr optional(const optional&) = default;
- _LIBCPP_HIDE_FROM_ABI constexpr optional(optional&&) = default;
- _LIBCPP_HIDE_FROM_ABI constexpr optional(nullopt_t) noexcept {}
-
- template <class _InPlaceT,
- class... _Args,
- enable_if_t<_And<_IsSame<_InPlaceT, in_place_t>, is_constructible<_Tp, _Args...>>::value, int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_InPlaceT, _Args&&... __args)
- : __base(in_place, std::forward<_Args>(__args)...) {}
-
- template <class _Up, class... _Args, enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
- : __base(in_place, __il, std::forward<_Args>(__args)...) {}
-
- template <class _Up = _Tp, enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened
- : __base(in_place, std::forward<_Up>(__v)) {}
-
- template <class _Up = remove_cv_t<_Tp>,
- enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v) noexcept(
- is_nothrow_constructible_v<_Tp, _Up>) // strengthened
- : __base(in_place, std::forward<_Up>(__v)) {}
-
- // LWG2756: conditionally explicit conversion from const optional<_Up>&
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v) {
- this->__construct_from(__v);
- }
-
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v) {
- this->__construct_from(__v);
- }
-
- // LWG2756: conditionally explicit conversion from optional<_Up>&&
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v) {
- this->__construct_from(std::move(__v));
- }
-
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v) {
- this->__construct_from(std::move(__v));
- }
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Tag,
- class _Fp,
- class... _Args,
- enable_if_t<_IsSame<_Tag, __optional_construct_from_invoke_tag>::value, int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Tag, _Fp&& __f, _Args&&... __args)
- : __base(__optional_construct_from_invoke_tag{}, std::forward<_Fp>(__f), std::forward<_Args>(__args)...) {}
-# endif
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(nullopt_t) noexcept {
- reset();
- return *this;
- }
-
- _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(const optional&) = default;
- _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(optional&&) = default;
-
- // LWG2756
- template <class _Up = remove_cv_t<_Tp>,
- enable_if_t<_And<_IsNotSame<__remove_cvref_t<_Up>, optional>,
- _Or<_IsNotSame<__remove_cvref_t<_Up>, _Tp>, _Not<is_scalar<_Tp>>>,
- is_constructible<_Tp, _Up>,
- is_assignable<_Tp&, _Up>>::value,
- int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(_Up&& __v) {
- if (this->has_value())
- this->__get() = std::forward<_Up>(__v);
- else
- this->__construct(std::forward<_Up>(__v));
- return *this;
- }
-
- // LWG2756
- template <class _Up, enable_if_t<_CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(const optional<_Up>& __v) {
- this->__assign_from(__v);
- return *this;
- }
-
- // LWG2756
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_assign<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(optional<_Up>&& __v) {
- this->__assign_from(std::move(__v));
- return *this;
- }
-
- template <class... _Args, enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
- reset();
- this->__construct(std::forward<_Args>(__args)...);
- return this->__get();
- }
-
- template <class _Up, class... _Args, enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
- reset();
- this->__construct(__il, std::forward<_Args>(__args)...);
- return this->__get();
- }
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
- swap(optional& __opt) noexcept((is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>)) {
- this->__swap(__opt);
- }
-
- using __base::operator*;
- using __base::operator->;
-
- _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return has_value(); }
-
- using __base::__get;
- using __base::has_value;
- using __base::value;
-
- 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>, "optional<T>::value_or: T must be copy constructible");
- static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
- return this->has_value() ? this->__get() : 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>, "optional<T>::value_or: T must be move constructible");
- static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
- return this->has_value() ? std::move(this->__get()) : static_cast<_Tp>(std::forward<_Up>(__v));
- }
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
- using _Up = invoke_result_t<_Func, _Tp&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(value()) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), value());
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
- using _Up = invoke_result_t<_Func, const _Tp&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(value()) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), value());
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
- using _Up = invoke_result_t<_Func, _Tp&&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(std::move(value())) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), std::move(value()));
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
- using _Up = invoke_result_t<_Func, const _Tp&&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(std::move(value())) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), std::move(value()));
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
- using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
- static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(
- __is_valid_optional_contained_type<_Up>, "Result of f(value()) should be a valid contained type for optional");
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
- return optional<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
- using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>;
- static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(
- __is_valid_optional_contained_type<_Up>, "Result of f(value()) should be a valid contained type for optional");
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
- return optional<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
- using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>;
- static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
- static_assert(
- __is_valid_optional_contained_type<_Up>, "Result of f(value()) should be a valid contained type for optional");
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
- return optional<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
- using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>;
- static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
- static_assert(
- __is_valid_optional_contained_type<_Up>, "Result of f(value()) should be a valid contained type for optional");
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
- return optional<_Up>();
- }
-
- template <invocable _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const&
- requires is_copy_constructible_v<_Tp>
- {
- static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
- "Result of f() should be the same type as this optional");
- if (*this)
- return *this;
- return std::forward<_Func>(__f)();
- }
-
- template <invocable _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) &&
- requires is_move_constructible_v<_Tp>
- {
- static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
- "Result of f() should be the same type as this optional");
- if (*this)
- return std::move(*this);
- return std::forward<_Func>(__f)();
- }
-# endif // _LIBCPP_STD_VER >= 23
-
- using __base::reset;
-};
-
-# if _LIBCPP_STD_VER >= 26
-template <class _Tp>
-class optional<_Tp&> : public __optional_iterator_base<_Tp&> {
- using __base _LIBCPP_NODEBUG = __optional_iterator_base<_Tp&>;
-
- template <class _Up, class _QualUp>
- static constexpr bool __check_optionalU_ctor =
- !is_same_v<remove_cv_t<_Tp>, optional<_Up>> && !is_same_v<_Tp&, _Up> && is_constructible_v<_Tp&, _QualUp>;
- static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
- static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
-
-public:
- using value_type = _Tp;
-
- constexpr optional() noexcept = default;
- constexpr optional(nullopt_t) noexcept {}
- constexpr optional(const optional&) noexcept = default;
-
- template <class _Arg>
- requires(is_constructible_v<_Tp&, _Arg> && !reference_constructs_from_temporary_v<_Tp&, _Arg>)
- constexpr explicit optional(in_place_t, _Arg&& __arg) : __base(in_place, std::forward<_Arg>(__arg)) {}
-
- template <class _Up>
- requires(!is_same_v<remove_cvref_t<_Up>, optional> && !is_same_v<remove_cvref_t<_Up>, in_place_t> &&
- is_constructible_v<_Tp&, _Up> && !reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr explicit(!is_convertible_v<_Up, _Tp&>) optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>)
- : __base(in_place, std::forward<_Up>(__v)) {}
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, _Up&> && !reference_constructs_from_temporary_v<_Tp&, _Up&>)
- constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
- optional(optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up&>) {
- this->__construct_from(__rhs);
- }
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, const _Up&> && !reference_constructs_from_temporary_v<_Tp&, const _Up&>)
- constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
- optional(const optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, const _Up&>) {
- this->__construct_from(__rhs);
- }
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, _Up> && !reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr explicit(!is_convertible_v<_Up, _Tp&>)
- optional(optional<_Up>&& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) {
- this->__construct_from(std::move(__rhs));
- }
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, const _Up> && !reference_constructs_from_temporary_v<_Tp&, const _Up>)
- constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
- optional(const optional<_Up>&& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, const _Up>) {
- this->__construct_from(std::move(__rhs));
- }
-
- template <class _Tag, class _Fp, class... _Args>
- requires(is_same_v<_Tag, __optional_construct_from_invoke_tag>)
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Tag, _Fp&& __f, _Args&&... __args)
- : __base(__optional_construct_from_invoke_tag{}, std::forward<_Fp>(__f), std::forward<_Args>(__args)...) {}
-
- // deleted overloads
-
- template <class _Up>
- requires(!is_same_v<remove_cvref_t<_Up>, optional> && !is_same_v<remove_cvref_t<_Up>, in_place_t> &&
- is_constructible_v<_Tp&, _Up> && reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr explicit(!is_convertible_v<_Up, _Tp&>)
- optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) = delete;
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, _Up&> && reference_constructs_from_temporary_v<_Tp&, _Up&>)
- constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
- optional(optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up&>) = delete;
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, const _Up&> && reference_constructs_from_temporary_v<_Tp&, const _Up&>)
- constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
- optional(const optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, const _Up&>) = delete;
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, _Up> && reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr explicit(!is_convertible_v<_Up, _Tp&>)
- optional(optional<_Up>&& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) = delete;
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, const _Up> && reference_constructs_from_temporary_v<_Tp&, const _Up>)
- constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
- optional(const optional<_Up>&& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, const _Up>) = delete;
-
- constexpr ~optional() = default;
-
- using __base::__get;
-
- _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(nullopt_t) noexcept {
- reset();
- return *this;
- }
-
- constexpr optional& operator=(const optional&) noexcept = default;
-
- template <class _Up>
- requires(is_constructible_v<_Tp&, _Up> && !reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr _Tp& emplace(_Up&& __u) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) {
- this->__construct(std::forward<_Up>(__u));
-
- return this->__get();
- }
-
- constexpr void swap(optional& __rhs) noexcept { this->__swap(__rhs); }
-
- using __base::operator->;
- using __base::operator*;
-
- constexpr explicit operator bool() const noexcept { return has_value(); }
-
- using __base::has_value;
- using __base::value;
-
- template <class _Up = remove_cv_t<_Tp>>
- requires(!is_array_v<_Tp> && is_object_v<_Tp>)
- [[nodiscard]] constexpr decay_t<_Tp> value_or(_Up&& __v) const {
- using _XTp = remove_cv_t<_Tp>;
- static_assert(is_constructible_v<_XTp, _Tp&>, "optional<T&>::value_or: remove_cv_t<T> must be constructible");
- static_assert(is_convertible_v<_Up, _XTp>, "optional<T&>::value_or: U must be convertible to remove_cv_t<T>");
- return this->has_value() ? this->__get() : static_cast<_XTp>(std::forward<_Up>(__v));
- }
-
- template <class _Func>
- [[nodiscard]] constexpr auto and_then(_Func&& __f) const {
- using _Up = invoke_result_t<_Func, _Tp&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(value()) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), value());
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] constexpr optional<remove_cv_t<invoke_result_t<_Func, _Tp&>>> transform(_Func&& __f) const {
- using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
- static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(
- __is_valid_optional_contained_type<_Up>, "Result of f(value()) should be a valid contained type for optional");
-
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
- return optional<_Up>();
- }
-
- template <invocable _Func>
- [[nodiscard]] constexpr optional or_else(_Func&& __f) const {
- static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
- "Result of f() should be the same type as this optional");
- if (*this)
- return *this;
- return std::forward<_Func>(__f)();
- }
-
- using __base::reset;
-};
-# endif
-
template <class _Tp>
optional(_Tp) -> optional<_Tp>;
-// [optional.relops] Relational operators
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (static_cast<bool>(__x) != static_cast<bool>(__y))
- return false;
- if (!static_cast<bool>(__x))
- return true;
- return *__x == *__y;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (static_cast<bool>(__x) != static_cast<bool>(__y))
- return true;
- if (!static_cast<bool>(__x))
- return false;
- return *__x != *__y;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (!static_cast<bool>(__y))
- return false;
- if (!static_cast<bool>(__x))
- return true;
- return *__x < *__y;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (!static_cast<bool>(__x))
- return false;
- if (!static_cast<bool>(__y))
- return true;
- return *__x > *__y;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (!static_cast<bool>(__x))
- return true;
- if (!static_cast<bool>(__y))
- return false;
- return *__x <= *__y;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (!static_cast<bool>(__y))
- return true;
- if (!static_cast<bool>(__x))
- return false;
- return *__x >= *__y;
-}
-
-# if _LIBCPP_STD_VER >= 20
-
-template <class _Tp, three_way_comparable_with<_Tp> _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
-operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (__x && __y)
- return *__x <=> *__y;
- return __x.has_value() <=> __y.has_value();
-}
-
-# endif // _LIBCPP_STD_VER >= 20
-
-// [optional.nullops] Comparison with nullopt
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, nullopt_t) noexcept {
- return !static_cast<bool>(__x);
-}
-
-# if _LIBCPP_STD_VER <= 17
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(nullopt_t, const optional<_Tp>& __x) noexcept {
- return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, nullopt_t) noexcept {
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(nullopt_t, const optional<_Tp>& __x) noexcept {
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>&, nullopt_t) noexcept {
- return false;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(nullopt_t, const optional<_Tp>& __x) noexcept {
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, nullopt_t) noexcept {
- return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(nullopt_t, const optional<_Tp>&) noexcept {
- return true;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, nullopt_t) noexcept {
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(nullopt_t, const optional<_Tp>&) noexcept {
- return false;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>&, nullopt_t) noexcept {
- return true;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(nullopt_t, const optional<_Tp>& __x) noexcept {
- return !static_cast<bool>(__x);
-}
-
-# else // _LIBCPP_STD_VER <= 17
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept {
- return __x.has_value() <=> false;
-}
-
-# endif // _LIBCPP_STD_VER <= 17
-
-// [optional.comp.with.t] Comparison with T
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x == __v;
- return false;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v == *__x;
- return false;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x != __v;
- return true;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v != *__x;
- return true;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x < __v;
- return true;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v < *__x;
- return false;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x <= __v;
- return true;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v <= *__x;
- return false;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x > __v;
- return false;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v > *__x;
- return true;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x >= __v;
- return false;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v >= *__x;
- return true;
-}
-
-# if _LIBCPP_STD_VER >= 20
-
-template <class _Tp, class _Up>
- requires(!__is_derived_from_optional<_Up>) && three_way_comparable_with<_Tp, _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
-operator<=>(const optional<_Tp>& __x, const _Up& __v) {
- return __x.has_value() ? *__x <=> __v : strong_ordering::less;
-}
-
-# endif // _LIBCPP_STD_VER >= 20
-
-template <class _Tp,
- enable_if_t<(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)
-# if _LIBCPP_STD_VER >= 26
- || is_reference_v<_Tp>
-# endif
- ,
- int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) {
- __x.swap(__y);
-}
-
struct __make_optional_barrier_tag {
----------------
frederick-vs-ja wrote:
I think there're some reasons.
1. We don't call `make_optional` within libc++ itself.
2. If we want to use `make_optional` somewhere, `optional` (including `optional<T&>`) should also be made available. As a result, other stuffs in `<optional>` (comparison operators, `swap`, and some specializations) should also be provided to avoid potential ODR violation. I.e. the potential `<__optional/make_optional.h>` will need to provide all contents in `<optional>` except for transitive includes.
But I'm not sure whether we should still granularize `make_optional` as a convention.
https://github.com/llvm/llvm-project/pull/206644
More information about the libcxx-commits
mailing list