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 "galaxy/core/ServiceLocator.hpp"
#include "galaxy/fs/VirtualFileSystem.hpp"
#include "galaxy/math/FNV1a.hpp"
#include "galaxy/meta/Concepts.hpp"
 
namespace galaxy
{
    namespace resource
    {
        template<meta::not_memory Resource, meta::not_memory Loader>
        // requires meta::is_class < Resource>&& meta::is_loader < Loader, Resource>
        class Cache final
        {
            using CacheType = ankerl::unordered_dense::map<std::uint64_t, std::unique_ptr<Resource>>;
 
        public:
            inline Cache() noexcept
            {
            }
 
            inline ~Cache()
            {
                clear();
            }
 
            inline void load(const std::string& file)
            {
                m_keys.push_back(file);
                m_cache[hash(file)] = std::move(m_loader(file));
            }
 
            inline void load_folder(const std::string& dir)
            {
                clear();
 
                for (const auto& file : core::ServiceLocator<fs::VirtualFileSystem>::ref().list(dir))
                {
                    load(file);
                }
            }
 
            inline void insert(std::string_view id, std::unique_ptr<Resource>& resource)
            {
                const auto hashed = hash(id);
                if (!m_cache.contains(hashed))
                {
                    m_cache[hashed] = std::move(resource);
                }
                else
                {
                    GALAXY_LOG(GALAXY_WARNING, "Tried to load duplicate resource '{0}'.", id);
                }
            }
 
            [[nodiscard]]
            inline Resource* get(std::string_view id)
            {
                const auto hashed = hash(id);
 
                if (m_cache.contains(hashed))
                {
                    return m_cache[hashed].get();
                }
 
                return nullptr;
            }
 
            inline void clear()
            {
                m_cache.clear();
            }
 
            [[nodiscard]]
            inline bool has(std::string_view id)
            {
                return m_cache.contains(hash(id));
            }
 
            [[nodiscard]]
            inline bool empty() const
            {
                return size() == 0;
            }
 
            [[nodiscard]]
            inline std::size_t size() const
            {
                return m_cache.size();
            }
 
            [[nodiscard]]
            inline const CacheType& cache() const
            {
                return m_cache;
            }
 
            [[nodiscard]]
            inline const meta::vector<std::string>& keys()
            {
                return m_keys;
            }
 
        private:
            Cache(const Cache&) = delete;
 
            Cache(Cache&&) = delete;
 
            Cache& operator=(const Cache&) = delete;
 
            Cache& operator=(Cache&&) = delete;
 
            inline std::uint64_t hash(std::string_view str)
            {
                const auto hash = math::fnv1a_64(str.data());
                return hash;
            }
 
        private:
            Loader m_loader;
 
            CacheType m_cache;
 
            meta::vector<std::string> m_keys;
        };
    } // namespace resource
} // namespace galaxy
 
#endif