tb_resource_cache.hpp

 
#ifndef TurtleBrains_ResourceCache_hpp
#define TurtleBrains_ResourceCache_hpp
 
#include <turtle_brains/core/tb_noncopyable.hpp>
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_types.hpp>
#include <turtle_brains/core/tb_defines.hpp>
 
#include <vector>
#include <utility>
#include <unordered_map>
#include <functional>
 
namespace TurtleBrains::Core
{
    template<typename ResourceType, typename HandleType> class ResourceCache : public Noncopyable
    {
    public:
        static HandleType InvalidResource(void);
 
        HandleType CreateResource(const ResourceType& resource, const String& resourceName = "");
 
        void DestroyResource(const HandleType& handle);
 
        void ClearCache(void);
 
        void IncrementReferenceOf(const HandleType& handle);
 
        bool DecrementReferenceOf(const HandleType& handle);
 
        ResourceType GetResource(const HandleType& handle) const;
 
        void SetResource(const HandleType& handle, const ResourceType& resource);
 
        const ResourceType& GetResourceReference(const HandleType& handle) const;
 
        ResourceType& GetResourceReference(const HandleType& handle);
 
        HandleType GetResourceHandle(const String& resourceName) const;
 
        bool IsValidHandle(const HandleType& handle) const;
 
        size_t ForEachValidResource(std::function<void(ResourceType&, HandleType)> callbackFunction)
        {
            tbCore::uint32 currentIndex = 0;
            size_t validResourceCount = 0;
            for (auto& resourcePair : mResources)
            {
                if (resourcePair.first > 0)
                {
                    callbackFunction(resourcePair.second, currentIndex);
                    ++validResourceCount;
                }
 
                ++currentIndex;
            }
            return validResourceCount;
        }
 
    private:
        std::unordered_map<String, HandleType> mResourceCache;
        std::vector<std::pair<int, ResourceType>> mResources;
    };
 
}; /* namespace TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> HandleType
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::InvalidResource(void)
{
    return HandleType();
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> HandleType
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::CreateResource(const ResourceType& resource, const String& resourceName)
{
    //does resourceName already point to something [this maybe required elsewhere].
    const auto& resourceIterator = mResourceCache.find(resourceName);
    if (resourceIterator == mResourceCache.end())
    {
        tbCore::uint32 searchedHandle = 0;
        for (; searchedHandle < mResources.size(); ++searchedHandle)
        {
            if (0 == mResources[searchedHandle].first)
            {
                mResources[searchedHandle].first = 1;
                mResources[searchedHandle].second = resource;
                break;
            }
        }
 
        if (searchedHandle == mResources.size())
        {
            mResources.emplace_back(1, resource);
        }
 
        if (false == resourceName.empty())
        {
            tb_error_if(mResourceCache.end() != mResourceCache.find(resourceName), "tbInternalError: Resource name already found in cache!");
            //mResourceCache.insert(std::unordered_map<String, HandleType>::value_type(resourceName, searchedHandle));
            mResourceCache.emplace(resourceName, searchedHandle);
        }
 
        return searchedHandle;
    }
 
    //Going to return to thinking about this, but I believe CreateResource should ALWAYS add a new resource
    //to the cache, and that it was the managers (user) responsibility to ensure the item did NOT exist and
    //if it did exist to increment ref count.
    tb_error("This probably should never happen...");
    IncrementReferenceOf(resourceIterator->second);
    return resourceIterator->second;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> void
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::DestroyResource(const HandleType& handle)
{
    tb_error_if(InvalidResource() == handle, "tbExternalError: Attempting to destroy a resource with an invalid handle.");
    tb_error_if(handle.mValue >= mResources.size(), "tbExternalError: Attempting to destroy a resource with an out-of-bounds handle.");
 
    mResources[handle.mValue].first = 0;
 
    for (auto cacheIter = mResourceCache.begin(), cacheEnd = mResourceCache.end(); cacheIter != cacheEnd; /* in loop */)
    {
        if (cacheIter->second == handle)
        {
            cacheIter = mResourceCache.erase(cacheIter);
        }
        else
        {
            ++cacheIter;
        }
    }
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> void
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::ClearCache(void)
{
    mResources.clear();
    mResourceCache.clear();
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> void
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::IncrementReferenceOf(const HandleType& handle)
{
    tb_error_if(mResources[handle.mValue].first == 0, "tbExternalError: Attempting to increment reference count of object with 0 references.");
    ++mResources[handle.mValue].first;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> bool
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::DecrementReferenceOf(const HandleType& handle)
{
    tb_error_if(mResources[handle.mValue].first == 0, "tbInternalError: Attempting to decrement reference count of object with 0 references.");
    --mResources[handle.mValue].first;
    return 0 == mResources[handle.mValue].first;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> ResourceType
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::GetResource(const HandleType& handle) const
{
    //TODO: TurtleBrains: Could use a tb_with_optimize to remove debug helper checks.
    tb_error_if(InvalidResource() == handle, "tbExternalError: Attempting to access a resource with an invalid handle.");
    tb_error_if(handle.mValue >= mResources.size(), "tbInternalError: Invalid handle, access out of range.");
    return mResources[handle.mValue].second;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> void
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::SetResource(const HandleType& handle, const ResourceType& resource)
{
    tb_error_if(InvalidResource() == handle, "tbExternalError: Attempting to access a resource with an invalid handle.");
    tb_error_if(handle.mValue >= mResources.size(), "tbInternalError: Invalid handle, access out of range.");
    mResources[handle.mValue].second = resource;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> const ResourceType&
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::GetResourceReference(const HandleType& handle) const
{
    //TODO: TurtleBrains: Could use a tb_with_optimize to remove debug helper checks.
    tb_error_if(InvalidResource() == handle, "tbExternalError: Attempting to access a resource with an invalid handle.");
    tb_error_if(handle.mValue >= mResources.size(), "tbInternalError: Invalid handle, access out of range.");
    return mResources[handle.mValue].second;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> ResourceType&
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::GetResourceReference(const HandleType& handle)
{
    //TODO: TurtleBrains: Could use a tb_with_optimize to remove debug helper checks.
    tb_error_if(InvalidResource() == handle, "tbExternalError: Attempting to access a resource with an invalid handle.");
    tb_error_if(handle.mValue >= mResources.size(), "tbInternalError: Invalid handle, access out of range.");
    return mResources[handle.mValue].second;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> HandleType
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::GetResourceHandle(const String& resourceName) const
{
    const auto& resourceIterator = mResourceCache.find(resourceName);
    if (mResourceCache.end() != resourceIterator)
    {
        return resourceIterator->second;
    }
 
    return HandleType();
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
template<typename ResourceType, typename HandleType> bool
TurtleBrains::Core::ResourceCache<ResourceType, HandleType>::IsValidHandle(
    const HandleType& handle) const
{
    if (handle.mValue < mResources.size() && mResources[handle.mValue].first > 0)
    {
        return true;
    }
 
    return false;
}
 
//--------------------------------------------------------------------------------------------------------------------//
 
#endif /* TurtleBrains_ResourceCache_hpp */