polymorphic_optional.hpp

// Copyright Take Vos 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "assert.hpp"
#include "concepts.hpp"
#include <array>
#include <memory>
#include <type_traits>
 
namespace tt {
 
template<typename BaseType, size_t Capacity>
class alignas(16) polymorphic_optional {
public:
    using value_type = BaseType;
    using reference = value_type &;
    using const_reference = value_type const &;
    using pointer = value_type *;
    using const_pointer = value_type const *;
 
    static constexpr size_t capacity = Capacity;
 
    ~polymorphic_optional()
    {
        reset();
    }
 
    polymorphic_optional(polymorphic_optional const &other) = delete;
    polymorphic_optional(polymorphic_optional &&other) = delete;
    polymorphic_optional &operator=(polymorphic_optional const &other) = delete;
    polymorphic_optional &operator=(polymorphic_optional &&other) = delete;
 
    [[nodiscard]] constexpr polymorphic_optional() noexcept : _state(state::empty) {}
 
    template<typename Other>
    requires(is_different_v<Other, value_type>) [[nodiscard]] polymorphic_optional(Other &&other) noexcept
    {
        static_assert(std::is_base_of_v<value_type, std::remove_cvref_t<Other>>);
        _state = state::empty;
        emplace<std::remove_cvref_t<Other>>(std::forward<Other>(other));
    }
 
    template<decayed_derived_from<value_type> Other>
    polymorphic_optional &operator=(Other &&other) noexcept
    {
        emplace<std::remove_cvref_t<Other>>(std::forward<Other>(other));
        return *this;
    }
 
    template<derived_from<value_type> T, typename... Args>
    reference emplace(Args &&...args) noexcept
    {
        reset();
 
        pointer r;
        if (sizeof(T) <= capacity) {
            r = new (_value.buffer.data()) T(std::forward<Args>(args)...);
            _state = state::internal;
 
        } else {
            r = _value.pointer = new T(std::forward<Args>(args)...);
            _state = state::external;
        }
        tt_axiom(r != nullptr);
        return *r;
    }
 
    [[nodiscard]] bool has_value() const noexcept
    {
        return _state != state::empty;
    }
 
    [[nodiscard]] operator bool() const noexcept
    {
        return has_value();
    }
 
    void reset() noexcept
    {
        if (_state != state::empty) {
            [[unlikely]] reset_deep();
        }
    }
 
    [[nodiscard]] const_reference value() const &noexcept
    {
        if (_state == state::empty) {
            throw std::bad_optional_access();
        }
        return *_pointer();
    }
 
    [[nodiscard]] reference value() &noexcept
    {
        if (_state == state::empty) {
            throw std::bad_optional_access();
        }
        return *_pointer();
    }
 
    [[nodiscard]] const_reference operator*() const noexcept
    {
        tt_axiom(_state != state::empty);
        return *_pointer();
    }
 
    [[nodiscard]] reference operator*() noexcept
    {
        tt_axiom(_state != state::empty);
        return *_pointer();
    }
 
    [[nodiscard]] const_pointer operator->() const noexcept
    {
        return _pointer();
    }
 
    [[nodiscard]] pointer operator->() noexcept
    {
        return _pointer();
    }
 
private:
    enum state { empty, internal, external };
 
    union {
        std::array<std::byte, capacity> buffer;
        pointer pointer;
    } _value;
    state _state;
 
    tt_no_inline void reset_deep() noexcept
    {
        if (_state == state::internal) {
            std::destroy_at(internal_pointer());
        } else if (_state == state::external) {
            delete external_pointer();
        }
        _state = state::empty;
    }
 
    [[nodiscard]] const_pointer internal_pointer() const noexcept
    {
        tt_axiom(_state == state::internal);
        return std::launder(reinterpret_cast<const_pointer>(_value.buffer.data()));
    }
 
    [[nodiscard]] pointer internal_pointer() noexcept
    {
        tt_axiom(_state == state::internal);
        return std::launder(reinterpret_cast<pointer>(_value.buffer.data()));
    }
 
    [[nodiscard]] const_pointer external_pointer() const noexcept
    {
        tt_axiom(_state == state::external);
        return std::launder(_value.pointer);
        ;
    }
 
    [[nodiscard]] pointer external_pointer() noexcept
    {
        tt_axiom(_state == state::external);
        return std::launder(_value.pointer);
        ;
    }
 
    [[nodiscard]] const_pointer _pointer() const noexcept
    {
        switch (_state) {
        case state::internal: return internal_pointer();
        case state::external: return external_pointer();
        case state::empty: return nullptr;
        default: tt_no_default();
        }
    }
 
    [[nodiscard]] pointer _pointer() noexcept
    {
        switch (_state) {
        case state::internal: return internal_pointer();
        case state::external: return external_pointer();
        case state::empty: return nullptr;
        default: tt_no_default();
        }
    }
};
 
} // namespace tt