optional.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_OPTIONAL_HPP__
#define NEFORCE_CORE_UTILITY_OPTIONAL_HPP__

 
#include <initializer_list>
#include "NeForce/core/exception/exception.hpp"
#include "NeForce/core/functional/invoke.hpp"
#include "NeForce/core/memory/construct.hpp"
#include "NeForce/core/utility/none.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct optional_exception final : memory_exception {
    explicit optional_exception(const char* info = "Access the Null Value of Optional.", const char* type = static_type,
                                const int code = 0) noexcept :
    memory_exception(info, type, code) {}
 
    explicit optional_exception(const exception& e) :
    memory_exception(e) {}
 
    ~optional_exception() override = default;
    static constexpr auto static_type = "optional_exception";
};
 // Exceptions

 
template <typename T>
class optional;
 
 
template <typename T>
struct is_optional : false_type {};
 
template <typename T>
struct is_optional<optional<T>> : true_type {};
 
template <typename T>
NEFORCE_INLINE17 bool is_optional_v = is_optional<T>::value;
 

template <typename T>
class optional : icommon<optional<T>> {
    static_assert(!is_any_of_v<remove_cv_t<T>, none_t, inplace_construct_tag>,
                  "optional do not contains none_t and inplace_construct_tag types.");
    static_assert(is_object_v<T> && !is_array_v<T>, "optional only contains non-array object types.");
    static_assert(!is_reference_v<T>, "optional of reference type should use optional<T&> specialization.");
 
public:
    using value_type = T;
    using pointer = T*;
    using reference = T&;
    using const_pointer = const T*;
    using const_reference = const T&;
 
private:
    template <typename U>
    using is_valid_optional = bool_constant<!is_any_of_v<remove_cv_t<U>, none_t, inplace_construct_tag> &&
                                            is_object_v<U> && !is_array_v<U>>;
 
    template <typename U>
    using convertible_from_optional =
            disjunction<is_constructible<T, const optional<U>&>, is_constructible<T, optional<U>&>,
                        is_constructible<T, const optional<U>&&>, is_constructible<T, optional<U>&&>,
                        is_convertible<const optional<U>&, T>, is_convertible<optional<U>&, T>,
                        is_convertible<const optional<U>&&, T>, is_convertible<optional<U>&&, T>>;
 
    template <typename U>
    using assignable_from_optional =
            disjunction<is_assignable<T&, const optional<U>&>, is_assignable<T&, optional<U>&>,
                        is_assignable<T&, const optional<U>&&>, is_assignable<T&, optional<U>&&>>;
 
    bool have_value_ = false;
    aligned_storage_t<sizeof(T), alignof(T)> storage_;
 
    constexpr T* get_ptr() noexcept { return reinterpret_cast<T*>(&storage_); }
    constexpr const T* get_ptr() const noexcept { return reinterpret_cast<const T*>(&storage_); }
 
public:
    constexpr optional(none_t n = none) noexcept {}

    NEFORCE_CONSTEXPR20 optional& operator=(none_t n) noexcept {
        reset();
        return *this;
    }

    template <typename U, enable_if_t<is_valid_optional<U>::value && !is_same_v<remove_cvref_t<U>, optional> &&
                                              is_constructible_v<T, U> && is_convertible_v<U, T>,
                                      int> = 0>
    constexpr optional(U&& value) noexcept(is_nothrow_constructible_v<T, U>) :
    have_value_(true) {
        _NEFORCE construct(get_ptr(), _NEFORCE forward<U>(value));
    }

    template <typename U, enable_if_t<is_valid_optional<U>::value && !is_same_v<remove_cvref_t<U>, optional> &&
                                              is_constructible_v<T, U> && !is_convertible_v<U, T>,
                                      int> = 0>
    explicit constexpr optional(U&& value) noexcept(is_nothrow_constructible_v<T, U>) :
    have_value_(true) {
        _NEFORCE construct(get_ptr(), _NEFORCE forward<U>(value));
    }

    explicit constexpr optional(const T& value) noexcept(is_nothrow_copy_constructible_v<T>) :
    have_value_(true) {
        _NEFORCE construct(get_ptr(), value);
    }

    explicit constexpr optional(T&& value) noexcept(is_nothrow_move_constructible_v<T>) :
    have_value_(true) {
        _NEFORCE construct(get_ptr(), _NEFORCE move(value));
    }

    template <typename U = T, enable_if_t<!is_same_v<remove_cvref_t<U>, optional> &&
                                                  negation_v<conjunction<is_scalar<T>, is_same<T, decay_t<U>>>> &&
                                                  is_constructible_v<T, U> && is_assignable_v<T&, U>,
                                          int> = 0>
    NEFORCE_CONSTEXPR20 optional& operator=(U&& value) noexcept(is_nothrow_constructible_v<T, U> &&
                                                                is_nothrow_assignable_v<T&, U>) {
        if (have_value_) {
            auto temp = T(_NEFORCE forward<U>(value));
            *get_ptr() = _NEFORCE move(temp);
        } else {
            _NEFORCE construct(get_ptr(), _NEFORCE forward<U>(value));
            have_value_ = true;
        }
        return *this;
    }

    template <typename U, enable_if_t<!is_same_v<T, U> && is_constructible_v<T, const U&> &&
                                              is_convertible_v<const U&, T> && convertible_from_optional<U>::value,
                                      int> = 0>
    constexpr optional(const optional<U>& other) noexcept(is_nothrow_constructible_v<T, const U&>) {
        if (other) {
            _NEFORCE construct(get_ptr(), *other);
            have_value_ = true;
        }
    }

    template <typename U, enable_if_t<!is_same_v<T, U> && is_constructible_v<T, const U&> &&
                                              !is_convertible_v<const U&, T> && convertible_from_optional<U>::value,
                                      int> = 0>
    constexpr explicit optional(const optional<U>& other) noexcept(is_nothrow_constructible_v<T, const U&>) {
        if (other) {
            _NEFORCE construct(get_ptr(), *other);
            have_value_ = true;
        }
    }

    template <typename U = T,
              enable_if_t<!is_same_v<remove_cvref_t<U>, optional> && is_constructible_v<T, const U&> &&
                                  is_assignable_v<T&, const U&> && !convertible_from_optional<U>::value &&
                                  !assignable_from_optional<U>::value,
                          int> = 0>
    NEFORCE_CONSTEXPR20 optional&
    operator=(const optional<U>& other) noexcept(is_nothrow_constructible_v<T, const U&> &&
                                                 is_nothrow_assignable_v<T&, const U&>) {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        if (other) {
            if (have_value_) {
                *get_ptr() = *other;
            } else {
                _NEFORCE construct(get_ptr(), *other);
                have_value_ = true;
            }
        } else {
            reset();
        }
        return *this;
    }

    optional(const optional& other) {
        if (other.have_value_) {
            _NEFORCE construct(get_ptr(), *other);
            have_value_ = true;
        }
    }

    optional& operator=(const optional& other) {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        if (other.have_value_) {
            if (have_value_) {
                *get_ptr() = *other;
            } else {
                _NEFORCE construct(get_ptr(), *other);
                have_value_ = true;
            }
        } else {
            reset();
        }
        return *this;
    }

    template <typename U, enable_if_t<!is_same_v<T, U> && is_constructible_v<T, U> && is_convertible_v<U, T> &&
                                              convertible_from_optional<U>::value,
                                      int> = 0>
    constexpr optional(optional<U>&& other) noexcept(is_nothrow_constructible_v<T, U>) {
        if (other) {
            _NEFORCE construct(get_ptr(), _NEFORCE move(*other));
            have_value_ = true;
        }
    }

    template <typename U, enable_if_t<!is_same_v<T, U> && is_constructible_v<T, U> && !is_convertible_v<U, T> &&
                                              convertible_from_optional<U>::value,
                                      int> = 0>
    constexpr optional(optional<U>&& other) noexcept(is_nothrow_constructible_v<T, U>) {
        if (other) {
            _NEFORCE construct(get_ptr(), _NEFORCE move(*other));
            have_value_ = true;
        }
    }

    template <typename U = T, enable_if_t<!is_same_v<remove_cvref_t<U>, optional> && is_constructible_v<T, U> &&
                                                  is_assignable_v<T&, U> && !convertible_from_optional<U>::value &&
                                                  !assignable_from_optional<U>::value,
                                          int> = 0>
    NEFORCE_CONSTEXPR20 optional& operator=(optional<U>&& other) noexcept(is_nothrow_constructible_v<T, U> &&
                                                                          is_nothrow_assignable_v<T&, U>) {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        if (other) {
            if (have_value_) {
                *get_ptr() = _NEFORCE move(*other);
            } else {
                _NEFORCE construct(get_ptr(), _NEFORCE move(*other));
                have_value_ = true;
            }
        } else {
            reset();
        }
        return *this;
    }

    optional(optional&& other) noexcept {
        if (other.have_value_) {
            _NEFORCE construct(get_ptr(), _NEFORCE move(*other));
            have_value_ = true;
            other.reset();
        }
    }

    optional& operator=(optional&& other) noexcept {
        if (addressof(other) == this) {
            return *this;
        }
 
        if (other.have_value_) {
            if (have_value_) {
                *get_ptr() = _NEFORCE move(*other);
            } else {
                _NEFORCE construct(get_ptr(), _NEFORCE move(*other));
                have_value_ = true;
            }
            other.reset();
        } else {
            reset();
        }
 
        return *this;
    }

    template <typename U, enable_if_t<is_constructible_v<T, U&>, int> = 0>
    constexpr optional(const optional<U&>& other) {
        if (other) {
            _NEFORCE construct(get_ptr(), *other);
            have_value_ = true;
        }
    }

    template <typename U, enable_if_t<is_assignable_v<T&, U&>, int> = 0>
    NEFORCE_CONSTEXPR20 optional& operator=(const optional<U&>& other) {
        if (other) {
            if (have_value_) {
                *get_ptr() = *other;
            } else {
                _NEFORCE construct(get_ptr(), *other);
                have_value_ = true;
            }
        } else {
            reset();
        }
        return *this;
    }

    template <typename... Types, enable_if_t<is_constructible_v<T, Types...>, int> = 0>
    constexpr explicit optional(inplace_construct_tag,
                                Types&&... args) noexcept(is_nothrow_constructible_v<T, Types...>) :
    have_value_(true) {
        _NEFORCE construct(get_ptr(), _NEFORCE forward<Types>(args)...);
    }

    template <typename U, typename... Types,
              enable_if_t<is_constructible_v<T, std::initializer_list<U>&, Types...>, int> = 0>
    constexpr explicit optional(inplace_construct_tag, std::initializer_list<U> ilist, Types&&... args) noexcept(
            is_nothrow_constructible_v<T, std::initializer_list<U>&, Types...>) :
    have_value_(true) {
        _NEFORCE construct(get_ptr(), ilist, _NEFORCE forward<Types>(args)...);
    }

    NEFORCE_CONSTEXPR20 ~optional() noexcept { reset(); }

    template <typename... Types, enable_if_t<is_constructible_v<T, Types...>, int> = 0>
    NEFORCE_CONSTEXPR20 void emplace(Types&&... args) noexcept(is_nothrow_constructible_v<T, Types...>) {
        reset();
        _NEFORCE construct(get_ptr(), _NEFORCE forward<Types>(args)...);
        have_value_ = true;
    }

    template <typename U, typename... Types,
              enable_if_t<is_constructible_v<T, std::initializer_list<U>&, Types...>, int> = 0>
    NEFORCE_CONSTEXPR20 void
    emplace(std::initializer_list<U> ilist,
            Types&&... args) noexcept(is_nothrow_constructible_v<T, std::initializer_list<U>&, Types...>) {
        reset();
        _NEFORCE construct(get_ptr(), ilist, _NEFORCE forward<Types>(args)...);
        have_value_ = true;
    }

    NEFORCE_CONSTEXPR20 void reset() noexcept {
        if (have_value_) {
            _NEFORCE destroy(get_ptr());
            have_value_ = false;
        }
    }

    NEFORCE_NODISCARD constexpr bool has_value() const noexcept { return have_value_; }

    constexpr explicit operator bool() const noexcept { return have_value_; }

    constexpr const_reference value() const& {
        if (!have_value_) {
            NEFORCE_THROW_EXCEPTION(optional_exception("optional have no value"));
        }
        return *get_ptr();
    }

    constexpr reference value() & {
        if (!have_value_) {
            NEFORCE_THROW_EXCEPTION(optional_exception("optional have no value"));
        }
        return *get_ptr();
    }

    constexpr const value_type&& value() const&& {
        if (!have_value_) {
            NEFORCE_THROW_EXCEPTION(optional_exception("optional have no value"));
        }
        return _NEFORCE move(*get_ptr());
    }

    constexpr value_type&& value() && {
        if (!have_value_) {
            NEFORCE_THROW_EXCEPTION(optional_exception("optional have no value"));
        }
        return _NEFORCE move(*get_ptr());
    }

    constexpr value_type value_or(value_type value) const& noexcept(is_nothrow_copy_constructible_v<value_type>) {
        if (!have_value_) {
            return value;
        }
        return *get_ptr();
    }

    constexpr value_type value_or(value_type value) && noexcept(is_nothrow_move_constructible_v<value_type>) {
        if (!have_value_) {
            return value;
        }
        return _NEFORCE move(*get_ptr());
    }

    template <typename F, enable_if_t<is_invocable_v<F> && is_copy_constructible_v<T>, int> = 0>
    constexpr optional or_else(F&& f) const& {
        if (have_value_) {
            return *this;
        }
        return _NEFORCE forward<F>(f)();
    }

    template <typename F, enable_if_t<is_invocable_v<F> && is_move_constructible_v<T>, int> = 0>
    constexpr optional or_else(F&& f) && {
        if (have_value_) {
            return _NEFORCE move(*this);
        }
        return _NEFORCE forward<F>(f)();
    }

    template <typename F>
    constexpr decltype(auto) and_then(F&& f) const& {
        if (have_value_) {
            return _NEFORCE forward<F>(f)(*get_ptr());
        }
        return remove_cvref_t<decltype(f(*get_ptr()))>{};
    }

    template <typename F>
    constexpr decltype(auto) and_then(F&& f) & {
        if (have_value_) {
            return _NEFORCE forward<F>(f)(*get_ptr());
        }
        return remove_cvref_t<decltype(f(*get_ptr()))>{};
    }

    template <typename F>
    constexpr decltype(auto) and_then(F&& f) const&& {
        if (have_value_) {
            return _NEFORCE forward<F>(f)(_NEFORCE move(*get_ptr()));
        }
        return remove_cvref_t<decltype(f(_NEFORCE move(*get_ptr())))>{};
    }

    template <typename F>
    constexpr decltype(auto) and_then(F&& f) && {
        if (have_value_) {
            return _NEFORCE forward<F>(f)(_NEFORCE move(*get_ptr()));
        }
        return remove_cvref_t<decltype(f(_NEFORCE move(*get_ptr())))>{};
    }

    template <typename F>
    constexpr auto transform(F&& f) const& -> optional<remove_cvref_t<decltype(f(*get_ptr()))>> {
        if (have_value_) {
            return _NEFORCE forward<F>(f)(*get_ptr());
        }
        return none;
    }

    template <typename F>
    constexpr auto transform(F&& f) & -> optional<remove_cvref_t<decltype(f(*get_ptr()))>> {
        if (have_value_) {
            return _NEFORCE forward<F>(f)(*get_ptr());
        }
        return none;
    }

    template <typename F>
    constexpr auto transform(F&& f) const&& -> optional<remove_cvref_t<decltype(f(_NEFORCE move(*get_ptr())))>> {
        if (have_value_) {
            return _NEFORCE forward<F>(f)(_NEFORCE move(*get_ptr()));
        }
        return none;
    }

    template <typename F>
    constexpr auto transform(F&& f) && -> optional<remove_cvref_t<decltype(f(_NEFORCE move(*get_ptr())))>> {
        if (have_value_) {
            return _NEFORCE forward<F>(f)(_NEFORCE move(*get_ptr()));
        }
        return none;
    }

    constexpr const_pointer operator->() const noexcept { return get_ptr(); }

    constexpr pointer operator->() noexcept { return get_ptr(); }

    constexpr const_reference operator*() const& noexcept { return *get_ptr(); }

    constexpr reference operator*() & noexcept { return *get_ptr(); }

    constexpr const value_type&& operator*() const&& noexcept { return _NEFORCE move(*get_ptr()); }

    constexpr value_type&& operator*() && noexcept { return _NEFORCE move(*get_ptr()); }

    constexpr bool operator==(const optional& rhs) const noexcept {
        if (have_value_ != rhs.have_value_) {
            return false;
        }
        if (have_value_) {
            return *get_ptr() == *rhs.get_ptr();
        }
        return true;
    }

    constexpr bool operator<(const optional& rhs) const noexcept {
        if (!have_value_ || !rhs.have_value_) {
            return false;
        }
        return *get_ptr() < *rhs.get_ptr();
    }
 
    constexpr bool operator==(none_t) const noexcept { return !have_value_; }
    constexpr bool operator!=(none_t) const noexcept { return have_value_; }
    constexpr bool operator>(none_t) const noexcept { return have_value_; }
    constexpr bool operator<(none_t) const noexcept { return false; }
    constexpr bool operator>=(none_t) const noexcept { return true; }
    constexpr bool operator<=(none_t) const noexcept { return !have_value_; }
 
    friend constexpr bool operator==(none_t, const optional& rhs) noexcept { return !rhs.have_value_; }
    friend constexpr bool operator!=(none_t, const optional& rhs) noexcept { return rhs.have_value_; }
    friend constexpr bool operator>(none_t, const optional&) noexcept { return false; }
    friend constexpr bool operator<(none_t, const optional& rhs) noexcept { return rhs.have_value_; }
    friend constexpr bool operator>=(none_t, const optional& rhs) noexcept { return !rhs.have_value_; }
    friend constexpr bool operator<=(none_t, const optional&) noexcept { return true; }

    constexpr size_t to_hash() const noexcept {
        return have_value_ ? hash<T>()(*get_ptr()) : constants::FNV_OFFSET_BASIS;
    }

    NEFORCE_CONSTEXPR20 void swap(optional& other) noexcept(is_nothrow_move_constructible_v<T> &&
                                                            is_nothrow_swappable_v<T>) {
        if (_NEFORCE addressof(other) == this) {
            return;
        }
        if (have_value_ && other.have_value_) {
            _NEFORCE swap(*this, other);
        } else if (have_value_) {
            other.emplace(_NEFORCE move(**this));
            reset();
        } else if (other.have_value_) {
            optional::emplace(_NEFORCE move(*other));
            other.reset();
        }
    }
};
 

template <typename T>
class optional<T&> : icommon<optional<T&>> {
    static_assert(is_object_v<T> && !is_array_v<T>, "optional<T&> requires T to be an object type.");
 
public:
    using value_type = T&;            
    using reference = T&;             
    using const_reference = const T&; 
    using pointer = T*;               
    using const_pointer = const T*;   
 
private:
    T* ptr_ = nullptr; 
 
    template <typename U>
    using convertible_from_optional_ref = disjunction<is_convertible<U&, T&>, is_convertible<const U&, T&>>;
 
public:
    constexpr optional(none_t n = none) noexcept {}

    constexpr optional(T& value) noexcept :
    ptr_(_NEFORCE addressof(value)) {}

    template <typename U, enable_if_t<is_convertible_v<U&, T&>, int> = 0>
    constexpr optional(U& value) noexcept :
    ptr_(_NEFORCE addressof(value)) {}

    template <typename U, enable_if_t<!is_convertible_v<U&, T&> && is_constructible_v<T&, U&>, int> = 0>
    constexpr explicit optional(U& value) noexcept :
    ptr_(_NEFORCE addressof(value)) {}

    template <typename U, enable_if_t<convertible_from_optional_ref<U>::value, int> = 0>
    constexpr optional(const _NEFORCE optional<U&>& other) noexcept :
    ptr_(other.ptr_) {}

    template <typename U, enable_if_t<!convertible_from_optional_ref<U>::value && is_constructible_v<T&, U&>, int> = 0>
    constexpr explicit optional(const _NEFORCE optional<U&>& other) noexcept :
    ptr_(other.ptr_) {}

    NEFORCE_CONSTEXPR20 optional& operator=(none_t n) noexcept {
        ptr_ = nullptr;
        return *this;
    }

    template <typename U = T, enable_if_t<is_assignable_v<T&, U&>, int> = 0>
    NEFORCE_CONSTEXPR20 optional& operator=(U& value) {
        if (ptr_) {
            *ptr_ = value;
        } else {
            ptr_ = _NEFORCE addressof(value);
        }
        return *this;
    }

    template <typename U, enable_if_t<is_assignable_v<T&, U&>, int> = 0>
    NEFORCE_CONSTEXPR20 optional& operator=(const _NEFORCE optional<U&>& other) {
        if (this != _NEFORCE addressof(other)) {
            if (other.ptr_) {
                if (ptr_) {
                    *ptr_ = *other.ptr_;
                } else {
                    ptr_ = other.ptr_;
                }
            } else {
                ptr_ = nullptr;
            }
        }
        return *this;
    }

    constexpr optional(const optional& other) noexcept = default;

    NEFORCE_CONSTEXPR20 optional& operator=(const optional& other) noexcept = default;

    constexpr optional(optional&& other) noexcept :
    ptr_(other.ptr_) {}

    NEFORCE_CONSTEXPR20 optional& operator=(optional&& other) noexcept {
        ptr_ = other.ptr_;
        return *this;
    }
 
    template <typename... Types>
    constexpr optional(inplace_construct_tag, Types&&...) = delete;

    ~optional() noexcept { ptr_ = nullptr; }

    template <typename U, enable_if_t<is_convertible_v<U&, T&>, int> = 0>
    NEFORCE_CONSTEXPR20 T& emplace(U& value) noexcept {
        ptr_ = _NEFORCE addressof(value);
        return *ptr_;
    }

    template <typename U, enable_if_t<!is_convertible_v<U&, T&> && is_constructible_v<T&, U&>, int> = 0>
    NEFORCE_CONSTEXPR20 T& emplace(U& value) noexcept {
        ptr_ = _NEFORCE addressof(value);
        return *ptr_;
    }

    NEFORCE_CONSTEXPR20 void reset() noexcept { ptr_ = nullptr; }

    NEFORCE_NODISCARD constexpr bool has_value() const noexcept { return ptr_ != nullptr; }

    constexpr explicit operator bool() const noexcept { return ptr_ != nullptr; }

    constexpr const T& value() const& {
        if (!ptr_) {
            NEFORCE_THROW_EXCEPTION(optional_exception("optional have no reference"));
        }
        return *ptr_;
    }

    constexpr T& value() & {
        if (!ptr_) {
            NEFORCE_THROW_EXCEPTION(optional_exception("optional have no reference"));
        }
        return *ptr_;
    }

    constexpr const T&& value() const&& {
        if (!ptr_) {
            NEFORCE_THROW_EXCEPTION(optional_exception("optional have no reference"));
        }
        return *ptr_;
    }

    constexpr T&& value() && {
        if (!ptr_) {
            NEFORCE_THROW_EXCEPTION(optional_exception("optional have no reference"));
        }
        return *ptr_;
    }

    template <typename U>
    constexpr T value_or(U&& value) const& {
        if (ptr_) {
            return *ptr_;
        }
        return _NEFORCE forward<U>(value);
    }

    template <typename U>
    constexpr T value_or(U&& value) && {
        if (ptr_) {
            return _NEFORCE move(*ptr_);
        }
        return _NEFORCE forward<U>(value);
    }

    template <typename F, enable_if_t<is_invocable_v<F>, int> = 0>
    constexpr optional or_else(F&& f) const& {
        if (ptr_) {
            return *this;
        }
        return _NEFORCE forward<F>(f)();
    }

    template <typename F, enable_if_t<is_invocable_v<F>, int> = 0>
    constexpr optional or_else(F&& f) && {
        if (ptr_) {
            return _NEFORCE move(*this);
        }
        return _NEFORCE forward<F>(f)();
    }

    template <typename F>
    constexpr decltype(auto) and_then(F&& f) const& {
        if (ptr_) {
            return _NEFORCE forward<F>(f)(*ptr_);
        }
        return remove_cvref_t<decltype(f(*ptr_))>{};
    }

    template <typename F>
    constexpr decltype(auto) and_then(F&& f) & {
        if (ptr_) {
            return _NEFORCE forward<F>(f)(*ptr_);
        }
        return remove_cvref_t<decltype(f(*ptr_))>{};
    }

    template <typename F>
    constexpr decltype(auto) and_then(F&& f) const&& {
        if (ptr_) {
            return _NEFORCE forward<F>(f)(_NEFORCE move(*ptr_));
        }
        return remove_cvref_t<decltype(f(*ptr_))>{};
    }

    template <typename F>
    constexpr decltype(auto) and_then(F&& f) && {
        if (ptr_) {
            return _NEFORCE forward<F>(f)(_NEFORCE move(*ptr_));
        }
        return remove_cvref_t<decltype(f(*ptr_))>{};
    }

    template <typename F>
    constexpr auto transform(F&& f) const& -> _NEFORCE optional<remove_cvref_t<decltype(f(*ptr_))>> {
        if (ptr_) {
            return _NEFORCE forward<F>(f)(*ptr_);
        }
        return none;
    }

    template <typename F>
    constexpr auto transform(F&& f) & -> _NEFORCE optional<remove_cvref_t<decltype(f(*ptr_))>> {
        if (ptr_) {
            return _NEFORCE forward<F>(f)(*ptr_);
        }
        return none;
    }

    template <typename F>
    constexpr auto transform(F&& f) const&& -> _NEFORCE optional<remove_cvref_t<decltype(f(*ptr_))>> {
        if (ptr_) {
            return _NEFORCE forward<F>(f)(_NEFORCE move(*ptr_));
        }
        return none;
    }

    template <typename F>
    constexpr auto transform(F&& f) && -> _NEFORCE optional<remove_cvref_t<decltype(f(*ptr_))>> {
        if (ptr_) {
            return _NEFORCE forward<F>(f)(_NEFORCE move(*ptr_));
        }
        return none;
    }

    constexpr const T* operator->() const noexcept { return ptr_; }

    constexpr T* operator->() noexcept { return ptr_; }

    constexpr const T& operator*() const& noexcept { return *ptr_; }

    constexpr T& operator*() & noexcept { return *ptr_; }

    constexpr const T&& operator*() const&& noexcept { return *ptr_; }

    constexpr T&& operator*() && noexcept { return *ptr_; }

    constexpr bool operator==(const optional& rhs) const noexcept {
        if (ptr_ == nullptr || rhs.ptr_ == nullptr) {
            return ptr_ == rhs.ptr_;
        }
        return *ptr_ == *rhs.ptr_;
    }

    constexpr bool operator<(const optional& rhs) const noexcept { return ptr_ && rhs.ptr_ && *ptr_ < *rhs.ptr_; }
 
    constexpr bool operator==(none_t) const noexcept { return ptr_ == nullptr; }
    constexpr bool operator!=(none_t) const noexcept { return ptr_ != nullptr; }
    constexpr bool operator>(none_t) const noexcept { return ptr_ != nullptr; }
    constexpr bool operator<(none_t) const noexcept { return false; }
    constexpr bool operator>=(none_t) const noexcept { return true; }
    constexpr bool operator<=(none_t) const noexcept { return ptr_ == nullptr; }
 
    friend constexpr bool operator==(none_t, const optional& rhs) noexcept { return rhs.ptr_ == nullptr; }
    friend constexpr bool operator!=(none_t, const optional& rhs) noexcept { return rhs.ptr_ != nullptr; }
    friend constexpr bool operator>(none_t, const optional&) noexcept { return false; }
    friend constexpr bool operator<(none_t, const optional& rhs) noexcept { return rhs.ptr_ != nullptr; }
    friend constexpr bool operator>=(none_t, const optional& rhs) noexcept { return rhs.ptr_ == nullptr; }
    friend constexpr bool operator<=(none_t, const optional&) noexcept { return true; }

    constexpr size_t to_hash() const noexcept {
        return ptr_ ? hash<remove_cvref_t<T>>()(*ptr_) : constants::FNV_OFFSET_BASIS;
    }

    NEFORCE_CONSTEXPR20 void swap(optional& other) noexcept { _NEFORCE swap(ptr_, other.ptr_); }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename T>
optional(T) -> optional<T>;
#endif
 

template <typename T, enable_if_t<is_constructible_v<decay_t<T>, T>, int> = 0>
constexpr optional<decay_t<T>> make_optional(T&& value) noexcept(is_nothrow_constructible_v<optional<decay_t<T>>, T>) {
    return optional<decay_t<T>>{_NEFORCE forward<T>(value)};
}

template <typename T, typename... Args, enable_if_t<is_constructible_v<T, Args...>, int> = 0>
constexpr optional<T> make_optional(Args&&... args) noexcept(is_nothrow_constructible_v<T, Args...>) {
    return optional<T>{inplace_construct_tag{}, _NEFORCE forward<Args>(args)...};
}

template <typename T, typename U, typename... Args>
constexpr enable_if_t<is_constructible_v<T, std::initializer_list<U>&, Args...>, optional<T>>
make_optional(std::initializer_list<U> ilist,
              Args&&... args) noexcept(is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>) {
    return optional<T>{inplace_construct_tag{}, ilist, _NEFORCE forward<Args>(args)...};
}

template <typename T>
constexpr optional<T&> make_optional(T& value) noexcept {
    return optional<T&>{value};
}

template <typename T>
constexpr optional<remove_reference_t<T>&> make_optional(T&&) = delete;
 

template <typename T>
constexpr const T& get(const optional<T>& opt) {
    return static_cast<const T&>(static_cast<const optional<T>&>(opt).value());
}

template <typename T>
constexpr T& get(optional<T>& opt) {
    return static_cast<T&>(static_cast<optional<T>&>(opt).value());
}

template <typename T>
constexpr const T&& get(const optional<T>&& opt) {
    return static_cast<const T&&>(static_cast<const optional<T>&&>(opt).value());
}

template <typename T>
constexpr T&& get(optional<T>&& opt) {
    return static_cast<T&&>(static_cast<optional<T>&&>(opt).value());
}
 // Optional
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_OPTIONAL_HPP__