mirror of
https://github.com/TartanLlama/optional.git
synced 2025-08-03 20:04:26 +02:00
Trivial destructor
This commit is contained in:
Simon Brand
843
optional.hpp
843
optional.hpp
@@ -55,20 +55,20 @@ namespace tl {
|
||||
};
|
||||
static constexpr in_place_t in_place{};
|
||||
|
||||
// [optional.optional], class template optional
|
||||
template <class T>
|
||||
class optional;
|
||||
// [optional.optional], class template optional
|
||||
template <class T>
|
||||
class optional;
|
||||
|
||||
namespace detail {
|
||||
template <class T, class U>
|
||||
using enable_forward_value = tl::enable_if_t<
|
||||
using enable_forward_value = enable_if_t<
|
||||
std::is_constructible<T, U&&>::value &&
|
||||
!std::is_same<tl::decay_t<U>, in_place_t>::value &&
|
||||
!std::is_same<optional<T>, tl::decay_t<U>>::value
|
||||
>;
|
||||
>;
|
||||
|
||||
template <class T, class U, class Other>
|
||||
using enable_from_other = tl::enable_if_t<
|
||||
using enable_from_other = enable_if_t<
|
||||
std::is_constructible<T, Other>::value &&
|
||||
!std::is_constructible<T, optional<U>&>::value &&
|
||||
!std::is_constructible<T, optional<U>&&>::value &&
|
||||
@@ -78,58 +78,59 @@ namespace tl {
|
||||
!std::is_convertible<optional<U>&&, T>::value &&
|
||||
!std::is_convertible<const optional<U>&, T>::value &&
|
||||
!std::is_convertible<const optional<U>&&, T>::value
|
||||
>;
|
||||
>;
|
||||
|
||||
template <class T, class U>
|
||||
using enable_assign_forward = tl::enable_if_t<
|
||||
!is_same_v<optional<T>, tl::decay_t<U>>::value &&
|
||||
using enable_assign_forward = enable_if_t<
|
||||
!std::is_same<optional<T>, tl::decay_t<U>>::value &&
|
||||
!tl::conjunction<std::is_scalar<T>, std::is_same<T, tl::decay_t<U>>>::value &&
|
||||
std::is_constructible<T, U>::value &&
|
||||
is_assignable<T&, U>::value
|
||||
>;
|
||||
std::is_assignable<T&, U>::value
|
||||
>;
|
||||
|
||||
template <class T, class U, class Other>
|
||||
using enable_assign_from_other = tl::enable_if_t<
|
||||
std::is_constructible<T, Other> &&
|
||||
std::is_assignablev<T&, Other> &&
|
||||
!std::is_constructiblev<T, optional<U>&> &&
|
||||
!std::is_constructiblev<T, optional<U>&&> &&
|
||||
!std::is_constructiblev<T, const optional<U>&> &&
|
||||
!std::is_constructiblev<T, const optional<U>&&> &&
|
||||
!std::is_convertiblev<optional<U>&, T> &&
|
||||
!std::is_convertiblev<optional<U>&&, T> &&
|
||||
!std::is_convertiblev<const optional<U>&, T> &&
|
||||
!std::is_convertiblev<const optional<U>&&, T> &&
|
||||
!std::is_assignablev<T&, optional<U>&> &&
|
||||
!std::is_assignablev<T&, optional<U>&&> &&
|
||||
!std::is_assignablev<T&, const optional<U>&> &&
|
||||
!std::is_assignablev<T&, const optional<U>&&>
|
||||
>
|
||||
using enable_assign_from_other = enable_if_t<
|
||||
std::is_constructible<T, Other>::value &&
|
||||
std::is_assignable<T&, Other>::value &&
|
||||
!std::is_constructible<T, optional<U>&>::value &&
|
||||
!std::is_constructible<T, optional<U>&&>::value &&
|
||||
!std::is_constructible<T, const optional<U>&>::value &&
|
||||
!std::is_constructible<T, const optional<U>&&>::value &&
|
||||
!std::is_convertible<optional<U>&, T>::value &&
|
||||
!std::is_convertible<optional<U>&&, T>::value &&
|
||||
!std::is_convertible<const optional<U>&, T>::value &&
|
||||
!std::is_convertible<const optional<U>&&, T>::value &&
|
||||
!std::is_assignable<T&, optional<U>&>::value &&
|
||||
!std::is_assignable<T&, optional<U>&&>::value &&
|
||||
!std::is_assignable<T&, const optional<U>&>::value &&
|
||||
!std::is_assignable<T&, const optional<U>&&>::value
|
||||
>;
|
||||
|
||||
//TODO improve
|
||||
template <class T, class=void>
|
||||
struct is_swappable : std::false_type{};
|
||||
//TODO improve
|
||||
template <class T, class=void>
|
||||
struct is_swappable : std::false_type{};
|
||||
|
||||
template <class T>
|
||||
struct is_swappable<T,void_t<decltype(swap(std::declval<T>(), std::declval<T>()))>>
|
||||
: std::true_type{};
|
||||
template <class T>
|
||||
struct is_swappable<T,void_t<decltype(swap(std::declval<T>(), std::declval<T>()))>>
|
||||
: std::true_type{};
|
||||
|
||||
//TODO improve
|
||||
template <class T, class=void>
|
||||
struct is_nothrow_swappable : std::false_type{};
|
||||
//TODO improve
|
||||
template <class T, class=void>
|
||||
struct is_nothrow_swappable : std::false_type{};
|
||||
|
||||
template <class T>
|
||||
struct is_nothrow_swappable<T,void_t<decltype(swap(std::declval<T>(), std::declval<T>()))>>
|
||||
: std::true_type{};
|
||||
template <class T>
|
||||
struct is_nothrow_swappable<T,void_t<decltype(swap(std::declval<T>(), std::declval<T>()))>>
|
||||
: std::true_type{};
|
||||
}
|
||||
|
||||
// [optional.nullopt], no-value state indicator
|
||||
struct nullopt_t{
|
||||
struct do_not_use{};
|
||||
constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept{}
|
||||
};
|
||||
// [optional.nullopt], no-value state indicator
|
||||
struct nullopt_t{
|
||||
struct do_not_use{};
|
||||
constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept{}
|
||||
};
|
||||
static constexpr nullopt_t nullopt{nullopt_t::do_not_use{}, nullopt_t::do_not_use{}};
|
||||
|
||||
// [optional.bad.access], class bad_optional_access
|
||||
// [optional.bad.access], class bad_optional_access
|
||||
class bad_optional_access : public std::exception {
|
||||
public:
|
||||
bad_optional_access() = default;
|
||||
@@ -138,158 +139,158 @@ namespace tl {
|
||||
}
|
||||
};
|
||||
|
||||
// [optional.relops], relational operators
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (lhs.has_value() != rhs.has_value())
|
||||
return false;
|
||||
if (lhs.has_value())
|
||||
return true;
|
||||
// [optional.relops], relational operators
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (lhs.has_value() != rhs.has_value())
|
||||
return false;
|
||||
if (lhs.has_value())
|
||||
return true;
|
||||
|
||||
return lhs.value() == rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (lhs.has_value() != rhs.has_value())
|
||||
return true;
|
||||
if (lhs.has_value())
|
||||
return false;
|
||||
return lhs.value() == rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (lhs.has_value() != rhs.has_value())
|
||||
return true;
|
||||
if (lhs.has_value())
|
||||
return false;
|
||||
|
||||
return lhs.value() != rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (!rhs.has_value())
|
||||
return false;
|
||||
if (!lhs.has_value())
|
||||
return true;
|
||||
return lhs.value() != rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (!rhs.has_value())
|
||||
return false;
|
||||
if (!lhs.has_value())
|
||||
return true;
|
||||
|
||||
return lhs.value() < rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (!lhs.has_value())
|
||||
return false;
|
||||
if (!rhs.has_value())
|
||||
return true;
|
||||
return lhs.value() < rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (!lhs.has_value())
|
||||
return false;
|
||||
if (!rhs.has_value())
|
||||
return true;
|
||||
|
||||
return lhs.value() > rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (!lhs.has_value())
|
||||
return true;
|
||||
if (!rhs.has_value())
|
||||
return false;
|
||||
return lhs.value() > rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (!lhs.has_value())
|
||||
return true;
|
||||
if (!rhs.has_value())
|
||||
return false;
|
||||
|
||||
return lhs.value() <= rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (!rhs.has_value())
|
||||
return true;
|
||||
if (!lhs.has_value())
|
||||
return false;
|
||||
return lhs.value() <= rhs.value();
|
||||
}
|
||||
template <class T, class U>
|
||||
inline constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs) {
|
||||
if (!rhs.has_value())
|
||||
return true;
|
||||
if (!lhs.has_value())
|
||||
return false;
|
||||
|
||||
return lhs.value() >= rhs.value();
|
||||
}
|
||||
return lhs.value() >= rhs.value();
|
||||
}
|
||||
|
||||
// [optional.nullops], comparison with nullopt
|
||||
template <class T> inline constexpr bool operator==(const optional<T>& lhs, nullopt_t) noexcept {
|
||||
return !lhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator==(nullopt_t, const optional<T>& rhs) noexcept {
|
||||
return !rhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator!=(const optional<T>& lhs, nullopt_t) noexcept {
|
||||
return lhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator!=(nullopt_t, const optional<T>& rhs) noexcept {
|
||||
return rhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
|
||||
return false;
|
||||
}
|
||||
template <class T> inline constexpr bool operator<(nullopt_t, const optional<T>& rhs) noexcept {
|
||||
return rhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator<=(const optional<T>& lhs, nullopt_t) noexcept {
|
||||
return !lhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
|
||||
return true;
|
||||
}
|
||||
template <class T> inline constexpr bool operator>(const optional<T>& lhs, nullopt_t) noexcept {
|
||||
return lhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
|
||||
return false;
|
||||
}
|
||||
template <class T> inline constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
|
||||
return true;
|
||||
}
|
||||
template <class T> inline constexpr bool operator>=(nullopt_t, const optional<T>& rhs) noexcept {
|
||||
return !rhs.has_value();
|
||||
}
|
||||
// [optional.nullops], comparison with nullopt
|
||||
template <class T> inline constexpr bool operator==(const optional<T>& lhs, nullopt_t) noexcept {
|
||||
return !lhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator==(nullopt_t, const optional<T>& rhs) noexcept {
|
||||
return !rhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator!=(const optional<T>& lhs, nullopt_t) noexcept {
|
||||
return lhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator!=(nullopt_t, const optional<T>& rhs) noexcept {
|
||||
return rhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
|
||||
return false;
|
||||
}
|
||||
template <class T> inline constexpr bool operator<(nullopt_t, const optional<T>& rhs) noexcept {
|
||||
return rhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator<=(const optional<T>& lhs, nullopt_t) noexcept {
|
||||
return !lhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
|
||||
return true;
|
||||
}
|
||||
template <class T> inline constexpr bool operator>(const optional<T>& lhs, nullopt_t) noexcept {
|
||||
return lhs.has_value();
|
||||
}
|
||||
template <class T> inline constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
|
||||
return false;
|
||||
}
|
||||
template <class T> inline constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
|
||||
return true;
|
||||
}
|
||||
template <class T> inline constexpr bool operator>=(nullopt_t, const optional<T>& rhs) noexcept {
|
||||
return !rhs.has_value();
|
||||
}
|
||||
|
||||
// [optional.comp_with_t], comparison with T
|
||||
template <class T, class U> inline constexpr bool operator==(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? *lhs == rhs : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator==(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs == rhs.value() : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator!=(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() != lhs : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator!=(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs != rhs.value() : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator<(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() < lhs : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator<(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs < rhs.value() : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator<=(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() <= lhs : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator<=(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs <= rhs.value() : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator>(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() > lhs : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator>(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs > rhs.value() : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator>=(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() >= lhs : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator>=(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs >= rhs.value() : true;
|
||||
}
|
||||
// [optional.comp_with_t], comparison with T
|
||||
template <class T, class U> inline constexpr bool operator==(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? *lhs == rhs : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator==(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs == rhs.value() : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator!=(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() != lhs : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator!=(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs != rhs.value() : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator<(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() < lhs : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator<(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs < rhs.value() : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator<=(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() <= lhs : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator<=(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs <= rhs.value() : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator>(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() > lhs : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator>(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs > rhs.value() : true;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator>=(const optional<T>& lhs, const U& rhs) {
|
||||
return lhs.has_value() ? lhs.value() >= lhs : false;
|
||||
}
|
||||
template <class T, class U> inline constexpr bool operator>=(const U& lhs, const optional<T>& rhs) {
|
||||
return rhs.has_value() ? lhs >= rhs.value() : true;
|
||||
}
|
||||
|
||||
|
||||
// [optional.specalg], specialized algorithms
|
||||
template <class T, tl::enable_if_t<std::is_move_constructible<T>::value>* = nullptr,
|
||||
tl::enable_if_t<is_swappable<T>::value>* = nullptr>
|
||||
void swap(optional<T>& lhs, optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
|
||||
return lhs.swap(rhs);
|
||||
}
|
||||
// [optional.specalg], specialized algorithms
|
||||
template <class T, enable_if_t<std::is_move_constructible<T>::value>* = nullptr,
|
||||
enable_if_t<detail::is_swappable<T>::value>* = nullptr>
|
||||
void swap(optional<T>& lhs, optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
|
||||
return lhs.swap(rhs);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline constexpr optional<tl::decay_t<T>> make_optional(T&& v) {
|
||||
return optional<decay_t<T>>(std::forward<T>(v));
|
||||
}
|
||||
template <class T, class... Args>
|
||||
inline constexpr optional<T> make_optional(Args&&... args) {
|
||||
return optional<T>(in_place, std::forward<Args>(args)...);
|
||||
}
|
||||
template <class T, class U, class... Args>
|
||||
inline constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args) {
|
||||
return optional<T>(in_place, il, std::forward<Args>(args)...);
|
||||
}
|
||||
template <class T>
|
||||
inline constexpr optional<tl::decay_t<T>> make_optional(T&& v) {
|
||||
return optional<decay_t<T>>(std::forward<T>(v));
|
||||
}
|
||||
template <class T, class... Args>
|
||||
inline constexpr optional<T> make_optional(Args&&... args) {
|
||||
return optional<T>(in_place, std::forward<Args>(args)...);
|
||||
}
|
||||
template <class T, class U, class... Args>
|
||||
inline constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args) {
|
||||
return optional<T>(in_place, il, std::forward<Args>(args)...);
|
||||
}
|
||||
}
|
||||
|
||||
// [optional.hash], hash support
|
||||
@@ -297,7 +298,7 @@ namespace std {
|
||||
//TODO SFINAE
|
||||
template <class T>
|
||||
struct hash<tl::optional<T>> {
|
||||
std::size_t operator() (const tl::optional<T>& o) const {
|
||||
::std::size_t operator() (const tl::optional<T>& o) const {
|
||||
if (!o.has_value())
|
||||
return 0;
|
||||
|
||||
@@ -307,9 +308,8 @@ namespace std {
|
||||
}
|
||||
|
||||
namespace tl {
|
||||
|
||||
namespace detail {
|
||||
template <class T, bool = std::is_trivially_destructible<T>::value>
|
||||
template <class T, bool = ::std::is_trivially_destructible<T>::value>
|
||||
struct optional_storage_base {
|
||||
constexpr optional_storage_base() noexcept
|
||||
: m_dummy(), m_has_value(false) {}
|
||||
@@ -333,12 +333,7 @@ namespace tl {
|
||||
struct optional_storage_base<T, true> {
|
||||
constexpr optional_storage_base() noexcept
|
||||
: m_dummy(), m_has_value(false) {}
|
||||
~optional_storage_base() {
|
||||
if (m_has_value) {
|
||||
//don't destruct value
|
||||
m_has_value = false;
|
||||
}
|
||||
}
|
||||
~optional_storage_base() = default;
|
||||
|
||||
struct dummy{};
|
||||
union {
|
||||
@@ -350,273 +345,273 @@ namespace tl {
|
||||
};
|
||||
}
|
||||
|
||||
template <class T>
|
||||
class optional : private detail::optional_storage_base<T> {
|
||||
public:
|
||||
using value_type = T;
|
||||
template <class T>
|
||||
class optional : private detail::optional_storage_base<T> {
|
||||
public:
|
||||
using value_type = T;
|
||||
|
||||
// [optional.ctor], constructors
|
||||
constexpr optional() noexcept = default;
|
||||
constexpr optional(nullopt_t) noexcept {};
|
||||
constexpr optional(const optional& rhs) {
|
||||
if (rhs.has_value()) {
|
||||
// [optional.ctor], constructors
|
||||
constexpr optional() noexcept = default;
|
||||
constexpr optional(nullopt_t) noexcept {};
|
||||
constexpr optional(const optional& rhs) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (rhs.value());
|
||||
}
|
||||
}
|
||||
template <class U = T, enable_if_t<std::is_move_constructible<T>::value>* = nullptr>
|
||||
constexpr optional(optional&& rhs) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.value()));
|
||||
}
|
||||
}
|
||||
template <class... Args>
|
||||
constexpr explicit optional(enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>,
|
||||
Args&&... args) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::forward<Args>(args)...);
|
||||
}
|
||||
template <class U, class... Args>
|
||||
constexpr explicit optional(
|
||||
enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, in_place_t>,
|
||||
std::initializer_list<U> il, Args&&... args) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (il, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <class U = T, enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr,
|
||||
detail::enable_forward_value<T,U>* = nullptr>
|
||||
constexpr optional(U&& u) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::forward<U>(u));
|
||||
}
|
||||
|
||||
template <class U = T, enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr,
|
||||
detail::enable_forward_value<T,U>* = nullptr>
|
||||
constexpr explicit optional(U&& u) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::forward<U>(u));
|
||||
}
|
||||
|
||||
template <class U, detail::enable_from_other<T,U,const U&>* = nullptr,
|
||||
enable_if_t<std::is_convertible<const U&, T>::value>* = nullptr>
|
||||
optional(const optional<U>& rhs) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (rhs.value());
|
||||
}
|
||||
}
|
||||
template <class U = T, tl::enable_if_t<std::is_move_constructible<T>::value>* = nullptr>
|
||||
constexpr optional(optional&& rhs) {
|
||||
|
||||
template <class U, detail::enable_from_other<T,U,const U&>* = nullptr,
|
||||
enable_if_t<!std::is_convertible<const U&, T>::value>* = nullptr>
|
||||
optional(const optional<U>& rhs) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (rhs.value());
|
||||
}
|
||||
|
||||
template <class U, detail::enable_from_other<T,U,U&&>* = nullptr,
|
||||
enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr>
|
||||
optional(optional<U>&& rhs) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.value()));
|
||||
}
|
||||
|
||||
|
||||
template <class U, detail::enable_from_other<T,U,U&&>* = nullptr,
|
||||
enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr>
|
||||
explicit optional(optional<U>&& rhs) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.value()));
|
||||
}
|
||||
|
||||
// [optional.dtor], destructor
|
||||
~optional() = default;
|
||||
|
||||
// [optional.assign], assignment
|
||||
optional& operator=(nullopt_t) noexcept {
|
||||
if (has_value()) {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO conditionally delete, check exception guarantee
|
||||
optional& operator=(const optional& rhs) {
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.value()));
|
||||
this->m_value = rhs.m_value;
|
||||
}
|
||||
else {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
}
|
||||
}
|
||||
template <class... Args>
|
||||
constexpr explicit optional(tl::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>,
|
||||
Args&&... args) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::forward<Args>(args)...);
|
||||
}
|
||||
template <class U, class... Args>
|
||||
constexpr explicit optional(
|
||||
tl::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, in_place_t>,
|
||||
std::initializer_list<U> il, Args&&... args) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (il, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <class U = T, tl::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr,
|
||||
detail::enable_forward_value<T,U>* = nullptr>
|
||||
constexpr optional(U&& u) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::forward<U>(u));
|
||||
}
|
||||
|
||||
template <class U = T, tl::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr,
|
||||
detail::enable_forward_value<T,U>* = nullptr>
|
||||
constexpr explicit optional(U&& u) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::forward<U>(u));
|
||||
}
|
||||
|
||||
template <class U, detail::enable_from_other<T,U,const U&>* = nullptr,
|
||||
tl::enable_if_t<std::is_convertible<const U&, T>::value>* = nullptr>
|
||||
optional(const optional<U>& rhs) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (rhs.value());
|
||||
}
|
||||
|
||||
template <class U, detail::enable_from_other<T,U,const U&>* = nullptr,
|
||||
tl::enable_if_t<!std::is_convertible<const U&, T>::value>* = nullptr>
|
||||
optional(const optional<U>& rhs) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (rhs.value());
|
||||
}
|
||||
|
||||
template <class U, detail::enable_from_other<T,U,U&&>* = nullptr,
|
||||
tl::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr>
|
||||
optional(optional<U>&& rhs) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.value()));
|
||||
}
|
||||
|
||||
|
||||
template <class U, detail::enable_from_other<T,U,U&&>* = nullptr,
|
||||
enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr>
|
||||
explicit optional(optional<U>&& rhs) {
|
||||
this->m_has_value = true;
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.value()));
|
||||
}
|
||||
|
||||
// [optional.dtor], destructor
|
||||
~optional() = default;
|
||||
|
||||
// [optional.assign], assignment
|
||||
optional& operator=(nullopt_t) noexcept {
|
||||
if (has_value()) {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO conditionally delete, check exception guarantee
|
||||
optional& operator=(const optional& rhs) {
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_value = rhs.m_value;
|
||||
}
|
||||
else {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
new (std::addressof(this->m_value)) T (rhs.m_value);
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (rhs.has_value()) {
|
||||
new (std::addressof(this->m_value)) T (rhs.m_value);
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
// TODO conditionally delete, check exception guarantee
|
||||
optional& operator=(optional&& rhs) noexcept {
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_value = std::move(rhs.m_value);
|
||||
}
|
||||
else {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO conditionally delete, check exception guarantee
|
||||
optional& operator=(optional&& rhs) noexcept {
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_value = std::move(rhs.m_value);
|
||||
}
|
||||
else {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.m_value));
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (rhs.has_value()) {
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.m_value));
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO conditionally delete, check exception guarantee
|
||||
template <class U = T,
|
||||
detail::enable_assign_forward<T,U>* = nullptr>
|
||||
// TODO conditionally delete, check exception guarantee
|
||||
template <class U = T,
|
||||
detail::enable_assign_forward<T,U>* = nullptr>
|
||||
optional& operator=(U&& u) {
|
||||
if (has_value()) {
|
||||
this->m_value = std::forward<U>(u);
|
||||
if (has_value()) {
|
||||
this->m_value = std::forward<U>(u);
|
||||
}
|
||||
else {
|
||||
new (std::addressof(this->m_value)) T (std::forward<U>(u));
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
else {
|
||||
new (std::addressof(this->m_value)) T (std::forward<U>(u));
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO SFINAE, check exception guarantee
|
||||
template <class U, detail::enable_assign_from_other<T,U,const U&>* = nullptr>
|
||||
// TODO check exception guarantee
|
||||
template <class U, detail::enable_assign_from_other<T,U,const U&>* = nullptr>
|
||||
optional& operator=(const optional<U>& rhs) {
|
||||
if (has_value()) {
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_value = rhs.m_value;
|
||||
}
|
||||
else {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (rhs.has_value()) {
|
||||
this->m_value = rhs.m_value;
|
||||
}
|
||||
else {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
new (std::addressof(this->m_value)) T (rhs.m_value);
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (rhs.has_value()) {
|
||||
new (std::addressof(this->m_value)) T (rhs.m_value);
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
// TODO check exception guarantee
|
||||
template <class U, detail::enable_assign_from_other<T,U,U>* = nullptr>
|
||||
optional& operator=(optional<U>&& rhs) {
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_value = std::move(rhs.m_value);
|
||||
}
|
||||
else {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO SFINAE, check exception guarantee
|
||||
template <class U, detail::enable_assign_from_other<T,U,U>* = nullptr>
|
||||
optional& operator=(optional<U>&& rhs) {
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
this->m_value = std::move(rhs.m_value);
|
||||
}
|
||||
else {
|
||||
this->m_value.~T();
|
||||
this->m_has_value = false;
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.m_value));
|
||||
this->m_has_value = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (rhs.has_value()) {
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.m_value));
|
||||
this->m_has_value = true;
|
||||
template <class... Args> T& emplace(Args&&... args) {
|
||||
static_assert(std::is_constructible<T, Args&&...>::value,
|
||||
"T must be constructible with Args");
|
||||
|
||||
*this = nullopt;
|
||||
new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
|
||||
}
|
||||
}
|
||||
|
||||
template <class... Args> T& emplace(Args&&... args) {
|
||||
static_assert(std::is_constructible<T, Args&&...>::value,
|
||||
"T must be constructible with Args");
|
||||
template <class U, class... Args>
|
||||
enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&>
|
||||
emplace(std::initializer_list<U> il, Args&&... args) {
|
||||
*this = nullopt;
|
||||
new (std::addressof(this->m_value)) T(il, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
*this = nullopt;
|
||||
new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <class U, class... Args>
|
||||
tl::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&>
|
||||
emplace(std::initializer_list<U> il, Args&&... args) {
|
||||
*this = nullopt;
|
||||
new (std::addressof(this->m_value)) T(il, std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
// [optional.swap], swap
|
||||
void swap(optional& rhs)
|
||||
noexcept(std::is_nothrow_move_constructible<T>::value && is_nothrow_swappable<T>::value)
|
||||
{
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
using std::swap;
|
||||
swap(value(), rhs.value());
|
||||
// [optional.swap], swap
|
||||
void swap(optional& rhs)
|
||||
noexcept(std::is_nothrow_move_constructible<T>::value && detail::is_nothrow_swappable<T>::value)
|
||||
{
|
||||
if (has_value()) {
|
||||
if (rhs.has_value()) {
|
||||
using std::swap;
|
||||
swap(value(), rhs.value());
|
||||
}
|
||||
else {
|
||||
new (&rhs.m_value) T (std::move(this->m_value));
|
||||
this->m_value.T::~T();
|
||||
}
|
||||
}
|
||||
else {
|
||||
new (&rhs.m_value) T (std::move(this->m_value));
|
||||
this->m_value.T::~T();
|
||||
else if (rhs.has_value()) {
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.m_value));
|
||||
rhs.m_value.T::~T();
|
||||
}
|
||||
}
|
||||
else if (rhs.has_value()) {
|
||||
new (std::addressof(this->m_value)) T (std::move(rhs.m_value));
|
||||
rhs.m_value.T::~T();
|
||||
|
||||
// [optional.observe], observers
|
||||
constexpr const T* operator->() const {
|
||||
return std::addressof(this->m_value);
|
||||
}
|
||||
constexpr T* operator->() {
|
||||
return std::addressof(this->m_value);
|
||||
}
|
||||
constexpr const T& operator*() const& {
|
||||
return this->m_value;
|
||||
}
|
||||
constexpr T& operator*() & {
|
||||
return this->m_value;
|
||||
}
|
||||
constexpr T&& operator*() && {
|
||||
return std::move(this->m_value);
|
||||
}
|
||||
constexpr const T&& operator*() const&& {
|
||||
return std::move(this->m_value);
|
||||
}
|
||||
constexpr explicit operator bool() const noexcept {
|
||||
return this->m_has_value;
|
||||
}
|
||||
constexpr bool has_value() const noexcept {
|
||||
return this->m_has_value;
|
||||
}
|
||||
constexpr const T& value() const& {
|
||||
if (has_value()) return this->m_value;
|
||||
throw bad_optional_access();
|
||||
}
|
||||
constexpr T& value() & {
|
||||
if (has_value()) return this->m_value;
|
||||
throw bad_optional_access();
|
||||
}
|
||||
constexpr T&& value() && {
|
||||
if (has_value()) return std::move(this->m_value);
|
||||
throw bad_optional_access();
|
||||
}
|
||||
constexpr const T&& value() const&& {
|
||||
if (has_value()) return std::move(this->m_value);
|
||||
throw bad_optional_access();
|
||||
}
|
||||
template <class U> constexpr T value_or(U&& u) const& {
|
||||
static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U&&, T>::value,
|
||||
"T must be copy constructible and convertible from U");
|
||||
return has_value() ? value() : static_cast<T>(std::forward<U>(u));
|
||||
}
|
||||
template <class U> constexpr T value_or(U&& u) && {
|
||||
static_assert(std::is_move_constructible<T>::value && std::is_convertible<U&&, T>::value,
|
||||
"T must be move constructible and convertible from U");
|
||||
return has_value() ? value() : static_cast<T>(std::forward<U>(u));
|
||||
}
|
||||
}
|
||||
|
||||
// [optional.observe], observers
|
||||
constexpr const T* operator->() const {
|
||||
return std::addressof(this->m_value);
|
||||
}
|
||||
constexpr T* operator->() {
|
||||
return std::addressof(this->m_value);
|
||||
}
|
||||
constexpr const T& operator*() const& {
|
||||
return this->m_value;
|
||||
}
|
||||
constexpr T& operator*() & {
|
||||
return this->m_value;
|
||||
}
|
||||
constexpr T&& operator*() && {
|
||||
return std::move(this->m_value);
|
||||
}
|
||||
constexpr const T&& operator*() const&& {
|
||||
return std::move(this->m_value);
|
||||
}
|
||||
constexpr explicit operator bool() const noexcept {
|
||||
return this->m_has_value;
|
||||
}
|
||||
constexpr bool has_value() const noexcept {
|
||||
return this->m_has_value;
|
||||
}
|
||||
constexpr const T& value() const& {
|
||||
if (has_value()) return this->m_value;
|
||||
throw bad_optional_access();
|
||||
}
|
||||
constexpr T& value() & {
|
||||
if (has_value()) return this->m_value;
|
||||
throw bad_optional_access();
|
||||
}
|
||||
constexpr T&& value() && {
|
||||
if (has_value()) return std::move(this->m_value);
|
||||
throw bad_optional_access();
|
||||
}
|
||||
constexpr const T&& value() const&& {
|
||||
if (has_value()) return std::move(this->m_value);
|
||||
throw bad_optional_access();
|
||||
}
|
||||
template <class U> constexpr T value_or(U&& u) const& {
|
||||
static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U&&, T>::value,
|
||||
"T must be copy constructible and convertible from U");
|
||||
return has_value() ? value() : static_cast<T>(std::forward<U>(u));
|
||||
}
|
||||
template <class U> constexpr T value_or(U&& u) && {
|
||||
static_assert(std::is_move_constructible<T>::value && std::is_convertible<U&&, T>::value,
|
||||
"T must be move constructible and convertible from U");
|
||||
return has_value() ? value() : static_cast<T>(std::forward<U>(u));
|
||||
}
|
||||
// [optional.mod], modifiers
|
||||
void reset() noexcept;
|
||||
|
||||
// [optional.mod], modifiers
|
||||
void reset() noexcept;
|
||||
private:
|
||||
|
||||
private:
|
||||
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user