Manager.hpp

#pragma once
#include "Ref.hpp"
#include "WeakRef.hpp"
#include "SpinLock.hpp"
#include "Map.hpp"
#include "Vector.hpp"
#include <tuple>
 
namespace RavEngine {
 
    struct CacheBase {
        using unique_key_t = uint32_t;
    };
 
template<typename key_t, typename T, bool keyIsConstructionParam = true>
struct GenericWeakReadThroughCache : public CacheBase{
 
protected:
    static UnorderedMap<std::tuple<key_t, unique_key_t>,WeakRef<T>> items;
    static SpinLock mtx;
public:
    template<typename ... A>
    static inline Ref<T> Get(const key_t& str, A ... extras){
        return GetWithKey(str, 0, extras...);
    }
 
    template<typename ... A>
    static inline Ref<T> GetWithKey(const key_t& str, unique_key_t unique_key, A ... extras) {
        auto key = std::tuple<key_t, unique_key_t>(str, unique_key);
       
        //TODO: optimize
        std::lock_guard guard(mtx);
        if (items.contains(key)) {
            auto value = items.at(key).lock();
            if (auto ptr = value) {
                return ptr;
            }
        }
        Ref<T> m;
        if constexpr (keyIsConstructionParam) {
            m = std::make_shared<T>(str, extras...);
        }
        else {
            m = std::make_shared<T>(extras...);
        }
        items[key] = m;
        return m;
    }
 
    static void Compact(){
        RavEngine::Vector<std::tuple<std::string, unique_key_t>> toremove;
        for(const auto& entry : items){
            if (entry.second.expired()){
                toremove.push_back(entry.first);
            }
        }
        for(const auto& c : toremove){
            items.erase(c);
        }
    }
    
    static void Clear(){
        std::lock_guard guard(mtx);
        items.clear();
    }
};
}
template<typename key, typename T, bool keyIsConstructionParam>
RavEngine::SpinLock RavEngine::GenericWeakReadThroughCache<key,T,keyIsConstructionParam>::mtx;
 
template<typename key,typename T, bool keyIsConstructionParam>
RavEngine::UnorderedMap<std::tuple<key, RavEngine::CacheBase::unique_key_t>, WeakRef<T>> RavEngine::GenericWeakReadThroughCache<key, T, keyIsConstructionParam>::items;