ResourceManager.inl

Go to the documentation of this file.

namespace Ult
{
 
template<typename A, typename HANDLE>
ResourceManager<A,HANDLE>::ResourceManager(int hashSize) :
    mObjects(),
    mResourceHash(nullptr)
{
    if (hashSize > 0) {
        mResourceHash = new HashTable<ResourceName>(hashSize);
    }
}
 
template<typename A, typename HANDLE>
ResourceManager<A,HANDLE>::~ResourceManager()
{
    DeleteAllMemory();
}
 
template<typename A, typename HANDLE>
bool ResourceManager<A,HANDLE>::Create(A* res, const char* name, HANDLE* handle)
{
    int index = -1;
    if (res == nullptr) {
        return false;
    }
    if (handle) {
        handle->Nullify();
    }
    index = GetRegisteredIndex(name);
    if (index == -1) {
        mObjects.push_back(res);
        index = (int)mObjects.size() - 1;
        if (index < 0) {
            return false;
        }
        SetRegisteredName(name, index);
    }
    if (handle) {
        handle->Initialize(index);
    }
    return true;
}
 
template<typename A, typename HANDLE>
void ResourceManager<A,HANDLE>::Release(HANDLE& handle)
{
    int index = handle.GetIndex();
    if (handle.IsNull()) {
        return;
    }
    handle.Nullify();
}
 
template<typename A, typename HANDLE>
int ResourceManager<A,HANDLE>::GetRegisteredIndex(const char* name)
{
    HashItem<ResourceName> tmpHashItem;
    ResourceName tmpRes;
    int key = -1;
    if (name == nullptr) {
        return -1;
    }
    std::string str(name);
    if (mResourceHash != nullptr) {
        key = mResourceHash->HashFunction(str);
        tmpHashItem = mResourceHash->Find(key);
        if (tmpHashItem.GetKey() != -1) {
            return tmpHashItem.GetObject().GetIndex();
        }
    }
    return -1;
}
 
template<typename A, typename HANDLE>
A* ResourceManager<A,HANDLE>::GetResource(const HANDLE& handle)
{
    int index = handle.GetIndex();
    if (index >= GetSize() || index <= HANDLE::NULL_HANDLE) {
        return nullptr;
    }
    return mObjects[index];
}
 
template<typename A, typename HANDLE>
int ResourceManager<A,HANDLE>::GetSize()
{
    return (int)mObjects.size();
}
 
template<typename A, typename HANDLE>
std::vector<A*>* ResourceManager<A,HANDLE>::GetObjects()
{
    return &mObjects;
}
 
template<typename A, typename HANDLE>
void ResourceManager<A,HANDLE>::SetRegisteredName(const char* name, int index)
{
    if (!name || !mResourceHash|| index < 0) {
        return;
    }
    HashItem<ResourceName> hashItem;
    std::string str(name);
    
    ResourceName resName;
    resName.SetName(name);
    resName.SetIndex(index);
    
    hashItem.SetKey(mResourceHash->HashFunction(str));
    hashItem.SetObj(resName);
    
    mResourceHash->Insert(hashItem);
}
 
template<typename A, typename HANDLE>
void ResourceManager<A,HANDLE>::DeleteAllMemory()
{
    for (int i = 0; i < GetSize(); i++) {
        if (mObjects[i]) {
            delete mObjects[i];
            mObjects[i] = nullptr;
        }
    }
    if (mResourceHash) {
        delete mResourceHash;
        mResourceHash = nullptr;
    }
}
    
} // namespace Ult