Cache.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_RESOURCE_CACHE_HPP_
#define GALAXY_RESOURCE_CACHE_HPP_
 
#include <ankerl/unordered_dense.h>
#include <entt/locator/locator.hpp>
 
#include "galaxy/fs/VirtualFileSystem.hpp"
#include "galaxy/logging/Log.hpp"
#include "galaxy/math/FNV1a.hpp"
#include "galaxy/resource/Loader.hpp"
 
namespace galaxy
{
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    class Cache final
    {
        using Map = ankerl::unordered_dense::map<std::uint64_t, std::shared_ptr<Resource>>;
 
    public:
        Cache() noexcept;
 
        ~Cache();
 
        void load_file(const std::string& file);
 
        template<typename... Args>
        void load_resource(const std::string& key, Args&&... args);
 
        void load_folder(const std::string& dir);
 
        void insert(const std::string& key, std::shared_ptr<Resource> resource) noexcept;
 
        [[nodiscard]]
        std::shared_ptr<Resource> get(const std::string& key) noexcept;
 
        [[nodiscard]]
        bool has(const std::string& key) noexcept;
 
        void clear();
 
        [[nodiscard]]
        bool empty() const noexcept;
 
        [[nodiscard]]
        std::size_t size() const noexcept;
 
        [[nodiscard]]
        const Map& cache() const noexcept;
 
    private:
        Cache(const Cache&) = delete;
 
        Cache(Cache&&) = delete;
 
        Cache& operator=(const Cache&) = delete;
 
        Cache& operator=(Cache&&) = delete;
 
    private:
        SpecLoader m_loader;
 
        Map m_cache;
    };
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline Cache<Resource, SpecLoader>::Cache() noexcept
    {
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline Cache<Resource, SpecLoader>::~Cache()
    {
        clear();
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline void Cache<Resource, SpecLoader>::load_file(const std::string& file)
    {
        const auto hash = math::fnv1a(file.c_str());
        if (!m_cache.contains(hash))
        {
            m_cache[hash] = m_loader(file);
        }
        else
        {
            GALAXY_LOG(GALAXY_WARN, "Tried to load duplicate resource: '{0}'.", file);
        }
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    template<typename... Args>
    inline void Cache<Resource, SpecLoader>::load_resource(const std::string& key, Args&&... args)
    {
        const auto hash = math::fnv1a(key.c_str());
        if (!m_cache.contains(hash))
        {
            m_cache[hash] = m_loader(std::forward<Args>(args)...);
        }
        else
        {
            GALAXY_LOG(GALAXY_WARN, "Tried to load duplicate resource: '{0}'.", key);
        }
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline void Cache<Resource, SpecLoader>::load_folder(const std::string& dir)
    {
        auto& fs = entt::locator<VirtualFileSystem>::value();
        for (const auto& file : fs.list(dir))
        {
            load_file(file);
        }
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline void Cache<Resource, SpecLoader>::insert(const std::string& key, std::shared_ptr<Resource> resource) noexcept
    {
        const auto hash = math::fnv1a(key.c_str());
        if (!m_cache.contains(hash))
        {
            m_cache[hash] = resource;
        }
        else
        {
            GALAXY_LOG(GALAXY_WARN, "Tried to load duplicate resource: '{0}'.", key);
        }
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline std::shared_ptr<Resource> Cache<Resource, SpecLoader>::get(const std::string& key) noexcept
    {
        const auto hash = math::fnv1a(key.c_str());
        if (m_cache.contains(hash))
        {
            return m_cache[hash];
        }
 
        return nullptr;
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline bool Cache<Resource, SpecLoader>::has(const std::string& key) noexcept
    {
        const auto hash = math::fnv1a(key.c_str());
        return m_cache.contains(hash);
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline void Cache<Resource, SpecLoader>::clear()
    {
        m_cache.clear();
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline bool Cache<Resource, SpecLoader>::empty() const noexcept
    {
        return size() == 0;
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline std::size_t Cache<Resource, SpecLoader>::size() const noexcept
    {
        return m_cache.size();
    }
 
    template<typename Resource, typename SpecLoader>
    requires meta::not_memory<Resource> && meta::is_class<Resource> && meta::is_instance_of_v<SpecLoader, Loader>
    inline const Cache<Resource, SpecLoader>::Map& Cache<Resource, SpecLoader>::cache() const noexcept
    {
        return m_cache;
    }
} // namespace galaxy
 
#endif