| // -*- C++ -*- |
| //===-------------------------- optional ----------------------------------===// |
| // |
| // 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 ); |
| 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> |
| constexpr EXPLICIT optional(const optional<U> &); |
| template <class U> |
| constexpr EXPLICIT optional(optional<U> &&); |
| |
| // 23.6.3.2, destructor |
| ~optional(); |
| |
| // 23.6.3.3, assignment |
| optional &operator=(nullopt_t) noexcept; |
| 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 &&); |
| template <class U> optional &operator=(const optional<U> &); |
| template <class U> optional &operator=(optional<U> &&); |
| template <class... Args> T& emplace(Args &&...); |
| template <class U, class... Args> |
| T& emplace(initializer_list<U>, Args &&...); |
| |
| // 23.6.3.4, swap |
| void swap(optional &) noexcept(see below ); |
| |
| // 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 &&) &&; |
| |
| // 23.6.3.6, modifiers |
| void reset() noexcept; |
| |
| private: |
| T *val; // exposition only |
| }; |
| |
| template<class T> |
| optional(T) -> optional<T>; |
| |
| } // namespace std |
| |
| */ |
| |
| #include <__config> |
| #include <__debug> |
| #include <__functional_base> |
| #include <functional> |
| #include <initializer_list> |
| #include <new> |
| #include <stdexcept> |
| #include <type_traits> |
| #include <utility> |
| #include <version> |
| |
| #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| #pragma GCC system_header |
| #endif |
| |
| _LIBCPP_PUSH_MACROS |
| #include <__undef_macros> |
| |
| |
| 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; |
| }; |
| |
| } // 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 {} |
| }; |
| |
| _LIBCPP_INLINE_VAR constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_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 |
| ~__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) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| 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) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| 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 |
| void __construct(_Args&&... __args) |
| { |
| _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); |
| ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); |
| this->__engaged_ = true; |
| } |
| |
| template <class _That> |
| _LIBCPP_INLINE_VISIBILITY |
| void __construct_from(_That&& __opt) |
| { |
| if (__opt.has_value()) |
| __construct(_VSTD::forward<_That>(__opt).__get()); |
| } |
| |
| template <class _That> |
| _LIBCPP_INLINE_VISIBILITY |
| 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 |
| 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 |
| 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 |
| void __construct_from(_That&& __opt) |
| { |
| if (__opt.has_value()) |
| __construct(_VSTD::forward<_That>(__opt).__get()); |
| } |
| |
| template <class _That> |
| _LIBCPP_INLINE_VISIBILITY |
| 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 |
| __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 |
| __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 |
| __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 |
| __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 |
| : 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() { |
| return is_constructible_v<_Tp, _Up&&> && |
| is_convertible_v<_Up&&, _Tp>; |
| } |
| |
| template <class _Up> |
| static constexpr bool __enable_explicit() { |
| return is_constructible_v<_Tp, _Up&&> && |
| !is_convertible_v<_Up&&, _Tp>; |
| } |
| }; |
| template <class _Up> |
| using _CheckOptionalArgsCtor = conditional_t< |
| !is_same_v<__uncvref_t<_Up>, in_place_t> && |
| !is_same_v<__uncvref_t<_Up>, optional>, |
| _CheckOptionalArgsConstructor, |
| __check_tuple_constructor_fail |
| >; |
| template <class _QualUp> |
| struct _CheckOptionalLikeConstructor { |
| template <class _Up, class _Opt = optional<_Up>> |
| using __check_constructible_from_opt = __lazy_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 = __lazy_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() { |
| return is_convertible<_QUp, _Tp>::value && |
| !__check_constructible_from_opt<_Up>::value; |
| } |
| template <class _Up, class _QUp = _QualUp> |
| static constexpr bool __enable_explicit() { |
| return !is_convertible<_QUp, _Tp>::value && |
| !__check_constructible_from_opt<_Up>::value; |
| } |
| template <class _Up, class _QUp = _QualUp> |
| 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 = conditional_t< |
| __lazy_and< |
| __lazy_not<is_same<_Up, _Tp>>, |
| is_constructible<_Tp, _QualUp> |
| >::value, |
| _CheckOptionalLikeConstructor<_QualUp>, |
| __check_tuple_constructor_fail |
| >; |
| template <class _Up, class _QualUp> |
| using _CheckOptionalLikeAssign = conditional_t< |
| __lazy_and< |
| __lazy_not<is_same<_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< |
| __lazy_and< |
| is_same<_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 |
| 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 |
| 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 |
| 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 |
| explicit optional(optional<_Up>&& __v) |
| { |
| this->__construct_from(_VSTD::move(__v)); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| 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 |
| <__lazy_and< |
| integral_constant<bool, |
| !is_same_v<__uncvref_t<_Up>, optional> && |
| !(is_same_v<_Up, value_type> && is_scalar_v<value_type>) |
| >, |
| is_constructible<value_type, _Up>, |
| is_assignable<value_type&, _Up> |
| >::value> |
| > |
| _LIBCPP_INLINE_VISIBILITY |
| 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 |
| 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 |
| 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 |
| _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 |
| _Tp & |
| emplace(initializer_list<_Up> __il, _Args&&... __args) |
| { |
| reset(); |
| this->__construct(__il, _VSTD::forward<_Args>(__args)...); |
| return this->__get(); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| 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 for disengaged value"); |
| #ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF |
| return _VSTD::addressof(this->__get()); |
| #else |
| return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get()); |
| #endif |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| constexpr |
| add_pointer_t<value_type> |
| operator->() |
| { |
| _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); |
| #ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF |
| return _VSTD::addressof(this->__get()); |
| #else |
| return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get()); |
| #endif |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| constexpr |
| const value_type& |
| operator*() const& |
| { |
| _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); |
| return this->__get(); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| constexpr |
| value_type& |
| operator*() & |
| { |
| _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); |
| return this->__get(); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| constexpr |
| value_type&& |
| operator*() && |
| { |
| _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); |
| return _VSTD::move(this->__get()); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| constexpr |
| const value_type&& |
| operator*() const&& |
| { |
| _LIBCPP_ASSERT(this->has_value(), "optional operator* called for 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)); |
| } |
| |
| using __base::reset; |
| |
| private: |
| template <class _Up> |
| _LIBCPP_INLINE_VISIBILITY |
| static _Up* |
| __operator_arrow(true_type, _Up& __x) |
| { |
| return _VSTD::addressof(__x); |
| } |
| |
| template <class _Up> |
| _LIBCPP_INLINE_VISIBILITY |
| static constexpr _Up* |
| __operator_arrow(false_type, _Up& __x) |
| { |
| return &__x; |
| } |
| }; |
| |
| #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES |
| template<class T> |
| optional(T) -> optional<T>; |
| #endif |
| |
| // Comparisons between optionals |
| template <class _Tp, class _Up> |
| _LIBCPP_INLINE_VISIBILITY constexpr |
| enable_if_t< |
| is_convertible_v<decltype(_VSTD::declval<const _Tp&>() == |
| _VSTD::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(_VSTD::declval<const _Tp&>() != |
| _VSTD::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(_VSTD::declval<const _Tp&>() < |
| _VSTD::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(_VSTD::declval<const _Tp&>() > |
| _VSTD::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(_VSTD::declval<const _Tp&>() <= |
| _VSTD::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(_VSTD::declval<const _Tp&>() >= |
| _VSTD::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(_VSTD::declval<const _Tp&>() == |
| _VSTD::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(_VSTD::declval<const _Tp&>() == |
| _VSTD::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(_VSTD::declval<const _Tp&>() != |
| _VSTD::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(_VSTD::declval<const _Tp&>() != |
| _VSTD::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(_VSTD::declval<const _Tp&>() < |
| _VSTD::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(_VSTD::declval<const _Tp&>() < |
| _VSTD::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(_VSTD::declval<const _Tp&>() <= |
| _VSTD::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(_VSTD::declval<const _Tp&>() <= |
| _VSTD::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(_VSTD::declval<const _Tp&>() > |
| _VSTD::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(_VSTD::declval<const _Tp&>() > |
| _VSTD::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(_VSTD::declval<const _Tp&>() >= |
| _VSTD::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(_VSTD::declval<const _Tp&>() >= |
| _VSTD::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 |
| 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>> |
| > |
| { |
| typedef optional<_Tp> argument_type; |
| typedef size_t result_type; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| result_type operator()(const argument_type& __opt) const |
| { |
| return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0; |
| } |
| }; |
| |
| _LIBCPP_END_NAMESPACE_STD |
| |
| #endif // _LIBCPP_STD_VER > 14 |
| |
| _LIBCPP_POP_MACROS |
| |
| #endif // _LIBCPP_OPTIONAL |