ResourceManager.h

#ifndef HB_RESOURCE_MANAGER_H
#define HB_RESOURCE_MANAGER_H
#include <unordered_map>
#include "Log.h"

namespace hb
{
    template <typename ManagerType, typename ResourceType, typename ResourceId, typename Hash = std::hash<ResourceId>>
    class ResourceManager
    {
    public:
        static ManagerType* instance()
        {
            if (s_instance == nullptr)
                s_instance = new ManagerType();
            return s_instance;
        }
        ResourceManager()
        {
            m_resource_count = 0;
        }
        ~ResourceManager(){}
        int addResource(const ResourceId& resource_id, const ResourceType& resource)
        {
            int ret = -1;
            if (isLoaded(resource_id))
            {
                ret = m_id_table.find(resource_id)->second;
                m_info_table.find(ret)->second.count++;
            }
            else
            {
                ret = m_resource_count++;
                ResourceInfo ti;
                ti.id = ret;
                ti.count = 1;
                ti.it = m_id_table.insert(std::pair<ResourceId, int>(resource_id, ret)).first;
                ti.data = resource;
                m_info_table.insert(std::pair<int, ResourceInfo>(ret, ti));
            }
            hb_assert(m_id_table.size() == m_info_table.size(), "Resource management broke bad");
            return ret;
        }
        virtual void release(int id)
        {
            auto i = m_info_table.find(id);
            if (i == m_info_table.end())
                return;
            ResourceInfo& ti = i->second;
            if (--ti.count == 0)
            {
                m_id_table.erase(ti.it);
                m_info_table.erase(id);
            }
            hb_assert(m_id_table.size() == m_info_table.size(), "Resource management broke bad");
        }
        void releaseAll(int id)
        {
            auto i = m_info_table.find(id);
            if (i == m_info_table.end())
                return;
            ResourceInfo& ti = i->second;
            m_id_table.erase(ti.it);
            m_info_table.erase(id);
            hb_assert(m_id_table.size() == m_info_table.size(), "Resource management broke bad");
        }
        const ResourceType& get(int id) const
        {
            auto it = m_info_table.find(id);
            hb_assert(it != m_info_table.end(), "Resource with id " << id << "does not exist.");
            return it->second.data;
        }
        ResourceType& get(int id)
        {
            auto it = m_info_table.find(id);
            hb_assert(it != m_info_table.end(), "Resource with id " << id << "does not exist.");
            return it->second.data;
        }
        const ResourceId& getId(int id) const
        {
            auto it = m_info_table.find(id);
            hb_assert(it != m_info_table.end(), "Resource with id " << id << "does not exist.");
            return it->second.it->first;
        }
        bool isLoaded(int id) const
        {
            return (m_info_table.find(id) != m_info_table.end());
        }
        bool isLoaded(const ResourceId& resource_id) const
        {
            return (m_id_table.find(resource_id) != m_id_table.end());
        }
        bool isLoaded(const ResourceId& resource_id, int& id) const
        {
            auto it = m_id_table.find(resource_id);
            bool ret = (it != m_id_table.end());
            if (ret)
                id = it->second;
            return ret;
        }
        int countResourceUsage(int id) const
        {
            int count = 0;
            auto it = m_info_table.find(id);
            if (it != m_info_table.end())
                count = it->second.count;
            return count;
        }
        int size() const
        {
            return m_id_table.size();
        }
        int resourceCount() const
        {
            return m_resource_count;
        }
        void clear()
        {
            m_resource_count = 0;
            m_id_table.clear();
            m_info_table.clear();
        }

    private:
        static ManagerType* s_instance;
        struct ResourceInfo
        {
            int id, count;
            typename std::unordered_map<ResourceId, int, Hash>::iterator it;
            ResourceType data;
        };

        int m_resource_count;
        std::unordered_map<ResourceId, int, Hash> m_id_table;
        std::unordered_map<int, ResourceInfo> m_info_table;
    };
}
template <typename ManagerType, typename ResourceType, typename ResourceId, typename Hash>
ManagerType* hb::ResourceManager<ManagerType, ResourceType, ResourceId, Hash>::s_instance = nullptr;
#endif