// -*- 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_OPTIONAL #define _LIBCPP_OPTIONAL /* optional synopsis // C++1z namespace std { // 23.6.3, optional for object types template <class T> class optional; // 23.6.4, no-value state indicator struct nullopt_t{see below }; inline constexpr nullopt_t nullopt(unspecified ); // 23.6.5, class bad_optional_access class bad_optional_access; // 23.6.6, relational operators template <class T, class U> constexpr bool operator==(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator!=(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator<(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator>(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator<=(const optional<T>&, const optional<U>&); template <class T, class U> constexpr bool operator>=(const optional<T>&, const optional<U>&); // 23.6.7 comparison with nullopt template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept; template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept; template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept; template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept; template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept; template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept; template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept; template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept; template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept; template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept; template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept; template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept; // 23.6.8, comparison with T template <class T, class U> constexpr bool operator==(const optional<T>&, const U&); template <class T, class U> constexpr bool operator==(const T&, const optional<U>&); template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&); template <class T, class U> constexpr bool operator!=(const T&, const optional<U>&); template <class T, class U> constexpr bool operator<(const optional<T>&, const U&); template <class T, class U> constexpr bool operator<(const T&, const optional<U>&); template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&); template <class T, class U> constexpr bool operator<=(const T&, const optional<U>&); template <class T, class U> constexpr bool operator>(const optional<T>&, const U&); template <class T, class U> constexpr bool operator>(const T&, const optional<U>&); template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&); template <class T, class U> constexpr bool operator>=(const T&, const optional<U>&); // 23.6.9, specialized algorithms template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below ); // constexpr in C++20 template <class T> constexpr optional<see below > make_optional(T&&); template <class T, class... Args> constexpr optional<T> make_optional(Args&&... args); template <class T, class U, class... Args> constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args); // 23.6.10, hash support template <class T> struct hash; template <class T> struct hash<optional<T>>; template <class T> class optional { public: using value_type = T; // 23.6.3.1, constructors constexpr optional() noexcept; constexpr optional(nullopt_t) noexcept; optional(const optional &); optional(optional &&) noexcept(see below); template <class... Args> constexpr explicit optional(in_place_t, Args &&...); template <class U, class... Args> constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...); template <class U = T> constexpr EXPLICIT optional(U &&); template <class U> EXPLICIT optional(const optional<U> &); // constexpr in C++20 template <class U> EXPLICIT optional(optional<U> &&); // constexpr in C++20 // 23.6.3.2, destructor ~optional(); // constexpr in C++20 // 23.6.3.3, assignment optional &operator=(nullopt_t) noexcept; // constexpr in C++20 optional &operator=(const optional &); // constexpr in C++20 optional &operator=(optional &&) noexcept(see below); // constexpr in C++20 template <class U = T> optional &operator=(U &&); // constexpr in C++20 template <class U> optional &operator=(const optional<U> &); // constexpr in C++20 template <class U> optional &operator=(optional<U> &&); // constexpr in C++20 template <class... Args> T& emplace(Args &&...); // constexpr in C++20 template <class U, class... Args> T& emplace(initializer_list<U>, Args &&...); // constexpr in C++20 // 23.6.3.4, swap void swap(optional &) noexcept(see below ); // constexpr in C++20 // 23.6.3.5, observers constexpr T const *operator->() const; constexpr T *operator->(); constexpr T const &operator*() const &; constexpr T &operator*() &; constexpr T &&operator*() &&; constexpr const T &&operator*() const &&; constexpr explicit operator bool() const noexcept; constexpr bool has_value() const noexcept; constexpr T const &value() const &; constexpr T &value() &; constexpr T &&value() &&; constexpr const T &&value() const &&; template <class U> constexpr T value_or(U &&) const &; template <class U> constexpr T value_or(U &&) &&; // [optional.monadic], monadic operations template<class F> constexpr auto and_then(F&& f) &; // since C++23 template<class F> constexpr auto and_then(F&& f) &&; // since C++23 template<class F> constexpr auto and_then(F&& f) const&; // since C++23 template<class F> constexpr auto and_then(F&& f) const&&; // since C++23 template<class F> constexpr auto transform(F&& f) &; // since C++23 template<class F> constexpr auto transform(F&& f) &&; // since C++23 template<class F> constexpr auto transform(F&& f) const&; // since C++23 template<class F> constexpr auto transform(F&& f) const&&; // since C++23 template<class F> constexpr optional or_else(F&& f) &&; // since C++23 template<class F> constexpr optional or_else(F&& f) const&; // since C++23 // 23.6.3.6, modifiers void reset() noexcept; // constexpr in C++20 private: T *val; // exposition only }; template<class T> optional(T) -> optional<T>; } // namespace std */ #include <__assert> // all public C++ headers provide the assertion handler #include <__availability> #include <__concepts/invocable.h> #include <__config> #include <__utility/in_place.h> #include <__utility/swap.h> #include <compare> #include <functional> #include <initializer_list> #include <new> #include <stdexcept> #include <type_traits> #include <version> // TODO: remove these headers #include <__memory/allocator_arg_t.h> #include <__memory/uses_allocator.h> #include <typeinfo> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif namespace std // purposefully not using versioning namespace { class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access : public exception { public: // Get the key function ~bad_optional_access() into the dylib virtual ~bad_optional_access() _NOEXCEPT; virtual const char* what() const _NOEXCEPT; }; } // namespace std #if _LIBCPP_STD_VER > 14 _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS void __throw_bad_optional_access() { #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_optional_access(); #else _VSTD::abort(); #endif } struct nullopt_t { struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; }; _LIBCPP_INLINE_VISIBILITY 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_; value_type __val_; }; bool __engaged_; _LIBCPP_INLINE_VISIBILITY /* _LIBCPP_CONSTEXPR_AFTER_CXX17 */ ~__optional_destruct_base() { if (__engaged_) __val_.~value_type(); } _LIBCPP_INLINE_VISIBILITY constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {} template <class... _Args> _LIBCPP_INLINE_VISIBILITY constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) : __val_(_VSTD::forward<_Args>(__args)...), __engaged_(true) {} #if _LIBCPP_STD_VER > 20 template <class _Fp, class... _Args> _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) : __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {} #endif _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 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_; value_type __val_; }; bool __engaged_; _LIBCPP_INLINE_VISIBILITY constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {} template <class... _Args> _LIBCPP_INLINE_VISIBILITY constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) : __val_(_VSTD::forward<_Args>(__args)...), __engaged_(true) {} #if _LIBCPP_STD_VER > 20 template <class _Fp, class... _Args> _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) : __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {} #endif _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 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 = __optional_destruct_base<_Tp>; using value_type = _Tp; using __base::__base; _LIBCPP_INLINE_VISIBILITY constexpr bool has_value() const noexcept { return this->__engaged_; } _LIBCPP_INLINE_VISIBILITY constexpr value_type& __get() & noexcept { return this->__val_; } _LIBCPP_INLINE_VISIBILITY constexpr const value_type& __get() const& noexcept { return this->__val_; } _LIBCPP_INLINE_VISIBILITY constexpr value_type&& __get() && noexcept { return _VSTD::move(this->__val_); } _LIBCPP_INLINE_VISIBILITY constexpr const value_type&& __get() const&& noexcept { return _VSTD::move(this->__val_); } template <class... _Args> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_Args&&... __args) { _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); #if _LIBCPP_STD_VER > 17 _VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...); #else ::new ((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); #endif this->__engaged_ = true; } template <class _That> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt) { if (__opt.has_value()) __construct(_VSTD::forward<_That>(__opt).__get()); } template <class _That> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt) { if (this->__engaged_ == __opt.has_value()) { if (this->__engaged_) this->__val_ = _VSTD::forward<_That>(__opt).__get(); } else { if (this->__engaged_) this->reset(); else __construct(_VSTD::forward<_That>(__opt).__get()); } } }; // optional<T&> is currently required ill-formed, however it may to be in the // future. For this reason it has already been implemented to ensure we can // make the change in an ABI compatible manner. template <class _Tp> struct __optional_storage_base<_Tp, true> { using value_type = _Tp; using __raw_type = remove_reference_t<_Tp>; __raw_type* __value_; template <class _Up> static constexpr bool __can_bind_reference() { using _RawUp = typename remove_reference<_Up>::type; using _UpPtr = _RawUp*; using _RawTp = typename remove_reference<_Tp>::type; using _TpPtr = _RawTp*; using _CheckLValueArg = integral_constant<bool, (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value) || is_same<_RawUp, reference_wrapper<_RawTp>>::value || is_same<_RawUp, reference_wrapper<typename remove_const<_RawTp>::type>>::value >; return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value) || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value); } _LIBCPP_INLINE_VISIBILITY constexpr __optional_storage_base() noexcept : __value_(nullptr) {} template <class _UArg> _LIBCPP_INLINE_VISIBILITY constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) : __value_(_VSTD::addressof(__uarg)) { static_assert(__can_bind_reference<_UArg>(), "Attempted to construct a reference element in tuple from a " "possible temporary"); } _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept { __value_ = nullptr; } _LIBCPP_INLINE_VISIBILITY constexpr bool has_value() const noexcept { return __value_ != nullptr; } _LIBCPP_INLINE_VISIBILITY constexpr value_type& __get() const& noexcept { return *__value_; } _LIBCPP_INLINE_VISIBILITY constexpr value_type&& __get() const&& noexcept { return _VSTD::forward<value_type>(*__value_); } template <class _UArg> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_UArg&& __val) { _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); static_assert(__can_bind_reference<_UArg>(), "Attempted to construct a reference element in tuple from a " "possible temporary"); __value_ = _VSTD::addressof(__val); } template <class _That> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt) { if (__opt.has_value()) __construct(_VSTD::forward<_That>(__opt).__get()); } template <class _That> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt) { if (has_value() == __opt.has_value()) { if (has_value()) *__value_ = _VSTD::forward<_That>(__opt).__get(); } else { if (has_value()) reset(); else __construct(_VSTD::forward<_That>(__opt).__get()); } } }; template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value> 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_INLINE_VISIBILITY __optional_copy_base() = default; _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_base(const __optional_copy_base& __opt) { this->__construct_from(__opt); } _LIBCPP_INLINE_VISIBILITY __optional_copy_base(__optional_copy_base&&) = default; _LIBCPP_INLINE_VISIBILITY __optional_copy_base& operator=(const __optional_copy_base&) = default; _LIBCPP_INLINE_VISIBILITY __optional_copy_base& operator=(__optional_copy_base&&) = default; }; template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value> 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_INLINE_VISIBILITY __optional_move_base() = default; _LIBCPP_INLINE_VISIBILITY __optional_move_base(const __optional_move_base&) = default; _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_base(__optional_move_base&& __opt) noexcept(is_nothrow_move_constructible_v<value_type>) { this->__construct_from(_VSTD::move(__opt)); } _LIBCPP_INLINE_VISIBILITY __optional_move_base& operator=(const __optional_move_base&) = default; _LIBCPP_INLINE_VISIBILITY __optional_move_base& operator=(__optional_move_base&&) = default; }; template <class _Tp, bool = is_trivially_destructible<_Tp>::value && is_trivially_copy_constructible<_Tp>::value && is_trivially_copy_assignable<_Tp>::value> 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_INLINE_VISIBILITY __optional_copy_assign_base() = default; _LIBCPP_INLINE_VISIBILITY __optional_copy_assign_base(const __optional_copy_assign_base&) = default; _LIBCPP_INLINE_VISIBILITY __optional_copy_assign_base(__optional_copy_assign_base&&) = default; _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt) { this->__assign_from(__opt); return *this; } _LIBCPP_INLINE_VISIBILITY __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default; }; template <class _Tp, bool = is_trivially_destructible<_Tp>::value && is_trivially_move_constructible<_Tp>::value && is_trivially_move_assignable<_Tp>::value> 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_INLINE_VISIBILITY __optional_move_assign_base() = default; _LIBCPP_INLINE_VISIBILITY __optional_move_assign_base(const __optional_move_assign_base& __opt) = default; _LIBCPP_INLINE_VISIBILITY __optional_move_assign_base(__optional_move_assign_base&&) = default; _LIBCPP_INLINE_VISIBILITY __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default; _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __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(_VSTD::move(__opt)); return *this; } }; template <class _Tp> using __optional_sfinae_ctor_base_t = __sfinae_ctor_base< is_copy_constructible<_Tp>::value, is_move_constructible<_Tp>::value >; template <class _Tp> using __optional_sfinae_assign_base_t = __sfinae_assign_base< (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value), (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value) >; template<class _Tp> class optional; template <class _Tp> struct __is_std_optional : false_type {}; template <class _Tp> struct __is_std_optional<optional<_Tp>> : true_type {}; template <class _Tp> class optional : private __optional_move_assign_base<_Tp> , private __optional_sfinae_ctor_base_t<_Tp> , private __optional_sfinae_assign_base_t<_Tp> { using __base = __optional_move_assign_base<_Tp>; public: using value_type = _Tp; private: // Disable the reference extension using this static assert. static_assert(!is_same_v<__uncvref_t<value_type>, in_place_t>, "instantiation of optional with in_place_t is ill-formed"); static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed"); static_assert(!is_reference_v<value_type>, "instantiation of optional with a reference type is ill-formed"); static_assert(is_destructible_v<value_type>, "instantiation of optional with a non-destructible type is ill-formed"); static_assert(!is_array_v<value_type>, "instantiation of optional with an array type is ill-formed"); // LWG2756: conditionally explicit conversion from _Up struct _CheckOptionalArgsConstructor { template <class _Up> static constexpr bool __enable_implicit = is_constructible_v<_Tp, _Up&&> && is_convertible_v<_Up&&, _Tp>; template <class _Up> static constexpr bool __enable_explicit = is_constructible_v<_Tp, _Up&&> && !is_convertible_v<_Up&&, _Tp>; }; template <class _Up> using _CheckOptionalArgsCtor = _If< _IsNotSame<__uncvref_t<_Up>, in_place_t>::value && _IsNotSame<__uncvref_t<_Up>, optional>::value, _CheckOptionalArgsConstructor, __check_tuple_constructor_fail >; template <class _QualUp> struct _CheckOptionalLikeConstructor { template <class _Up, class _Opt = optional<_Up>> using __check_constructible_from_opt = _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 = _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> static constexpr bool __enable_implicit = is_convertible<_QUp, _Tp>::value && !__check_constructible_from_opt<_Up>::value; template <class _Up, class _QUp = _QualUp> static constexpr bool __enable_explicit = !is_convertible<_QUp, _Tp>::value && !__check_constructible_from_opt<_Up>::value; template <class _Up, class _QUp = _QualUp> static constexpr bool __enable_assign = !__check_constructible_from_opt<_Up>::value && !__check_assignable_from_opt<_Up>::value; }; template <class _Up, class _QualUp> using _CheckOptionalLikeCtor = _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp> >::value, _CheckOptionalLikeConstructor<_QualUp>, __check_tuple_constructor_fail >; template <class _Up, class _QualUp> using _CheckOptionalLikeAssign = _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp>, is_assignable<_Tp&, _QualUp> >::value, _CheckOptionalLikeConstructor<_QualUp>, __check_tuple_constructor_fail >; public: _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} _LIBCPP_INLINE_VISIBILITY constexpr optional(const optional&) = default; _LIBCPP_INLINE_VISIBILITY constexpr optional(optional&&) = default; _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} template <class _InPlaceT, class... _Args, class = enable_if_t< _And< _IsSame<_InPlaceT, in_place_t>, is_constructible<value_type, _Args...> >::value > > _LIBCPP_INLINE_VISIBILITY constexpr explicit optional(_InPlaceT, _Args&&... __args) : __base(in_place, _VSTD::forward<_Args>(__args)...) {} template <class _Up, class... _Args, class = enable_if_t< is_constructible_v<value_type, initializer_list<_Up>&, _Args...>> > _LIBCPP_INLINE_VISIBILITY constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} template <class _Up = value_type, enable_if_t< _CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up> , int> = 0> _LIBCPP_INLINE_VISIBILITY constexpr optional(_Up&& __v) : __base(in_place, _VSTD::forward<_Up>(__v)) {} template <class _Up, enable_if_t< _CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up> , int> = 0> _LIBCPP_INLINE_VISIBILITY constexpr explicit optional(_Up&& __v) : __base(in_place, _VSTD::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_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 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_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 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_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 optional(optional<_Up>&& __v) { this->__construct_from(_VSTD::move(__v)); } template <class _Up, enable_if_t< _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up> , int> = 0> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(optional<_Up>&& __v) { this->__construct_from(_VSTD::move(__v)); } #if _LIBCPP_STD_VER > 20 template<class _Fp, class... _Args> _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) : __base(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...) { } #endif _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& operator=(nullopt_t) noexcept { reset(); return *this; } _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default; _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default; // LWG2756 template <class _Up = value_type, class = enable_if_t< _And< _IsNotSame<__uncvref_t<_Up>, optional>, _Or< _IsNotSame<__uncvref_t<_Up>, value_type>, _Not<is_scalar<value_type>> >, is_constructible<value_type, _Up>, is_assignable<value_type&, _Up> >::value> > _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& operator=(_Up&& __v) { if (this->has_value()) this->__get() = _VSTD::forward<_Up>(__v); else this->__construct(_VSTD::forward<_Up>(__v)); return *this; } // LWG2756 template <class _Up, enable_if_t< _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up> , int> = 0> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 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_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& operator=(optional<_Up>&& __v) { this->__assign_from(_VSTD::move(__v)); return *this; } template <class... _Args, class = enable_if_t < is_constructible_v<value_type, _Args...> > > _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp & emplace(_Args&&... __args) { reset(); this->__construct(_VSTD::forward<_Args>(__args)...); return this->__get(); } template <class _Up, class... _Args, class = enable_if_t < is_constructible_v<value_type, initializer_list<_Up>&, _Args...> > > _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp & emplace(initializer_list<_Up> __il, _Args&&... __args) { reset(); this->__construct(__il, _VSTD::forward<_Args>(__args)...); return this->__get(); } _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(optional& __opt) noexcept(is_nothrow_move_constructible_v<value_type> && is_nothrow_swappable_v<value_type>) { if (this->has_value() == __opt.has_value()) { using _VSTD::swap; if (this->has_value()) swap(this->__get(), __opt.__get()); } else { if (this->has_value()) { __opt.__construct(_VSTD::move(this->__get())); reset(); } else { this->__construct(_VSTD::move(__opt.__get())); __opt.reset(); } } } _LIBCPP_INLINE_VISIBILITY constexpr add_pointer_t<value_type const> operator->() const { _LIBCPP_ASSERT(this->has_value(), "optional operator-> called on a disengaged value"); return _VSTD::addressof(this->__get()); } _LIBCPP_INLINE_VISIBILITY constexpr add_pointer_t<value_type> operator->() { _LIBCPP_ASSERT(this->has_value(), "optional operator-> called on a disengaged value"); return _VSTD::addressof(this->__get()); } _LIBCPP_INLINE_VISIBILITY constexpr const value_type& operator*() const& noexcept { _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value"); return this->__get(); } _LIBCPP_INLINE_VISIBILITY constexpr value_type& operator*() & noexcept { _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value"); return this->__get(); } _LIBCPP_INLINE_VISIBILITY constexpr value_type&& operator*() && noexcept { _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value"); return _VSTD::move(this->__get()); } _LIBCPP_INLINE_VISIBILITY constexpr const value_type&& operator*() const&& noexcept { _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value"); return _VSTD::move(this->__get()); } _LIBCPP_INLINE_VISIBILITY constexpr explicit operator bool() const noexcept { return has_value(); } using __base::has_value; using __base::__get; _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type const& value() const& { if (!this->has_value()) __throw_bad_optional_access(); return this->__get(); } _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type& value() & { if (!this->has_value()) __throw_bad_optional_access(); return this->__get(); } _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type&& value() && { if (!this->has_value()) __throw_bad_optional_access(); return _VSTD::move(this->__get()); } _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type const&& value() const&& { if (!this->has_value()) __throw_bad_optional_access(); return _VSTD::move(this->__get()); } template <class _Up> _LIBCPP_INLINE_VISIBILITY constexpr value_type value_or(_Up&& __v) const& { static_assert(is_copy_constructible_v<value_type>, "optional<T>::value_or: T must be copy constructible"); static_assert(is_convertible_v<_Up, value_type>, "optional<T>::value_or: U must be convertible to T"); return this->has_value() ? this->__get() : static_cast<value_type>(_VSTD::forward<_Up>(__v)); } template <class _Up> _LIBCPP_INLINE_VISIBILITY constexpr value_type value_or(_Up&& __v) && { static_assert(is_move_constructible_v<value_type>, "optional<T>::value_or: T must be move constructible"); static_assert(is_convertible_v<_Up, value_type>, "optional<T>::value_or: U must be convertible to T"); return this->has_value() ? _VSTD::move(this->__get()) : static_cast<value_type>(_VSTD::forward<_Up>(__v)); } #if _LIBCPP_STD_VER > 20 template<class _Func> _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto and_then(_Func&& __f) & { using _Up = invoke_result_t<_Func, value_type&>; static_assert(__is_std_optional<remove_cvref_t<_Up>>::value, "Result of f(value()) must be a specialization of std::optional"); if (*this) return _VSTD::invoke(_VSTD::forward<_Func>(__f), value()); return remove_cvref_t<_Up>(); } template<class _Func> _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto and_then(_Func&& __f) const& { using _Up = invoke_result_t<_Func, const value_type&>; static_assert(__is_std_optional<remove_cvref_t<_Up>>::value, "Result of f(value()) must be a specialization of std::optional"); if (*this) return _VSTD::invoke(_VSTD::forward<_Func>(__f), value()); return remove_cvref_t<_Up>(); } template<class _Func> _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto and_then(_Func&& __f) && { using _Up = invoke_result_t<_Func, value_type&&>; 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 _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value())); return remove_cvref_t<_Up>(); } template<class _Func> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& { using _Up = invoke_result_t<_Func, const value_type&&>; 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 _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value())); return remove_cvref_t<_Up>(); } template<class _Func> _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto transform(_Func&& __f) & { using _Up = remove_cv_t<invoke_result_t<_Func, value_type&>>; 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_object_v<_Up>, "Result of f(value()) should be an object type"); if (*this) return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), value()); return optional<_Up>(); } template<class _Func> _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto transform(_Func&& __f) const& { using _Up = remove_cv_t<invoke_result_t<_Func, const value_type&>>; 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_object_v<_Up>, "Result of f(value()) should be an object type"); if (*this) return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), value()); return optional<_Up>(); } template<class _Func> _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto transform(_Func&& __f) && { using _Up = remove_cv_t<invoke_result_t<_Func, value_type&&>>; 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_object_v<_Up>, "Result of f(std::move(value())) should be an object type"); if (*this) return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), _VSTD::move(value())); return optional<_Up>(); } template<class _Func> _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto transform(_Func&& __f) const&& { using _Up = remove_cvref_t<invoke_result_t<_Func, const value_type&&>>; 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_object_v<_Up>, "Result of f(std::move(value())) should be an object type"); if (*this) return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), _VSTD::move(value())); return optional<_Up>(); } template<invocable _Func> _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const& requires is_copy_constructible_v<value_type> { 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 _VSTD::forward<_Func>(__f)(); } template<invocable _Func> _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) && requires is_move_constructible_v<value_type> { 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 _VSTD::move(*this); return _VSTD::forward<_Func>(__f)(); } #endif // _LIBCPP_STD_VER > 20 using __base::reset; }; #if _LIBCPP_STD_VER >= 17 template<class _Tp> optional(_Tp) -> optional<_Tp>; #endif // Comparisons between optionals template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() == declval<const _Up&>()), bool>, 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> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() != declval<const _Up&>()), bool>, 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> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() < declval<const _Up&>()), bool>, 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> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() > declval<const _Up&>()), bool>, 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> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() <= declval<const _Up&>()), bool>, 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> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() >= declval<const _Up&>()), bool>, 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; } // Comparisons with nullopt template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator==(const optional<_Tp>& __x, nullopt_t) noexcept { return !static_cast<bool>(__x); } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator==(nullopt_t, const optional<_Tp>& __x) noexcept { return !static_cast<bool>(__x); } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator!=(const optional<_Tp>& __x, nullopt_t) noexcept { return static_cast<bool>(__x); } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator!=(nullopt_t, const optional<_Tp>& __x) noexcept { return static_cast<bool>(__x); } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator<(const optional<_Tp>&, nullopt_t) noexcept { return false; } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator<(nullopt_t, const optional<_Tp>& __x) noexcept { return static_cast<bool>(__x); } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator<=(const optional<_Tp>& __x, nullopt_t) noexcept { return !static_cast<bool>(__x); } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator<=(nullopt_t, const optional<_Tp>&) noexcept { return true; } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator>(const optional<_Tp>& __x, nullopt_t) noexcept { return static_cast<bool>(__x); } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator>(nullopt_t, const optional<_Tp>&) noexcept { return false; } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator>=(const optional<_Tp>&, nullopt_t) noexcept { return true; } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr bool operator>=(nullopt_t, const optional<_Tp>& __x) noexcept { return !static_cast<bool>(__x); } // Comparisons with T template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() == declval<const _Up&>()), bool>, bool > operator==(const optional<_Tp>& __x, const _Up& __v) { return static_cast<bool>(__x) ? *__x == __v : false; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() == declval<const _Up&>()), bool>, bool > operator==(const _Tp& __v, const optional<_Up>& __x) { return static_cast<bool>(__x) ? __v == *__x : false; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() != declval<const _Up&>()), bool>, bool > operator!=(const optional<_Tp>& __x, const _Up& __v) { return static_cast<bool>(__x) ? *__x != __v : true; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() != declval<const _Up&>()), bool>, bool > operator!=(const _Tp& __v, const optional<_Up>& __x) { return static_cast<bool>(__x) ? __v != *__x : true; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() < declval<const _Up&>()), bool>, bool > operator<(const optional<_Tp>& __x, const _Up& __v) { return static_cast<bool>(__x) ? *__x < __v : true; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() < declval<const _Up&>()), bool>, bool > operator<(const _Tp& __v, const optional<_Up>& __x) { return static_cast<bool>(__x) ? __v < *__x : false; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() <= declval<const _Up&>()), bool>, bool > operator<=(const optional<_Tp>& __x, const _Up& __v) { return static_cast<bool>(__x) ? *__x <= __v : true; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() <= declval<const _Up&>()), bool>, bool > operator<=(const _Tp& __v, const optional<_Up>& __x) { return static_cast<bool>(__x) ? __v <= *__x : false; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() > declval<const _Up&>()), bool>, bool > operator>(const optional<_Tp>& __x, const _Up& __v) { return static_cast<bool>(__x) ? *__x > __v : false; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() > declval<const _Up&>()), bool>, bool > operator>(const _Tp& __v, const optional<_Up>& __x) { return static_cast<bool>(__x) ? __v > *__x : true; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() >= declval<const _Up&>()), bool>, bool > operator>=(const optional<_Tp>& __x, const _Up& __v) { return static_cast<bool>(__x) ? *__x >= __v : false; } template <class _Tp, class _Up> _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< is_convertible_v<decltype(declval<const _Tp&>() >= declval<const _Up&>()), bool>, bool > operator>=(const _Tp& __v, const optional<_Up>& __x) { return static_cast<bool>(__x) ? __v >= *__x : true; } template <class _Tp> inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 enable_if_t< is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, void > swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template <class _Tp> _LIBCPP_INLINE_VISIBILITY constexpr optional<decay_t<_Tp>> make_optional(_Tp&& __v) { return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v)); } template <class _Tp, class... _Args> _LIBCPP_INLINE_VISIBILITY constexpr optional<_Tp> make_optional(_Args&&... __args) { return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...); } template <class _Tp, class _Up, class... _Args> _LIBCPP_INLINE_VISIBILITY constexpr optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) { return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...); } template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash< __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>> > { #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) _LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type; _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type; #endif _LIBCPP_INLINE_VISIBILITY size_t operator()(const optional<_Tp>& __opt) const { return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0; } }; _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_OPTIONAL