Optional.hpp

[詳解]

//
//    Optional
//
//    Copyright (c) 2022-2024 udonrobo
//
 
#pragma once
 
#include <Udon/Utility/Platform.hpp>
#include <Udon/Utility/Show.hpp>
#include <type_traits>
#include <new>
 
#if __has_include(<new.h>)
#   include <new.h>
#endif
 
namespace Udon
{
 
#if UDON_PLATFORM_ENABLE_EXCEPTION
    struct BadOptionalAccess : public std::exception
    {
        const char* what() const noexcept override
        {
            return "Bad Optional Access";
        }
    };
    inline void ThrowBadOptionalAccess(bool throwException)
    {
        if (throwException)
        {
            throw BadOptionalAccess{};
        }
    }
#else
    inline void ThrowBadOptionalAccess(bool /* throwException */)
    {
    }
#endif
 
    struct NulloptT
    {
    };
 
    constexpr NulloptT nullopt{};
 
 
    template <typename T>
    class Optional
    {
 
        static_assert(std::is_nothrow_destructible<T>::value, "T must be nothrow destructible");
 
        static_assert(not std::is_same<typename std::remove_cv<T>::type, NulloptT>::value, "T must not be the same as NulloptT");
 
        static_assert(not std::is_array<T>::value, "T must not be an array");
 
        template <typename> friend class Optional;
 
    public:
        using ValueType = T;
 
        constexpr Optional() noexcept
            : mStorage()
            , mHasValue()
        {
        }
 
 
        constexpr Optional(NulloptT)
            : mStorage()
            , mHasValue()
        {
        }
 
 
        template <typename U, typename std::enable_if<std::is_constructible<ValueType, U>::value, std::nullptr_t>::type = nullptr>
        Optional(U&& value) noexcept(std::is_nothrow_constructible<ValueType>::value)
            : mStorage()
            , mHasValue(true)
        {
            ConstructValue(std::forward<U>(value));
        }
 
 
        template <typename U, typename std::enable_if<std::is_constructible<ValueType, const U&>::value, std::nullptr_t>::type = nullptr>
        Optional(const Optional<U>& other) noexcept(std::is_nothrow_constructible<ValueType, U>::value)
            : mStorage()
            , mHasValue(other.mHasValue)
        {
            if (mHasValue)
            {
                ConstructValue(other.mStorage.value);
            }
        }
    
 
        template <typename U, typename std::enable_if<std::is_constructible<ValueType, U&&>::value, std::nullptr_t>::type = nullptr>
        Optional(Optional<U>&& other) noexcept(std::is_nothrow_constructible<ValueType, U>::value)
            : mStorage()
            , mHasValue(other.mHasValue)
        {
            if (mHasValue)
            {
                ConstructValue(std::move(other.mStorage.value));
            }
        }
 
 
        ~Optional() noexcept
        {
            reset();
        }
 
 
        Optional& operator=(NulloptT) noexcept
        {
            reset();
            return *this;
        }
 
 
        // template <typename U>
        template <typename U, typename std::enable_if<std::is_constructible<ValueType, U>::value and std::is_assignable<ValueType, U>::value, std::nullptr_t>::type = nullptr>
        Optional& operator=(U&& value) noexcept(std::is_nothrow_constructible<ValueType, U>::value and std::is_nothrow_assignable<ValueType, U>::value)
        {
            AssignmentValue(std::forward<U>(value));
            return *this;
        }
 
 
        template <typename U, typename std::enable_if<std::is_constructible<ValueType, const U&>::value and std::is_assignable<ValueType, const U&>::value, std::nullptr_t>::type = nullptr>
        Optional& operator=(const Optional<U>& other) noexcept(std::is_nothrow_constructible<ValueType, U>::value and std::is_nothrow_assignable<ValueType, U>::value)
        {
            if (other)
            {
                AssignmentValue(other.value());
            }
            else
            {
                reset();
            }
            return *this;
        }
 
 
        template <typename U, typename std::enable_if<std::is_constructible<ValueType, U&&>::value and std::is_assignable<ValueType, U&&>::value, std::nullptr_t>::type = nullptr>
        Optional& operator=(Optional<U>&& other) noexcept(std::is_nothrow_constructible<ValueType, U>::value and std::is_nothrow_assignable<ValueType, U>::value)
        {
            if (other)
            {
                AssignmentValue(std::move(other.value()));
            }
            else
            {
                reset();
            }
            return *this;
        }
 
 
        friend bool operator==(const Optional& lhs, const Optional& rhs) noexcept
        {
            if (lhs and rhs)
            {
                return *lhs == *rhs;
            }
            if (not lhs and not rhs)
            {
                return true;    // nullopt == nullopt
            }
            return false;
        }
 
        friend bool operator!=(const Optional& lhs, const Optional& rhs) noexcept
        {
            return not(lhs == rhs);
        }
 
        friend bool operator<(const Optional& lhs, const Optional& rhs) noexcept
        {
            if (lhs and rhs)
            {
                return *lhs < *rhs;
            }
            if (not rhs)
            {
                return false;
            }
            return not lhs;
        }
 
        friend bool operator>(const Optional& lhs, const Optional& rhs) noexcept
        {
            return rhs < lhs;
        }
 
        friend bool operator>=(const Optional& lhs, const Optional& rhs) noexcept
        {
            return not(lhs < rhs);
        }
 
        friend bool operator<=(const Optional& lhs, const Optional& rhs) noexcept
        {
            return not(rhs < lhs);
        }
 
 
        explicit constexpr operator bool() const noexcept
        {
            return mHasValue;
        }
 
 
        constexpr bool hasValue() const noexcept
        {
            return mHasValue;
        }
 
 
        ValueType& value() &
        {
            ThrowBadOptionalAccess(not mHasValue);
            return mStorage.value;
        }
 
        const ValueType& value() const&
        {
            ThrowBadOptionalAccess(not mHasValue);
            return mStorage.value;
        }
 
        ValueType&& value() &&
        {
            ThrowBadOptionalAccess(not mHasValue);
            return std::move(mStorage.value);
        }
 
        const ValueType&& value() const&&
        {
            ThrowBadOptionalAccess(not mHasValue);
            return std::move(mStorage.value);
        }
 
        ValueType& operator*() &
        {
            return value();
        }
 
        const ValueType& operator*() const&
        {
            return value();
        }
 
        ValueType&& operator*() &&
        {
            return std::move(*this).value();
        }
 
        const ValueType&& operator*() const&&
        {
            return std::move(*this).value();
        }
 
        ValueType* operator->()
        {
            return &value();
        }
 
        const ValueType* operator->() const
        {
            return &value();
        }
 
        template <typename U>
        constexpr ValueType valueOr(U&& defaultValue) const&
        {
            return mHasValue ? **this : static_cast<ValueType>(std::forward<U>(defaultValue));
        }
 
        template <typename U>
        constexpr ValueType valueOr(U&& defaultValue) &&
        {
            return mHasValue ? std::move(**this) : static_cast<ValueType>(std::forward<U>(defaultValue));
        }
 
 
        void swap(Optional& other) noexcept(/* std::is_nothrow_swappable<ValueType>::value and*/ std::is_nothrow_move_assignable<ValueType>::value)
        {
            if (*this and other)
            {
                std::swap(**this, *other);
            }
            else if (not *this and other)
            {
                mStorage.value = std::move(*other);
                other.reset();
            }
            else if (*this and not other)
            {
                *other = std::move(**this);
                reset();
            }
        }
        
 
        template <typename U = ValueType, typename std::enable_if<std::is_trivially_destructible<U>::value, std::nullptr_t>::type = nullptr>
        void reset() noexcept(std::is_nothrow_destructible<ValueType>::value)
        {
            if (mHasValue)
            {
                mHasValue = false;
            }
        }
 
 
        template <typename U = ValueType, typename std::enable_if<not std::is_trivially_destructible<U>::value, std::nullptr_t>::type = nullptr>
        void reset() noexcept(std::is_nothrow_destructible<ValueType>::value)
        {
            if (mHasValue)
            {
                mStorage.value.~ValueType();
                mHasValue = false;
            }
        }
 
 
        void show() const noexcept
        {
            if (mHasValue)
            {
                Udon::ShowRaw(mStorage.value);
            }
            else
            {
                Udon::ShowRaw("nullopt");
            }
        }
 
#if UDON_PLATFORM_OUTPUT_STREAM == UDON_PLATFORM_OUTPUT_CONSOLE
 
        template <typename CharType>
        friend std::basic_ostream<CharType>& operator<<(std::basic_ostream<CharType>& os, const Optional& opt)
        {
            if (opt)
            {
                return os << *opt;
            }
            else
            {
                return os << "nullopt";
            }
        }
 
#endif
 
    private:
        // 共用体を用いて初期化タイミングを遅延
        union Storage
        {
            struct Dummy
            {
                constexpr Dummy() noexcept {}
            } dummy;
 
            ValueType value;
 
            constexpr Storage() noexcept
                : dummy{}
            {
            }
 
            constexpr Storage(Storage&& other) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
                : value{ std::move(other.value) }
            {
            }
 
            constexpr Storage(const Storage& other) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
                : value{ other.value }
            {
            }
 
            ~Storage() noexcept {}
 
            Storage& operator=(const Storage& other)
            {
                value = other.value;
                return *this;
            }
 
            Storage& operator=(Storage&& other) noexcept(std::is_nothrow_assignable<ValueType, ValueType>::value)
            {
                value = std::move(other.value);
                return *this;
            }
 
        } mStorage{};
 
        bool mHasValue;
 
        template <typename U>
        void ConstructValue(U&& value) noexcept(std::is_nothrow_constructible<ValueType, U>::value)
        {
            new (&mStorage.value) ValueType(std::forward<U>(value));
        }
 
        template <typename U>
        void AssignmentValue(U&& value) noexcept(std::is_nothrow_constructible<ValueType, U>::value and std::is_nothrow_assignable<ValueType, U>::value)
        {
            if (mHasValue)
            {
                mStorage.value = std::forward<U>(value);
            }
            else
            {
                ConstructValue(std::forward<U>(value));
                mHasValue = true;
            }
        }
    };
 
}    // namespace Udon