forked from OSchip/llvm-project
698 lines
20 KiB
C++
698 lines
20 KiB
C++
// -*- 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++1y
|
|
|
|
#include <initializer_list>
|
|
|
|
namespace std
|
|
{
|
|
|
|
// optional for object types
|
|
template <class T>
|
|
class optional
|
|
{
|
|
public:
|
|
typedef T value_type;
|
|
|
|
// constructors
|
|
constexpr optional() noexcept;
|
|
constexpr optional(nullopt_t) noexcept;
|
|
optional(const optional&);
|
|
optional(optional&&) noexcept(is_nothrow_move_constructible<T>::value);
|
|
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&&...);
|
|
|
|
// destructor
|
|
~optional();
|
|
|
|
// assignment
|
|
optional& operator=(nullopt_t) noexcept;
|
|
optional& operator=(const optional&);
|
|
optional& operator=(optional&&)
|
|
noexcept(is_nothrow_move_assignable<T>::value &&
|
|
is_nothrow_move_constructible<T>::value);
|
|
template <class U> optional& operator=(U&&);
|
|
template <class... Args> void emplace(Args&&...);
|
|
template <class U, class... Args> void emplace(initializer_list<U>, Args&&...);
|
|
|
|
// swap
|
|
void swap(optional&)
|
|
noexcept(is_nothrow_move_constructible<T>::value &&
|
|
noexcept(swap(declval<T&>(), declval<T&>())));
|
|
|
|
// observers
|
|
constexpr T const* operator->() const;
|
|
T* operator->();
|
|
constexpr T const& operator*() const;
|
|
T& operator*();
|
|
constexpr explicit operator bool() const noexcept;
|
|
constexpr T const& value() const;
|
|
T& value();
|
|
template <class U> constexpr T value_or(U&&) const&;
|
|
template <class U> T value_or(U&&) &&;
|
|
};
|
|
|
|
// In-place construction
|
|
struct in_place_t{};
|
|
constexpr in_place_t in_place{};
|
|
|
|
// Disengaged state indicator
|
|
struct nullopt_t{see below};
|
|
constexpr nullopt_t nullopt(unspecified);
|
|
|
|
// class bad_optional_access
|
|
class bad_optional_access
|
|
: public logic_error
|
|
{
|
|
public:
|
|
explicit bad_optional_access(const string& what_arg);
|
|
explicit bad_optional_access(const char* what_arg);
|
|
};
|
|
|
|
// 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>&);
|
|
|
|
// 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;
|
|
|
|
// 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>&);
|
|
|
|
// Specialized algorithms
|
|
template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
|
|
template <class T> constexpr optional<typename decay<T>::type> make_optional(T&&);
|
|
|
|
// hash support
|
|
template <class T> struct hash;
|
|
template <class T> struct hash<optional<T>>;
|
|
|
|
} // std
|
|
|
|
*/
|
|
|
|
#include <__config>
|
|
#include <functional>
|
|
#include <stdexcept>
|
|
|
|
namespace std // purposefully not using versioning namespace
|
|
{
|
|
|
|
class _LIBCPP_EXCEPTION_ABI bad_optional_access
|
|
: public logic_error
|
|
{
|
|
public:
|
|
#if _LIBCPP_STD_VER > 11
|
|
_LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const string& __arg)
|
|
: logic_error(__arg) {}
|
|
_LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const char* __arg)
|
|
: logic_error(__arg) {}
|
|
_LIBCPP_INLINE_VISIBILITY bad_optional_access(const bad_optional_access&) noexcept = default;
|
|
_LIBCPP_INLINE_VISIBILITY bad_optional_access& operator=(const bad_optional_access&) noexcept = default;
|
|
#else
|
|
private:
|
|
bad_optional_access(const bad_optional_access&);
|
|
bad_optional_access& operator=(const bad_optional_access&);
|
|
public:
|
|
#endif // _LIBCPP_STD_VER > 11
|
|
// Get the key function ~bad_optional_access() into the dylib even if not compiling for C++1y
|
|
virtual ~bad_optional_access() _NOEXCEPT;
|
|
};
|
|
|
|
} // std
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
#include <initializer_list>
|
|
#include <type_traits>
|
|
#include <new>
|
|
#include <__functional_base>
|
|
|
|
#include <__undef_min_max>
|
|
|
|
#ifdef _LIBCPP_DEBUG
|
|
# include <__debug>
|
|
#else
|
|
# define _LIBCPP_ASSERT(x, m) ((void)0)
|
|
#endif
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
struct 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(_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(_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(_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(_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(_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(_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(_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(_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(_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(_VSTD::addressof(__opt.__val_)) value_type(_VSTD::move(this->__val_));
|
|
this->__val_.~value_type();
|
|
}
|
|
else
|
|
{
|
|
::new(_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");
|
|
return __operator_arrow(__has_operator_addressof<value_type>{});
|
|
}
|
|
|
|
_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_INLINE_VISIBILITY
|
|
constexpr value_type const& value() const
|
|
{
|
|
if (!this->__engaged_)
|
|
throw bad_optional_access("optional<T>::value: not engaged");
|
|
return this->__val_;
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
value_type& value()
|
|
{
|
|
if (!this->__engaged_)
|
|
throw bad_optional_access("optional<T>::value: not engaged");
|
|
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_;
|
|
}
|
|
};
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator==(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_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
|
|
{
|
|
if (!static_cast<bool>(__y))
|
|
return false;
|
|
if (!static_cast<bool>(__x))
|
|
return true;
|
|
return less<_Tp>{}(*__x, *__y);
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator==(const optional<_Tp>& __x, nullopt_t) noexcept
|
|
{
|
|
return !static_cast<bool>(__x);
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator==(nullopt_t, const optional<_Tp>& __x) noexcept
|
|
{
|
|
return !static_cast<bool>(__x);
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator<(const optional<_Tp>&, nullopt_t) noexcept
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator<(nullopt_t, const optional<_Tp>& __x) noexcept
|
|
{
|
|
return static_cast<bool>(__x);
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator==(const optional<_Tp>& __x, const _Tp& __v)
|
|
{
|
|
return static_cast<bool>(__x) ? *__x == __v : false;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator==(const _Tp& __v, const optional<_Tp>& __x)
|
|
{
|
|
return static_cast<bool>(__x) ? *__x == __v : false;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator<(const optional<_Tp>& __x, const _Tp& __v)
|
|
{
|
|
return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
bool
|
|
operator<(const _Tp& __v, const optional<_Tp>& __x)
|
|
{
|
|
return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
|
|
{
|
|
__x.swap(__y);
|
|
}
|
|
|
|
template <class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
constexpr
|
|
optional<typename decay<_Tp>::type>
|
|
make_optional(_Tp&& __v)
|
|
{
|
|
return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
|
|
}
|
|
|
|
template <class _Tp>
|
|
struct _LIBCPP_TYPE_VIS_ONLY hash<optional<_Tp> >
|
|
{
|
|
typedef 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
|
|
|
|
#endif // _LIBCPP_ARRAY
|