diff options
Diffstat (limited to 'thirdparty/ue-libcxx/include/c++/v1/optional')
| -rw-r--r-- | thirdparty/ue-libcxx/include/c++/v1/optional | 1590 |
1 files changed, 0 insertions, 1590 deletions
diff --git a/thirdparty/ue-libcxx/include/c++/v1/optional b/thirdparty/ue-libcxx/include/c++/v1/optional deleted file mode 100644 index 349ceb5bc..000000000 --- a/thirdparty/ue-libcxx/include/c++/v1/optional +++ /dev/null @@ -1,1590 +0,0 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_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(see-below) optional(U &&); - template <class U> - explicit(see-below) optional(const optional<U> &); // constexpr in C++20 - template <class U> - explicit(see-below) 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 <__functional/hash.h> -#include <__functional/invoke.h> -#include <__functional/unary_function.h> -#include <__memory/construct_at.h> -#include <__tuple> -#include <__utility/forward.h> -#include <__utility/in_place.h> -#include <__utility/move.h> -#include <__utility/swap.h> -#include <initializer_list> -#include <new> -#include <stdexcept> -#include <type_traits> -#include <version> - -#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES -# include <atomic> -# include <chrono> -# include <climits> -# include <concepts> -# include <ctime> -# include <iterator> -# include <memory> -# include <ratio> -# include <tuple> -# include <typeinfo> -# include <utility> -# include <variant> -#endif - -// standard-mandated includes -#include <compare> - -#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 to be ill-formed. However, it may -// be allowed 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() { - 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 = _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() { - 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 = _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 |