unique_handle.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2019 - 2023.
// 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)
 
#ifndef SL_UNIQUE_HANDLE_HPP
#define SL_UNIQUE_HANDLE_HPP
 
#pragma once
 
#include <compare>
#include <concepts>
#include <functional>
#include <optional>
#include <utility>
 
#include "Simple-Utility/Config.hpp"
#include "Simple-Utility/concepts/stl_extensions.hpp"
#include "Simple-Utility/nullables/base.hpp"
 
// some of the std::optional interface hasn't been declared constexpr before
#if __cpp_lib_optional >= 202106L
#define SL_UNIQUE_HANDLE_FULL_CONSTEXPR constexpr
#else
#define SL_UNIQUE_HANDLE_FULL_CONSTEXPR
#endif
 
namespace sl
{
    // ReSharper disable once IdentifierTypo
    struct nullhandle_t
    { };
 
    // ReSharper disable once IdentifierTypo
    constexpr nullhandle_t nullhandle{};
 
    using bad_handle_access = std::bad_optional_access;
 
    struct default_delete_action
    {
        constexpr void operator ()(auto&) const noexcept
        { }
    };
 
    namespace detail
    {
        template <class T>
        struct value_validator
        {
            static_assert(std::movable<T>, "The value type must be movable.");
            static_assert(concepts::not_same_as<std::remove_cvref_t<T>, nullhandle_t>, "The value type must not be sl::nullhandle_t.");
 
            using type = T;
        };
 
        template <class T, class TDeleteAction>
        struct delete_action_validator
        {
            static_assert(std::copyable<TDeleteAction>, "The delete action object must be copyable (capturing lambdas are not).");
            static_assert(std::invocable<TDeleteAction, T&>, "The delete action object must be invokable by T&.");
 
            using type = TDeleteAction;
        };
 
        template <class T>
        using type_t = typename T::type;
    }
 
    template <class T>
    concept value = std::movable<T> && concepts::not_same_as<T, nullhandle_t>;
 
    template <class T, class TValue>
    concept delete_action_for = value<TValue>
                            && std::invocable<T, TValue&>
                            && std::copyable<T>;
 
    template <value T, delete_action_for<T> TDeleteAction = default_delete_action>
    class unique_handle
    {
    private:
        template <value T2, delete_action_for<T2> TOtherDeleteAction>
        friend class unique_handle;
 
    public:
        using value_type = T;
        using delete_action_type = TDeleteAction;
 
        constexpr unique_handle() noexcept = default;
 
        constexpr ~unique_handle() noexcept
        {
            invoke_delete_action_if_necessary();
        }
 
        SL_UNIQUE_HANDLE_FULL_CONSTEXPR unique_handle
        (
            unique_handle&& other
        ) noexcept(std::is_nothrow_move_constructible_v<T>
                    && std::is_nothrow_copy_constructible_v<TDeleteAction>)
            : m_Value{ std::exchange(other.m_Value, std::nullopt) },
            m_DeleteAction{ other.m_DeleteAction }
        { }
 
        SL_UNIQUE_HANDLE_FULL_CONSTEXPR unique_handle& operator =
        (
            unique_handle&& other
        ) noexcept(std::is_nothrow_move_constructible_v<T>
                    && std::is_nothrow_move_assignable_v<T>
                    && std::is_nothrow_copy_constructible_v<TDeleteAction>
                    && std::is_nothrow_copy_assignable_v<TDeleteAction>)
        {
            if (this != &other)
            {
                invoke_delete_action_if_necessary();
 
                m_Value = std::exchange(other.m_Value, std::nullopt);
                m_DeleteAction = other.m_DeleteAction;
            }
            return *this;
        }
 
        constexpr void swap
        (
            unique_handle& other
        ) noexcept(std::is_nothrow_move_constructible_v<T>
                    && std::is_nothrow_swappable_v<T>
                    && std::is_nothrow_move_constructible_v<TDeleteAction>
                    && std::is_nothrow_swappable_v<TDeleteAction>)
        {
            using std::swap;
 
            swap(m_Value, other.m_Value);
            swap(m_DeleteAction, other.m_DeleteAction);
        }
 
        unique_handle(const unique_handle&) = delete;
        unique_handle& operator =(const unique_handle&) = delete;
 
        constexpr unique_handle(nullhandle_t, const delete_action_type& deleteAction = delete_action_type()) noexcept
            : m_Value{ std::nullopt },
            m_DeleteAction{ deleteAction }
        { }
 
        SL_UNIQUE_HANDLE_FULL_CONSTEXPR unique_handle& operator =(nullhandle_t) noexcept
        {
            invoke_delete_action_if_necessary();
 
            m_Value = std::nullopt;
            return *this;
        }
 
        constexpr unique_handle(const delete_action_type& deleteAction) noexcept
            : m_Value{ std::nullopt },
            m_DeleteAction{ deleteAction }
        { }
 
        template <concepts::initializes<T> T2>
            requires concepts::not_same_as<std::remove_cvref_t<T2>, unique_handle>
                    && concepts::not_same_as<std::remove_cvref_t<T2>, nullhandle_t>
        explicit (!std::convertible_to<T2&&, T>)
        constexpr unique_handle(T2&& value, const delete_action_type& deleteAction = delete_action_type{})
            : m_Value{ std::forward<T2>(value) },
            m_DeleteAction{ deleteAction }
        { }
 
        template <concepts::assignable_to<T&> T2>
            requires concepts::not_same_as<std::remove_cvref_t<T2>, unique_handle>
                    && concepts::not_same_as<std::remove_cvref_t<T2>, nullhandle_t>
                    && concepts::initializes<std::remove_cvref_t<T2>, T>
        constexpr unique_handle& operator =(T2&& value)
        {
            invoke_delete_action_if_necessary();
 
            m_Value = std::forward<T2>(value);
            return *this;
        }
 
        template <class... TArgs>
            requires std::constructible_from<T, TArgs...>
        constexpr explicit unique_handle(std::in_place_t, TArgs&&... args)
            : m_Value{ std::in_place, std::forward<TArgs>(args)... }
        { }
 
        template <class... TArgs>
            requires std::constructible_from<T, TArgs...>
        constexpr explicit unique_handle(std::in_place_t, const delete_action_type& deleteAction, TArgs&&... args)
            : m_Value{ std::in_place, std::forward<TArgs>(args)... },
            m_DeleteAction{ deleteAction }
        { }
 
        template <class... TArgs>
            requires std::constructible_from<T, TArgs...>
        SL_UNIQUE_HANDLE_FULL_CONSTEXPR void emplace(TArgs&&... args)
        {
            m_Value.emplace(std::forward<TArgs>(args)...);
        }
 
        SL_UNIQUE_HANDLE_FULL_CONSTEXPR void reset() noexcept
        {
            invoke_delete_action_if_necessary();
 
            m_Value.reset();
        }
 
        [[nodiscard]]
        constexpr const T& raw() const { return m_Value.value(); }
 
        [[nodiscard]]
        constexpr const T& operator *() const noexcept { return *m_Value; }
 
        [[nodiscard]]
        constexpr const T* operator ->() const noexcept { return &*m_Value; }
 
        [[nodiscard]]
        constexpr explicit operator bool() const noexcept { return m_Value.has_value(); }
 
        [[nodiscard]]
        constexpr bool is_valid() const noexcept { return m_Value.has_value(); }
 
        [[nodiscard]]
        constexpr const delete_action_type& delete_action() const noexcept { return m_DeleteAction; }
 
        template <std::equality_comparable_with<T> T2, class TOtherDeleteAction>
        [[nodiscard]]
        constexpr bool operator ==(const unique_handle<T2, TOtherDeleteAction>& other) const
        {
            return m_Value == other.m_Value;
        }
 
        template <std::three_way_comparable_with<T> T2, class TOtherDeleteAction>
        [[nodiscard]]
        constexpr std::compare_three_way_result_t<T, T2> operator <=>(const unique_handle<T2, TOtherDeleteAction>& other) const
        {
            return m_Value <=> other.m_Value;
        }
 
        template <class T2>
            requires concepts::not_same_as<std::remove_cvref_t<T2>, unique_handle>
                    // do not move into template arg list, as this will result in a template cycle
                    && std::three_way_comparable_with<T, T2>
        [[nodiscard]]
        constexpr std::compare_three_way_result_t<T, T2> operator <=>(const T2& other) const
        {
            return m_Value <=> other;
        }
 
        template <class T2>
            requires concepts::not_same_as<std::remove_cvref_t<T2>, unique_handle>
                    // do not move into template arg list, as this will result in a template cycle
                    && std::equality_comparable_with<T, T2>
        [[nodiscard]]
        constexpr bool operator ==(const T2& other) const
        {
            return m_Value == other;
        }
 
        [[nodiscard]]
        constexpr bool operator ==(nullhandle_t) const noexcept
        {
            return !is_valid();
        }
 
        [[nodiscard]]
        constexpr std::strong_ordering operator <=>(nullhandle_t) const noexcept
        {
            return is_valid() <=> false;
        }
 
    private:
        std::optional<T> m_Value{};
 
        SL_UTILITY_NO_UNIQUE_ADDRESS
        TDeleteAction m_DeleteAction{};
 
        constexpr void invoke_delete_action_if_necessary() noexcept
        {
            if (m_Value)
                std::invoke(m_DeleteAction, *m_Value);
        }
    };
 
    template <class T, class TDeleteAction>
    unique_handle
    (
        T,
        TDeleteAction
    ) -> unique_handle<detail::type_t<detail::value_validator<T>>, detail::type_t<detail::delete_action_validator<T, TDeleteAction>>>;
 
    template <class T>
    unique_handle(T) -> unique_handle<T>;
 
    template <class T, class TDeleteAction>
    struct nullables::traits<unique_handle<T, TDeleteAction>>
    {
        using value_type = typename unique_handle<T, TDeleteAction>::value_type;
        static constexpr nullhandle_t null{ nullhandle };
    };
 
}
 
#endif