resource.hpp

#ifndef ENTT_RESOURCE_RESOURCE_HPP
#define ENTT_RESOURCE_RESOURCE_HPP
 
#include <memory>
#include <type_traits>
#include <utility>
#include "../config/config.h"
#include "fwd.hpp"
 
namespace entt {
 
template<typename Type>
class resource {
    template<typename>
    friend class resource;
 
    template<typename Other>
    static constexpr bool is_acceptable_v = !std::is_same_v<Type, Other> && std::is_constructible_v<Type &, Other &>;
 
public:
    resource() ENTT_NOEXCEPT
        : value{} {}
 
    explicit resource(std::shared_ptr<Type> res) ENTT_NOEXCEPT
        : value{std::move(res)} {}
 
    resource(const resource &) ENTT_NOEXCEPT = default;
 
    resource(resource &&) ENTT_NOEXCEPT = default;
 
    template<typename Other>
    resource(const resource<Other> &other, Type &res) ENTT_NOEXCEPT
        : value{other.value, std::addressof(res)} {}
 
    template<typename Other, typename = std::enable_if_t<is_acceptable_v<Other>>>
    resource(const resource<Other> &other) ENTT_NOEXCEPT
        : value{other.value} {}
 
    template<typename Other, typename = std::enable_if_t<is_acceptable_v<Other>>>
    resource(resource<Other> &&other) ENTT_NOEXCEPT
        : value{std::move(other.value)} {}
 
    resource &operator=(const resource &) ENTT_NOEXCEPT = default;
 
    resource &operator=(resource &&) ENTT_NOEXCEPT = default;
 
    template<typename Other>
    std::enable_if_t<is_acceptable_v<Other>, resource &>
    operator=(const resource<Other> &other) ENTT_NOEXCEPT {
        value = other.value;
        return *this;
    }
 
    template<typename Other>
    std::enable_if_t<is_acceptable_v<Other>, resource &>
    operator=(resource<Other> &&other) ENTT_NOEXCEPT {
        value = std::move(other.value);
        return *this;
    }
 
    [[nodiscard]] Type &operator*() const ENTT_NOEXCEPT {
        return *value;
    }
 
    [[nodiscard]] operator Type &() const ENTT_NOEXCEPT {
        return *value;
    }
 
    [[nodiscard]] Type *operator->() const ENTT_NOEXCEPT {
        return value.get();
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return static_cast<bool>(value);
    }
 
    [[nodiscard]] long use_count() const ENTT_NOEXCEPT {
        return value.use_count();
    }
 
private:
    std::shared_ptr<Type> value;
};
 
template<typename Res, typename Other>
[[nodiscard]] bool operator==(const resource<Res> &lhs, const resource<Other> &rhs) ENTT_NOEXCEPT {
    return (std::addressof(*lhs) == std::addressof(*rhs));
}
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator!=(const resource<ILhs> &lhs, const resource<IRhs> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
} // namespace entt
 
#endif