Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
25 kB · 922 lines
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923// -*- 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_EXPERIMENTAL_OPTIONAL#define _LIBCPP_EXPERIMENTAL_OPTIONAL/* optional synopsis// C++1ynamespace std { namespace experimental { inline namespace fundamentals_v1 { // 5.3, optional for object types template <class T> class optional; // 5.4, In-place construction struct in_place_t{}; constexpr in_place_t in_place{}; // 5.5, No-value state indicator struct nullopt_t{see below}; constexpr nullopt_t nullopt(unspecified); // 5.6, Class bad_optional_access class bad_optional_access; // 5.7, Relational operators template <class T> constexpr bool operator==(const optional<T>&, const optional<T>&); template <class T> constexpr bool operator!=(const optional<T>&, const optional<T>&); template <class T> constexpr bool operator<(const optional<T>&, const optional<T>&); template <class T> constexpr bool operator>(const optional<T>&, const optional<T>&); template <class T> constexpr bool operator<=(const optional<T>&, const optional<T>&); template <class T> constexpr bool operator>=(const optional<T>&, const optional<T>&); // 5.8, 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; // 5.9, Comparison with T template <class T> constexpr bool operator==(const optional<T>&, const T&); template <class T> constexpr bool operator==(const T&, const optional<T>&); template <class T> constexpr bool operator!=(const optional<T>&, const T&); template <class T> constexpr bool operator!=(const T&, const optional<T>&); template <class T> constexpr bool operator<(const optional<T>&, const T&); template <class T> constexpr bool operator<(const T&, const optional<T>&); template <class T> constexpr bool operator<=(const optional<T>&, const T&); template <class T> constexpr bool operator<=(const T&, const optional<T>&); template <class T> constexpr bool operator>(const optional<T>&, const T&); template <class T> constexpr bool operator>(const T&, const optional<T>&); template <class T> constexpr bool operator>=(const optional<T>&, const T&); template <class T> constexpr bool operator>=(const T&, const optional<T>&); // 5.10, 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 optional { public: typedef T value_type; // 5.3.1, Constructors constexpr optional() noexcept; constexpr optional(nullopt_t) noexcept; optional(const optional&); optional(optional&&) noexcept(see below); constexpr optional(const T&); constexpr optional(T&&); 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&&...); // 5.3.2, Destructor ~optional(); // 5.3.3, Assignment optional& operator=(nullopt_t) noexcept; optional& operator=(const optional&); optional& operator=(optional&&) noexcept(see below); template <class U> optional& operator=(U&&); template <class... Args> void emplace(Args&&...); template <class U, class... Args> void emplace(initializer_list<U>, Args&&...); // 5.3.4, Swap void swap(optional&) noexcept(see below); // 5.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 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&&) &&; private: T* val; // exposition only }; } // namespace fundamentals_v1 } // namespace experimental // 5.11, Hash support template <class T> struct hash; template <class T> struct hash<experimental::optional<T>>;} // namespace std*/#include <experimental/__config>#include <functional>#include <stdexcept>#if _LIBCPP_STD_VER > 11#include <initializer_list>#include <type_traits>#include <new>#include <__functional_base>#include <__debug>#endif#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)#pragma GCC system_header#endif_LIBCPP_PUSH_MACROS#include <__undef_macros>_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTALclass _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access : public std::logic_error{public: bad_optional_access() : std::logic_error("Bad optional Access") {}// Get the key function ~bad_optional_access() into the dylib virtual ~bad_optional_access() _NOEXCEPT;};_LIBCPP_END_NAMESPACE_EXPERIMENTAL#if _LIBCPP_STD_VER > 11_LIBCPP_BEGIN_NAMESPACE_LFTSstruct in_place_t {};constexpr in_place_t in_place{};struct nullopt_t{ explicit constexpr nullopt_t(int) noexcept {}};constexpr nullopt_t nullopt{0};template <class _Tp, bool = is_trivially_destructible<_Tp>::value>class __optional_storage{protected: typedef _Tp value_type; union { char __null_state_; value_type __val_; }; bool __engaged_ = false; _LIBCPP_INLINE_VISIBILITY ~__optional_storage() { if (__engaged_) __val_.~value_type(); } _LIBCPP_INLINE_VISIBILITY constexpr __optional_storage() noexcept : __null_state_('\0') {} _LIBCPP_INLINE_VISIBILITY __optional_storage(const __optional_storage& __x) : __engaged_(__x.__engaged_) { if (__engaged_) ::new((void*)_VSTD::addressof(__val_)) value_type(__x.__val_); } _LIBCPP_INLINE_VISIBILITY __optional_storage(__optional_storage&& __x) noexcept(is_nothrow_move_constructible<value_type>::value) : __engaged_(__x.__engaged_) { if (__engaged_) ::new((void*)_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_)); } _LIBCPP_INLINE_VISIBILITY constexpr __optional_storage(const value_type& __v) : __val_(__v), __engaged_(true) {} _LIBCPP_INLINE_VISIBILITY constexpr __optional_storage(value_type&& __v) : __val_(_VSTD::move(__v)), __engaged_(true) {} template <class... _Args> _LIBCPP_INLINE_VISIBILITY constexpr explicit __optional_storage(in_place_t, _Args&&... __args) : __val_(_VSTD::forward<_Args>(__args)...), __engaged_(true) {}};template <class _Tp>class __optional_storage<_Tp, true>{protected: typedef _Tp value_type; union { char __null_state_; value_type __val_; }; bool __engaged_ = false; _LIBCPP_INLINE_VISIBILITY constexpr __optional_storage() noexcept : __null_state_('\0') {} _LIBCPP_INLINE_VISIBILITY __optional_storage(const __optional_storage& __x) : __engaged_(__x.__engaged_) { if (__engaged_) ::new((void*)_VSTD::addressof(__val_)) value_type(__x.__val_); } _LIBCPP_INLINE_VISIBILITY __optional_storage(__optional_storage&& __x) noexcept(is_nothrow_move_constructible<value_type>::value) : __engaged_(__x.__engaged_) { if (__engaged_) ::new((void*)_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_)); } _LIBCPP_INLINE_VISIBILITY constexpr __optional_storage(const value_type& __v) : __val_(__v), __engaged_(true) {} _LIBCPP_INLINE_VISIBILITY constexpr __optional_storage(value_type&& __v) : __val_(_VSTD::move(__v)), __engaged_(true) {} template <class... _Args> _LIBCPP_INLINE_VISIBILITY constexpr explicit __optional_storage(in_place_t, _Args&&... __args) : __val_(_VSTD::forward<_Args>(__args)...), __engaged_(true) {}};template <class _Tp>class optional : private __optional_storage<_Tp>{ typedef __optional_storage<_Tp> __base;public: typedef _Tp value_type; static_assert(!is_reference<value_type>::value, "Instantiation of optional with a reference type is ill-formed."); static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value, "Instantiation of optional with a in_place_t type is ill-formed."); static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value, "Instantiation of optional with a nullopt_t type is ill-formed."); static_assert(is_object<value_type>::value, "Instantiation of optional with a non-object type is undefined behavior."); static_assert(is_nothrow_destructible<value_type>::value, "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior."); _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default; _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default; _LIBCPP_INLINE_VISIBILITY ~optional() = default; _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v) : __base(__v) {} _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v) : __base(_VSTD::move(__v)) {} template <class... _Args, class = typename enable_if < is_constructible<value_type, _Args...>::value >::type > _LIBCPP_INLINE_VISIBILITY constexpr explicit optional(in_place_t, _Args&&... __args) : __base(in_place, _VSTD::forward<_Args>(__args)...) {} template <class _Up, class... _Args, class = typename enable_if < is_constructible<value_type, initializer_list<_Up>&, _Args...>::value >::type > _LIBCPP_INLINE_VISIBILITY constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} _LIBCPP_INLINE_VISIBILITY optional& operator=(nullopt_t) noexcept { if (this->__engaged_) { this->__val_.~value_type(); this->__engaged_ = false; } return *this; } _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional& __opt) { if (this->__engaged_ == __opt.__engaged_) { if (this->__engaged_) this->__val_ = __opt.__val_; } else { if (this->__engaged_) this->__val_.~value_type(); else ::new((void*)_VSTD::addressof(this->__val_)) value_type(__opt.__val_); this->__engaged_ = __opt.__engaged_; } return *this; } _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&& __opt) noexcept(is_nothrow_move_assignable<value_type>::value && is_nothrow_move_constructible<value_type>::value) { if (this->__engaged_ == __opt.__engaged_) { if (this->__engaged_) this->__val_ = _VSTD::move(__opt.__val_); } else { if (this->__engaged_) this->__val_.~value_type(); else ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_)); this->__engaged_ = __opt.__engaged_; } return *this; } template <class _Up, class = typename enable_if < is_same<typename remove_reference<_Up>::type, value_type>::value && is_constructible<value_type, _Up>::value && is_assignable<value_type&, _Up>::value >::type > _LIBCPP_INLINE_VISIBILITY optional& operator=(_Up&& __v) { if (this->__engaged_) this->__val_ = _VSTD::forward<_Up>(__v); else { ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v)); this->__engaged_ = true; } return *this; } template <class... _Args, class = typename enable_if < is_constructible<value_type, _Args...>::value >::type > _LIBCPP_INLINE_VISIBILITY void emplace(_Args&&... __args) { *this = nullopt; ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); this->__engaged_ = true; } template <class _Up, class... _Args, class = typename enable_if < is_constructible<value_type, initializer_list<_Up>&, _Args...>::value >::type > _LIBCPP_INLINE_VISIBILITY void emplace(initializer_list<_Up> __il, _Args&&... __args) { *this = nullopt; ::new((void*)_VSTD::addressof(this->__val_)) value_type(__il, _VSTD::forward<_Args>(__args)...); this->__engaged_ = true; } _LIBCPP_INLINE_VISIBILITY void swap(optional& __opt) noexcept(is_nothrow_move_constructible<value_type>::value && __is_nothrow_swappable<value_type>::value) { using _VSTD::swap; if (this->__engaged_ == __opt.__engaged_) { if (this->__engaged_) swap(this->__val_, __opt.__val_); } else { if (this->__engaged_) { ::new((void*)_VSTD::addressof(__opt.__val_)) value_type(_VSTD::move(this->__val_)); this->__val_.~value_type(); } else { ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_)); __opt.__val_.~value_type(); } swap(this->__engaged_, __opt.__engaged_); } } _LIBCPP_INLINE_VISIBILITY constexpr value_type const* operator->() const { _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF return __builtin_addressof(this->__val_);#else return __operator_arrow(__has_operator_addressof<value_type>{});#endif } _LIBCPP_INLINE_VISIBILITY value_type* operator->() { _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value"); return _VSTD::addressof(this->__val_); } _LIBCPP_INLINE_VISIBILITY constexpr const value_type& operator*() const { _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value"); return this->__val_; } _LIBCPP_INLINE_VISIBILITY value_type& operator*() { _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value"); return this->__val_; } _LIBCPP_INLINE_VISIBILITY constexpr explicit operator bool() const noexcept {return this->__engaged_;} _LIBCPP_NORETURN _LIBCPP_INLINE_VISIBILITY #ifndef _LIBCPP_NO_EXCEPTIONS_LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS#endif constexpr void __throw_bad_optional_access() const {#ifndef _LIBCPP_NO_EXCEPTIONS throw bad_optional_access();#else _VSTD::abort();#endif } _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS constexpr value_type const& value() const { if (!this->__engaged_) __throw_bad_optional_access(); return this->__val_; } _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS value_type& value() { if (!this->__engaged_) __throw_bad_optional_access(); return this->__val_; } template <class _Up> _LIBCPP_INLINE_VISIBILITY constexpr value_type value_or(_Up&& __v) const& { static_assert(is_copy_constructible<value_type>::value, "optional<T>::value_or: T must be copy constructible"); static_assert(is_convertible<_Up, value_type>::value, "optional<T>::value_or: U must be convertible to T"); return this->__engaged_ ? this->__val_ : static_cast<value_type>(_VSTD::forward<_Up>(__v)); } template <class _Up> _LIBCPP_INLINE_VISIBILITY value_type value_or(_Up&& __v) && { static_assert(is_move_constructible<value_type>::value, "optional<T>::value_or: T must be move constructible"); static_assert(is_convertible<_Up, value_type>::value, "optional<T>::value_or: U must be convertible to T"); return this->__engaged_ ? _VSTD::move(this->__val_) : static_cast<value_type>(_VSTD::forward<_Up>(__v)); }private: _LIBCPP_INLINE_VISIBILITY value_type const* __operator_arrow(true_type) const { return _VSTD::addressof(this->__val_); } _LIBCPP_INLINE_VISIBILITY constexpr value_type const* __operator_arrow(false_type) const { return &this->__val_; }};// Comparisons between optionalstemplate <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator==(const optional<_Tp>& __x, const optional<_Tp>& __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>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator!=(const optional<_Tp>& __x, const optional<_Tp>& __y){ return !(__x == __y);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<(const optional<_Tp>& __x, const optional<_Tp>& __y){ if (!static_cast<bool>(__y)) return false; if (!static_cast<bool>(__x)) return true; return *__x < *__y;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>(const optional<_Tp>& __x, const optional<_Tp>& __y){ return __y < __x;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<=(const optional<_Tp>& __x, const optional<_Tp>& __y){ return !(__y < __x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>=(const optional<_Tp>& __x, const optional<_Tp>& __y){ return !(__x < __y);}// Comparisons with nullopttemplate <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator==(const optional<_Tp>& __x, nullopt_t) noexcept{ return !static_cast<bool>(__x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator==(nullopt_t, const optional<_Tp>& __x) noexcept{ return !static_cast<bool>(__x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator!=(const optional<_Tp>& __x, nullopt_t) noexcept{ return static_cast<bool>(__x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator!=(nullopt_t, const optional<_Tp>& __x) noexcept{ return static_cast<bool>(__x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<(const optional<_Tp>&, nullopt_t) noexcept{ return false;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<(nullopt_t, const optional<_Tp>& __x) noexcept{ return static_cast<bool>(__x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<=(const optional<_Tp>& __x, nullopt_t) noexcept{ return !static_cast<bool>(__x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<=(nullopt_t, const optional<_Tp>&) noexcept{ return true;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>(const optional<_Tp>& __x, nullopt_t) noexcept{ return static_cast<bool>(__x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>(nullopt_t, const optional<_Tp>&) noexcept{ return false;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>=(const optional<_Tp>&, nullopt_t) noexcept{ return true;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>=(nullopt_t, const optional<_Tp>& __x) noexcept{ return !static_cast<bool>(__x);}// Comparisons with Ttemplate <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator==(const optional<_Tp>& __x, const _Tp& __v){ return static_cast<bool>(__x) ? *__x == __v : false;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator==(const _Tp& __v, const optional<_Tp>& __x){ return static_cast<bool>(__x) ? *__x == __v : false;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator!=(const optional<_Tp>& __x, const _Tp& __v){ return static_cast<bool>(__x) ? !(*__x == __v) : true;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator!=(const _Tp& __v, const optional<_Tp>& __x){ return static_cast<bool>(__x) ? !(*__x == __v) : true;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<(const optional<_Tp>& __x, const _Tp& __v){ return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<(const _Tp& __v, const optional<_Tp>& __x){ return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<=(const optional<_Tp>& __x, const _Tp& __v){ return !(__x > __v);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator<=(const _Tp& __v, const optional<_Tp>& __x){ return !(__v > __x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>(const optional<_Tp>& __x, const _Tp& __v){ return static_cast<bool>(__x) ? __v < __x : false;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>(const _Tp& __v, const optional<_Tp>& __x){ return static_cast<bool>(__x) ? __x < __v : true;}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>=(const optional<_Tp>& __x, const _Tp& __v){ return !(__x < __v);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexprbooloperator>=(const _Tp& __v, const optional<_Tp>& __x){ return !(__v < __x);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYvoidswap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))){ __x.swap(__y);}template <class _Tp>inline _LIBCPP_INLINE_VISIBILITYconstexproptional<typename decay<_Tp>::type>make_optional(_Tp&& __v){ return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));}_LIBCPP_END_NAMESPACE_LFTS_LIBCPP_BEGIN_NAMESPACE_STDtemplate <class _Tp>struct _LIBCPP_TEMPLATE_VIS hash<std::experimental::optional<_Tp> >{ typedef std::experimental::optional<_Tp> argument_type; typedef size_t result_type; _LIBCPP_INLINE_VISIBILITY result_type operator()(const argument_type& __opt) const _NOEXCEPT { return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0; }};_LIBCPP_END_NAMESPACE_STD#endif // _LIBCPP_STD_VER > 11_LIBCPP_POP_MACROS#endif // _LIBCPP_EXPERIMENTAL_OPTIONAL