ResourceHandle.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/UUID.hpp"
 
namespace CeresEngine {
 
    class AbstractResourceHandle;
 
    class ResourceHandleData final {
        friend class ResourceManager;
        friend class AbstractResourceHandle;
        template<typename T> friend class ResourceHandle;
        template<typename T> friend class WeakResourceHandle;
 
    private:
        ResourceManager* mResourceManager = nullptr;
 
        const UUID mUUID;
 
        ResourcePtr mResource;
 
        RefCounter<> mReferenceCounter;
 
        RefCounter<> mStrongReferenceCounter;
 
        Event<void(const HResource&)> didLoadResource;
 
        Event<void(const HResource&)> didUnloadResource;
 
    public:
        explicit ResourceHandleData(ResourceManager& manager, const UUID& uuid, ResourcePtr&& resource = nullptr)
                : mResourceManager(&manager), mUUID(uuid), mResource(std::move(resource)) {}
 
        explicit ResourceHandleData(const UUID& uuid, ResourcePtr&& resource = nullptr) : mUUID(uuid), mResource(std::move(resource)) {}
 
        ~ResourceHandleData();
 
    public:
        [[nodiscard]] const UUID& getUUID() const noexcept { return mUUID; }
 
        [[nodiscard]] Resource* getResource() const noexcept { return mResource.get(); }
 
        [[nodiscard]] const ResourcePtr& getResourcePointer() const noexcept { return mResource; }
 
    private: // Interface for ResourceHandle/WeakResouceHandle
        void strongRetain();
 
        void strongRelease();
 
        void weakRetain();
 
        void weakRelease();
 
    private: // Interface for ResourceManager
        void setResource(ResourcePtr&& resource);
 
        void notifyStrongRelease();
    };
 
    class AbstractResourceHandle {
    protected:
        ResourceHandleData* mData = nullptr;
 
    public:
        AbstractResourceHandle() = default;
        explicit AbstractResourceHandle(ResourceHandleData* data) { set(data); }
        explicit AbstractResourceHandle(SPtr<Resource> resource) noexcept;
 
    public:
        [[nodiscard]] const UUID& getUUID() const noexcept {
            static const UUID nullUUID;
            return mData != nullptr ? mData->getUUID() : nullUUID;
        }
 
        [[nodiscard]] bool isValid() const noexcept { return mData != nullptr; }
 
        [[nodiscard]] Async<HResource> load() const;
 
        [[nodiscard]] bool isLoaded() const noexcept { return mData != nullptr && mData->mResource != nullptr; }
 
        [[nodiscard]] explicit operator bool() const noexcept { return isLoaded(); }
 
        void reset() { set(nullptr); }
 
    protected:
        void set(ResourceHandleData* const data) noexcept {
            if(mData != nullptr) {
                mData->strongRelease();
            }
 
            mData = data;
 
            if(mData != nullptr) {
                mData->strongRetain();
            }
        }
    };
 
    template<typename T> class ResourceHandle final : public AbstractResourceHandle {
        friend class ResourceManager;
        friend class AbstractResourceHandle;
        friend class ResourceHandleData;
        template<typename> friend class ResourceHandle;
        template<typename> friend class WeakResourceHandle;
 
    public:
        ResourceHandle() noexcept = default;
 
        CE_EXPLICIT(false) ResourceHandle(std::nullptr_t) noexcept : ResourceHandle() {}
        ResourceHandle& operator=(std::nullptr_t) {
            set(nullptr);
            return *this;
        }
 
        ResourceHandle(const ResourceHandle& other) { set(other.mData); }
        ResourceHandle& operator=(const ResourceHandle& other) {
            set(other.mData);
            return *this;
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        CE_EXPLICIT(false) ResourceHandle(const ResourceHandle<U>& other) noexcept {
            set(other.mData);
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        ResourceHandle& operator=(const ResourceHandle<U>& other) {
            set(other.mData);
            return *this;
        }
 
        ResourceHandle(ResourceHandle&& other) noexcept { mData = std::exchange(other.mData, nullptr); }
        ResourceHandle& operator=(ResourceHandle&& other) noexcept {
            set(nullptr);
            mData = std::exchange(other.mData, nullptr);
            return *this;
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        CE_EXPLICIT(false) ResourceHandle(ResourceHandle<U>&& other) noexcept {
            mData = std::exchange(other.mData, nullptr);
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        ResourceHandle& operator=(ResourceHandle<U>&& other) {
            set(nullptr);
            mData = std::exchange(other.mData, nullptr);
            return *this;
        }
 
        explicit ResourceHandle(SPtr<T> resource) noexcept : AbstractResourceHandle(std::move(resource)) {}
 
        ~ResourceHandle() noexcept { set(nullptr); }
 
    private:
        explicit ResourceHandle(ResourceHandleData* data) { set(data); }
 
    public:
        [[nodiscard]] T* get() const noexcept { return static_cast<T*>(mData != nullptr ? mData->getResource() : nullptr); }
 
        [[nodiscard]] SPtr<T> getPointer() const noexcept { return mData != nullptr ? std::static_pointer_cast<T>(mData->getResourcePointer()) : nullptr; }
 
        [[nodiscard]] T* operator->() const noexcept {
            CE_ASSERT(mData != nullptr);
            return get();
        }
 
        [[nodiscard]] T& operator*() const noexcept {
            CE_ASSERT(mData != nullptr);
            Resource* const resource = mData->getResource();
            CE_ASSERT(resource != nullptr);
            return *static_cast<T*>(resource);
        }
 
        [[nodiscard]] Async<ResourceHandle<T>> load() const;
 
    public: // Resource load events
        template<typename Func> [[nodiscard]] EventConnection didLoadResource(Func&& func) {
            return mData->didLoadResource.connect(
                [func = std::forward<Func>(func)](const HResource& handle) mutable { std::move(func)(static_resource_cast<T>(handle)); });
        }
 
        template<typename Func> [[nodiscard]] EventConnection didUnloadResource(Func&& func) {
            return mData->didUnloadResource.connect(
                [func = std::forward<Func>(func)](const HResource& handle) mutable { std::move(func)(static_resource_cast<T>(handle)); });
        }
 
    public:
        template<typename U1, typename U2>
        friend bool operator==(const ResourceHandle<U1>& lhs, const ResourceHandle<U2>& rhs) noexcept;
 
        template<typename U1, typename U2>
        friend bool operator!=(const ResourceHandle<U1>& lhs, const ResourceHandle<U2>& rhs) noexcept;
 
        template<typename U> friend bool operator==(const ResourceHandle<U>& lhs, std::nullptr_t) noexcept;
 
        template<typename U> friend bool operator==(std::nullptr_t, const ResourceHandle<U>& rhs) noexcept;
 
        template<typename U> friend bool operator!=(const ResourceHandle<U>& lhs, std::nullptr_t) noexcept;
 
        template<typename U> friend bool operator!=(std::nullptr_t, const ResourceHandle<U>& rhs) noexcept;
 
    public:
        template<typename U, typename V> friend ResourceHandle<U> static_resource_cast(const ResourceHandle<V>& handle);
        template<typename U, typename V> friend ResourceHandle<U> static_resource_cast(ResourceHandle<V>&& handle);
    };
 
    template<typename U1, typename U2>
    inline bool operator==(const ResourceHandle<U1>& lhs, const ResourceHandle<U2>& rhs) noexcept {
        return lhs.mData == rhs.mData;
    }
 
    template<typename U1, typename U2> inline bool operator!=(const ResourceHandle<U1>& lhs, const ResourceHandle<U2>& rhs) noexcept {
        return lhs.mData != rhs.mData;
    }
 
    template<typename U> bool operator==(const ResourceHandle<U>& lhs, std::nullptr_t) noexcept { return lhs.mData == nullptr; }
    template<typename U> bool operator==(std::nullptr_t, const ResourceHandle<U>& rhs) noexcept { return rhs == nullptr; }
    template<typename U> bool operator!=(const ResourceHandle<U>& lhs, std::nullptr_t) noexcept { return lhs.mData != nullptr; }
    template<typename U> bool operator!=(std::nullptr_t, const ResourceHandle<U>& rhs) noexcept { return rhs != nullptr; }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename U, typename V> ResourceHandle<U> static_resource_cast(const ResourceHandle<V>& handle) { return ResourceHandle<U>(handle.mData); }
    template<typename U, typename V> ResourceHandle<U> static_resource_cast(ResourceHandle<V>&& handle) { return ResourceHandle<U>(std::move(handle.mData)); }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> Async<ResourceHandle<T>> ResourceHandle<T>::load() const {
        return AbstractResourceHandle::load() | [](const HResource& resource) {
            return static_resource_cast<T>(resource);
        };
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> class WeakResourceHandle final {
        friend class ResourceManager;
 
    private:
        ResourceHandleData* mData = nullptr;
 
    public:
        WeakResourceHandle() noexcept = default;
 
        CE_EXPLICIT(false) WeakResourceHandle(std::nullptr_t) noexcept : mData(nullptr) {}
        WeakResourceHandle& operator=(std::nullptr_t) {
            set(nullptr);
            return *this;
        }
 
        WeakResourceHandle(const WeakResourceHandle& other) { set(other.mData); }
        WeakResourceHandle& operator=(const WeakResourceHandle& other) {
            set(other.mData);
            return *this;
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        CE_EXPLICIT(false) WeakResourceHandle(const WeakResourceHandle<U>& other) noexcept {
            set(other.mData);
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        WeakResourceHandle& operator=(const WeakResourceHandle<U>& other) {
            set(other.mData);
            return *this;
        }
 
        WeakResourceHandle(WeakResourceHandle&& other) noexcept { mData = std::exchange(other.mData, nullptr); }
        WeakResourceHandle& operator=(WeakResourceHandle&& other) noexcept {
            set(nullptr);
            mData = std::exchange(other.mData, nullptr);
            return *this;
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        CE_EXPLICIT(false) WeakResourceHandle(WeakResourceHandle<U>&& other) noexcept {
            mData = std::exchange(other.mData, nullptr);
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        WeakResourceHandle& operator=(WeakResourceHandle<U>&& other) {
            set(nullptr);
            mData = std::exchange(other.mData, nullptr);
            return *this;
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        CE_EXPLICIT(false) WeakResourceHandle(const ResourceHandle<U>& other) noexcept {
            set(other.mData);
        }
 
        template<typename U>
            requires(std::is_convertible_v<U*, T*>)
        WeakResourceHandle& operator=(const ResourceHandle<U>& other) {
            set(other.mData);
            return *this;
        }
 
        ~WeakResourceHandle() noexcept { set(nullptr); }
 
    private:
        explicit WeakResourceHandle(ResourceHandleData* data) { set(data); }
 
    public:
        [[nodiscard]] ResourceHandle<T> lock() const noexcept { return ResourceHandle<T>(mData); }
 
    public:
        [[nodiscard]] const UUID& getUUID() const noexcept {
            static UUID empty;
            if(mData == nullptr) {
                return empty;
            }
 
            return mData->getUUID();
        }
 
    private:
        void set(ResourceHandleData* data) noexcept {
            if(mData != nullptr) {
                mData->weakRelease();
            }
 
            mData = data;
 
            if(mData != nullptr) {
                mData->weakRetain();
            }
        }
 
    public:
        template<typename U, typename V> friend WeakResourceHandle<U> static_resource_cast(const WeakResourceHandle<V>& handle);
        template<typename U, typename V> friend WeakResourceHandle<U> static_resource_cast(WeakResourceHandle<V>&& handle);
    };
 
    template<typename U, typename V> WeakResourceHandle<U> static_resource_cast(const WeakResourceHandle<V>& handle) {
        return WeakResourceHandle<U>(handle.mData);
    }
 
    template<typename U, typename V> WeakResourceHandle<U> static_resource_cast(WeakResourceHandle<V>&& handle) {
        return WeakResourceHandle<U>(std::move(handle.mData));
    }
 
} // namespace CeresEngine
 
template<typename T> struct std::hash<CeresEngine::ResourceHandle<T>> final {
    using HashedType = CeresEngine::ResourceHandle<T>;
    size_t operator()(const HashedType& type) const {
        using CeresEngine::hash;
        return hash(type.getUUID());
    }
};