diff options
Diffstat (limited to 'data/iphoneos-sdk/v1/optional')
| -rwxr-xr-x | data/iphoneos-sdk/v1/optional | 1404 |
1 files changed, 1404 insertions, 0 deletions
diff --git a/data/iphoneos-sdk/v1/optional b/data/iphoneos-sdk/v1/optional new file mode 100755 index 000000000..921e32e1b --- /dev/null +++ b/data/iphoneos-sdk/v1/optional @@ -0,0 +1,1404 @@ +// -*- C++ -*- +//===-------------------------- optional ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#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 &); + optional &operator=(optional &&) noexcept(see below ); + 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 + }; +} // namespace std + +*/ + +#include <__config> +#include <__debug> +#include <__functional_base> +#include <functional> +#include <initializer_list> +#include <new> +#include <stdexcept> +#include <type_traits> +#include <utility> + +#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<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"); + + // 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<decay_t<_Up>, in_place_t> && + !is_same_v<decay_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... _Args, class = enable_if_t< + is_constructible_v<value_type, _Args...>> + > + _LIBCPP_INLINE_VISIBILITY + constexpr explicit optional(in_place_t, _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<decay_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; + } +}; + +// 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 |