tb_resource_cache.hpp

#ifndef _TurtleBraines_ResourceCache_hpp
#define _TurtleBraines_ResourceCache_hpp

#include <turtle_brains/core/tb_noncopyable.hpp>
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_types.hpp>

#include <vector>
#include <utility>
#include <unordered_map>
#include <functional>

namespace TurtleBrains
{
    namespace Core
    {
        template <typename ResourceType, typename HandleType> class ResourceCache : public tbCore::Noncopyable
        {
        public:
            static HandleType InvalidResource(void);

            HandleType CreateResource(const ResourceType& resource, const tbCore::tbString& 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 tbCore::tbString& resourceName) const;

            bool IsValidHandle(const HandleType& handle) const;

            size_t ForEachValidResource(std::function<void(ResourceType&, HandleType)> callbackFunction)
            {
                size_t currentIndex = 0;
                size_t validResourceCount = 0;
                for (auto& resourcePair : mResources)
                {
                    if (resourcePair.first > 0)
                    {
                        callbackFunction(resourcePair.second, HandleType(currentIndex));
                        ++validResourceCount;
                    }

                    ++currentIndex;
                }
                return validResourceCount;
            }

        private:
            std::unordered_map<tbCore::tbString, HandleType> mResourceCache;
            std::vector<std::pair<int, ResourceType>> mResources;
        };

    }; /* namespace Core */
}; /* namespace TurtleBrains */

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 tbCore::tbString& resourceName)
{
    //does resourceName already point to something [this maybe required elsewhere].
    const auto& resourceIterator = mResourceCache.find(resourceName);
    if (resourceIterator == mResourceCache.end())
    {
        size_t 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<tbCore::tbString, HandleType>::value_type(resourceName, searchedHandle));
            mResourceCache.emplace(resourceName, HandleType(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 tbCore::tbString& 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 /* _TurtleBraines_ResourceCache_hpp */