resource.hpp

#ifndef ENTT_RESOURCE_RESOURCE_HPP
#define ENTT_RESOURCE_RESOURCE_HPP
 
#include <compare>
#include "../stl/concepts.hpp"
#include "../stl/memory.hpp"
#include "../stl/utility.hpp"
#include "fwd.hpp"
 
namespace entt {

template<typename Type>
class resource {
    template<typename>
    friend class resource;
 
public:
    using element_type = Type;
    using handle_type = stl::shared_ptr<element_type>;

    resource() noexcept
        : value{} {}

    explicit resource(handle_type res) noexcept
        : value{stl::move(res)} {}

    resource(const resource &) noexcept = default;

    resource(resource &&) noexcept = default;

    template<typename Other>
    resource(const resource<Other> &other, element_type &res) noexcept
        : value{other.value, stl::addressof(res)} {}

    template<typename Other>
    requires (!stl::same_as<Type, Other> && stl::constructible_from<Type &, Other &>)
    resource(const resource<Other> &other) noexcept
        : value{other.value} {}

    template<typename Other>
    requires (!stl::same_as<Type, Other> && stl::constructible_from<Type &, Other &>)
    resource(resource<Other> &&other) noexcept
        : value{stl::move(other.value)} {}

    ~resource() = default;

    resource &operator=(const resource &) noexcept = default;

    resource &operator=(resource &&) noexcept = default;

    template<typename Other>
    requires (!stl::same_as<Type, Other> && stl::constructible_from<Type &, Other &>)
    resource &operator=(const resource<Other> &other) noexcept {
        value = other.value;
        return *this;
    }

    template<typename Other>
    requires (!stl::same_as<Type, Other> && stl::constructible_from<Type &, Other &>)
    resource &operator=(resource<Other> &&other) noexcept {
        value = stl::move(other.value);
        return *this;
    }

    void swap(resource &other) noexcept {
        using stl::swap;
        swap(value, other.value);
    }

    [[nodiscard]] element_type &operator*() const noexcept {
        return *value;
    }

    [[nodiscard]] operator element_type &() const noexcept {
        return *value;
    }

    [[nodiscard]] element_type *operator->() const noexcept {
        return value.get();
    }

    [[nodiscard]] explicit operator bool() const noexcept {
        return static_cast<bool>(value);
    }

    template<typename Other>
    [[nodiscard]] bool operator==(const resource<Other> &other) const noexcept {
        return (value == other.value);
    }

    template<typename Other>
    [[nodiscard]] auto operator<=>(const resource<Other> &other) const noexcept {
        return (value <=> other.value);
    }

    void reset() {
        value.reset();
    }

    void reset(handle_type other) {
        value = stl::move(other);
    }

    [[nodiscard]] handle_type handle() const noexcept {
        return value;
    }
 
private:
    handle_type value;
};
 
} // namespace entt
 
#endif