ResourceManager Namespace Reference

Typedefs
typedef Resource *(*	loader) (SDL_RWops *rw, const std::string &name)
typedef Resource *(&)	generator(const void *const data)
typedef std::map< std::string, Resource * >	Resources
typedef Resources::iterator	ResourceIterator
typedef Resources::const_iterator	ResourceCIterator

Functions
void	deleteResourceManager ()
void	cleanUp (Resource *const res)
void	cleanProtected ()
bool	cleanOrphans (const bool always)
void	logResource (const Resource *const res)
void	logResources (const std::string &msg)
void	clearDeleted (const bool full)
bool	addResource (const std::string &idPath, Resource *const resource)
Resource *	getFromCache (const std::string &filename, const int variant)
bool	isInCache (const std::string &idPath)
Resource *	getTempResource (const std::string &idPath)
Resource *	getFromCache (const std::string &idPath)
Resource *	get (const std::string &idPath, generator fun, const void *const data)
void	release (Resource *const res)
void	moveToDeleted (Resource *const res)
void	decRefDelete (Resource *const res)
void	deleteInstance ()
void	scheduleDelete (SDL_Surface *const surface)
void	clearScheduled ()
void	clearCache ()
int	calcMemoryLocal ()
int	calcMemoryChilds (const int level)
int	calcMemory (const int level)
int	size ()

Variables
std::set< SDL_Surface * >	deletedSurfaces
Resources	mResources
Resources	mOrphanedResources
std::set< Resource * >	mDeletedResources
time_t	mOldestOrphan = 0
bool	mDestruction = false

Typedef Documentation

generator

typedef Resource*(&) ResourceManager::generator(const void *const data)

Definition at line 39 of file resourcefunctiontypes.h.

loader

typedef Resource*(* ResourceManager::loader) (SDL_RWops *rw, const std::string &name)

Definition at line 37 of file resourcefunctiontypes.h.

ResourceCIterator

typedef Resources::const_iterator ResourceManager::ResourceCIterator

Definition at line 38 of file resourcetypes.h.

ResourceIterator

typedef Resources::iterator ResourceManager::ResourceIterator

Definition at line 37 of file resourcetypes.h.

Resources

typedef std::map<std::string, Resource*> ResourceManager::Resources

Definition at line 36 of file resourcetypes.h.

Function Documentation

addResource()

bool ResourceManager::addResource	(	const std::string &	idPath,
		Resource *const	resource
	)

Definition at line 360 of file resourcemanager.cpp.

{
    if (resource != nullptr)
    {
        resource->incRef();
        resource->mIdPath = idPath;
#ifdef DEBUG_IMAGES
        logger->log("set name %p, %s", static_cast<void*>(resource),
            resource->mIdPath.c_str());
#endif  // DEBUG_IMAGES
 
        mResources[idPath] = resource;
        return true;
    }
    return false;
}

References Resource::incRef(), Logger::log(), logger, Resource::mIdPath, and mResources.

Referenced by AtlasManager::injectToResources().

calcMemory()

int ResourceManager::calcMemory

(

const int

level

)

Definition at line 681 of file resourcemanager.cpp.

{
    const int sumLocal = calcMemoryLocal();
    const int sumChilds = calcMemoryChilds(0);
    MemoryManager::printMemory("resource manager",
        level,
        sumLocal,
        sumChilds);
    return sumLocal + sumChilds;
}

References calcMemoryChilds(), calcMemoryLocal(), and MemoryManager::printMemory().

Referenced by MemoryManager::printAllMemory().

calcMemoryChilds()

int ResourceManager::calcMemoryChilds

(

const int

level

)

Definition at line 661 of file resourcemanager.cpp.

{
    int sz = 0;
    FOR_EACH (ResourceCIterator, it, mResources)
    {
        sz += static_cast<int>((*it).first.capacity());
        sz += (*it).second->calcMemory(level + 1);
    }
    FOR_EACH (ResourceCIterator, it, mOrphanedResources)
    {
        sz += static_cast<int>((*it).first.capacity());
        sz += (*it).second->calcMemory(level + 1);
    }
    FOR_EACH (std::set<Resource*>::const_iterator, it, mDeletedResources)
    {
        sz += (*it)->calcMemory(level + 1);
    }
    return sz;
}

References FOR_EACH, mDeletedResources, mOrphanedResources, and mResources.

Referenced by calcMemory().

calcMemoryLocal()

int ResourceManager::calcMemoryLocal

(

)

Definition at line 651 of file resourcemanager.cpp.

{
    int sz = 24;
    FOR_EACH (std::set<SDL_Surface*>::iterator, it, deletedSurfaces)
    {
        sz += MemoryManager::getSurfaceSize(*it);
    }
    return sz;
}

References deletedSurfaces, FOR_EACH, and MemoryManager::getSurfaceSize().

Referenced by calcMemory(), and SubImage::calcMemoryLocal().

cleanOrphans()

bool ResourceManager::cleanOrphans

(

const bool

always

)

Definition at line 227 of file resourcemanager.cpp.

{
    timeval tv;
    gettimeofday(&tv, nullptr);
    // Delete orphaned resources after 30 seconds.
    time_t oldest = static_cast<time_t>(tv.tv_sec);
    const time_t threshold = oldest - 30;
 
    if (mOrphanedResources.empty() || (!always && mOldestOrphan >= threshold))
        return false;
 
    bool status(false);
    ResourceIterator iter = mOrphanedResources.begin();
    while (iter != mOrphanedResources.end())
    {
        Resource *const res = iter->second;
        if (res == nullptr)
        {
            ++iter;
            continue;
        }
        const time_t t = res->mTimeStamp;
        if (!always && t >= threshold)
        {
            if (t < oldest)
                oldest = t;
            ++ iter;
        }
        else
        {
            logResource(res);
            const ResourceIterator toErase = iter;
            ++iter;
            mOrphanedResources.erase(toErase);
            delete res;  // delete only after removal from list,
                         // to avoid issues in recursion
            status = true;
        }
    }
 
    mOldestOrphan = oldest;
    return status;
}

References logResource(), mOldestOrphan, mOrphanedResources, and Resource::mTimeStamp.

Referenced by cleanUp(), clearCache(), deleteInstance(), main(), and Gui::slowLogic().

cleanProtected()

void ResourceManager::cleanProtected

(

)

Definition at line 204 of file resourcemanager.cpp.

{
    ResourceIterator iter = mResources.begin();
    while (iter != mResources.end())
    {
        Resource *const res = iter->second;
        if (res == nullptr)
        {
            ++ iter;
            continue;
        }
        if (res->mProtected)
        {
            res->mProtected = false;
            res->decRef();
            iter = mResources.begin();
            continue;
        }
 
        ++ iter;
    }
}

References Resource::decRef(), Resource::mProtected, and mResources.

Referenced by Game::changeMap(), clearCache(), and deleteInstance().

cleanUp()

void ResourceManager::cleanUp

(

Resource *const

res

)

Definition at line 183 of file resourcemanager.cpp.

{
    if (res == nullptr)
        return;
 
    const unsigned refCount = res->mRefCount;
    if (refCount > 0)
    {
        logger->log("ResourceManager::~ResourceManager() cleaning up %u "
                "reference%s to %s",
                refCount,
                (refCount == 1) ? "" : "s",
                res->mIdPath.c_str());
    }
 
    delete res;
#ifdef DEBUG_LEAKS
    cleanOrphans(true);
#endif  // DEBUG_LEAKS
}

References cleanOrphans(), Logger::log(), logger, Resource::mIdPath, and Resource::mRefCount.

Referenced by deleteResourceManager().

clearCache()

void ResourceManager::clearCache

(

)

Definition at line 644 of file resourcemanager.cpp.

{
    cleanProtected();
    while (cleanOrphans(true))
        continue;
}

References cleanOrphans(), and cleanProtected().

Referenced by Client::unloadData().

clearDeleted()

void ResourceManager::clearDeleted

(

const bool

full

)

Definition at line 321 of file resourcemanager.cpp.

{
    bool status(true);
    logger->log1("clear deleted");
    while (status)
    {
        status = false;
        std::set<Resource*>::iterator resDelIter = mDeletedResources.begin();
        while (resDelIter != mDeletedResources.end())
        {
            if ((*resDelIter)->mRefCount == 0U)
            {
                status = true;
                Resource *res = *resDelIter;
                logResource(res);
                mDeletedResources.erase(resDelIter);
                delete res;
                break;
            }
            ++ resDelIter;
        }
    }
    if (full && !mDeletedResources.empty())
    {
        logger->log1("leaks in deleted");
        std::set<Resource*>::iterator resDelIter = mDeletedResources.begin();
        while (resDelIter != mDeletedResources.end())
        {
            logResource(*resDelIter);
 
            // for debug only
//            delete *resDelIter;
            // for debug only
 
            ++ resDelIter;
        }
    }
}

References Logger::log1(), logger, logResource(), and mDeletedResources.

Referenced by deleteResourceManager(), and AtlasResource::~AtlasResource().

clearScheduled()

void ResourceManager::clearScheduled

(

)

Definition at line 635 of file resourcemanager.cpp.

{
    BLOCK_START("ResourceManager::clearScheduled")
    FOR_EACH (std::set<SDL_Surface*>::iterator, i, deletedSurfaces)
        MSDL_FreeSurface(*i);
    deletedSurfaces.clear();
    BLOCK_END("ResourceManager::clearScheduled")
}

References BLOCK_END, BLOCK_START, deletedSurfaces, FOR_EACH, and MSDL_FreeSurface.

Referenced by deleteResourceManager(), and Gui::logic().

decRefDelete()

void ResourceManager::decRefDelete

(

Resource *const

res

)

Definition at line 560 of file resourcemanager.cpp.

{
    if (res == nullptr)
        return;
 
    const int count = res->mRefCount;
    if (count == 1)
    {
        logResource(res);
 
        ResourceIterator resIter = mResources.find(res->mIdPath);
        if (resIter != mResources.end() && resIter->second == res)
        {
            mResources.erase(resIter);
        }
        else
        {
            resIter = mOrphanedResources.find(res->mIdPath);
            if (resIter != mOrphanedResources.end() && resIter->second == res)
                mOrphanedResources.erase(resIter);
        }
 
        delete res;
    }
    else
    {
        res->decRef();
    }
}

References Resource::decRef(), logResource(), Resource::mIdPath, mOrphanedResources, Resource::mRefCount, and mResources.

Referenced by SoundManager::close(), and Desktop::setBestFittingWallpaper().

deleteInstance()

void ResourceManager::deleteInstance

(

)

Deletes the class instance if it exists.

Definition at line 590 of file resourcemanager.cpp.

{
#ifdef DUMP_LEAKED_RESOURCES
    logger->log1("clean orphans start");
    ResourceManager::cleanProtected();
    while (ResourceManager::cleanOrphans(true))
        continue;
    logger->log1("clean orphans end");
    ResourceIterator iter = ResourceManager::mResources.begin();
 
#ifdef UNITTESTS
    bool status(false);
#endif  // UNITTESTS
 
    while (iter != ResourceManager::mResources.end())
    {
        const Resource *const res = iter->second;
        if (res != nullptr)
        {
            if (res->mRefCount != 0U)
            {
                logger->log(std::string("ResourceLeak: ").append(
                    res->mIdPath).append(" (").append(toString(
                    res->mRefCount)).append(")"));
#ifdef UNITTESTS
                status = true;
#endif  // UNITTESTS
            }
        }
        ++iter;
    }
#ifdef UNITTESTS
    if (status)
        reportAlways("Found leaked resources.")
#endif  // UNITTESTS
#endif  // DUMP_LEAKED_RESOURCES
 
    deleteResourceManager();
}

References cleanOrphans(), cleanProtected(), deleteResourceManager(), Logger::log(), Logger::log1(), logger, Resource::mIdPath, Resource::mRefCount, mResources, reportAlways, and Catch::toString().

Referenced by Client::gameClear().

deleteResourceManager()

void ResourceManager::deleteResourceManager

(

)

Cleans up remaining resources, warning about resources that were still referenced.

Definition at line 68 of file resourcemanager.cpp.

{
    mDestruction = true;
    mResources.insert(mOrphanedResources.begin(), mOrphanedResources.end());
 
    // Release any remaining spritedefs first because they depend on image sets
    ResourceIterator iter = mResources.begin();
 
#ifdef DEBUG_LEAKS
#ifdef UNITTESTS
    bool status(false);
#endif  // UNITTESTS
 
    while (iter != mResources.end())
    {
        if (iter->second)
        {
            if (iter->second->mRefCount)
            {
                logger->log(std::string("ResourceLeak: ").append(
                    iter->second->mIdPath).append(" (").append(
                    toString(iter->second->mRefCount)).append(")"));
#ifdef UNITTESTS
                status = true;
#endif  // UNITTESTS
            }
        }
        ++iter;
    }
 
#ifdef UNITTESTS
    if (status)
        reportAlways("Found leaked resources.")
#endif  // UNITTESTS
 
    iter = mResources.begin();
#endif  // DEBUG_LEAKS
 
    while (iter != mResources.end())
    {
#ifdef DEBUG_LEAKS
        if (iter->second && iter->second->mRefCount)
        {
            ++iter;
            continue;
        }
#endif  // DEBUG_LEAKS
 
        if (dynamic_cast<SpriteDef*>(iter->second) != nullptr)
        {
            cleanUp(iter->second);
            const ResourceIterator toErase = iter;
            ++iter;
            mResources.erase(toErase);
        }
        else
        {
            ++iter;
        }
    }
 
    // Release any remaining image sets first because they depend on images
    iter = mResources.begin();
    while (iter != mResources.end())
    {
#ifdef DEBUG_LEAKS
        if (iter->second && iter->second->mRefCount)
        {
            ++iter;
            continue;
        }
#endif  // DEBUG_LEAKS
 
        if (dynamic_cast<ImageSet*>(iter->second) != nullptr)
        {
            cleanUp(iter->second);
            const ResourceIterator toErase = iter;
            ++iter;
            mResources.erase(toErase);
        }
        else
        {
            ++iter;
        }
    }
 
    // Release remaining resources, logging the number of dangling references.
    iter = mResources.begin();
    while (iter != mResources.end())
    {
#ifdef DEBUG_LEAKS
        if (iter->second && iter->second->mRefCount)
        {
            ++iter;
            continue;
        }
#endif  // DEBUG_LEAKS
 
        if (iter->second != nullptr)
        {
            cleanUp(iter->second);
            const ResourceIterator toErase = iter;
            ++iter;
            mResources.erase(toErase);
        }
        else
        {
            ++iter;
        }
    }
    clearDeleted(true);
    clearScheduled();
    mDestruction = false;
}

References cleanUp(), clearDeleted(), clearScheduled(), Logger::log(), logger, mDestruction, mOrphanedResources, mResources, reportAlways, and Catch::toString().

Referenced by deleteInstance().

get()

Resource * ResourceManager::get	(	const std::string &	idPath,
		generator	fun,
		const void *const	data
	)

Creates a resource and adds it to the resource map.

Parameters

idPath	The resource identifier path.
fun	A function for generating the resource.
data	Extra parameters for the generator.

Returns

A valid resource or NULL if the resource could not be generated.

Definition at line 428 of file resourcemanager.cpp.

{
#ifndef DISABLE_RESOURCE_CACHING
    Resource *resource = getFromCache(idPath);
    if (resource != nullptr)
        return resource;
    resource = fun(data);
 
    if (resource != nullptr)
    {
        resource->incRef();
        resource->mIdPath = idPath;
#ifdef DEBUG_IMAGES
        logger->log("set name %p, %s", static_cast<void*>(resource),
            resource->mIdPath.c_str());
#endif  // DEBUG_IMAGES
 
        mResources[idPath] = resource;
    }
    else
    {
        reportAlways("Error loading resource: %s", idPath.c_str())
    }
#else  // DISABLE_RESOURCE_CACHING
 
    Resource *resource = fun(data, idPath);
 
    if (resource)
    {
        resource->incRef();
        resource->mIdPath = idPath;
#ifdef DEBUG_IMAGES
        logger->log("set name %p, %s", static_cast<void*>(resource),
            resource->mIdPath.c_str());
#endif  // DEBUG_IMAGES
    }
    else
    {
        reportAlways("Error loading resource: " + idPath)
    }
#endif  // DISABLE_RESOURCE_CACHING
 
    // Returns nullptr if the object could not be created.
    return resource;
}

References data, getFromCache(), Resource::incRef(), Logger::log(), logger, Resource::mIdPath, mResources, and reportAlways.

Referenced by Loader::getAtlas(), Loader::getEmptyAtlas(), Loader::getImage(), Loader::getImageSet(), Loader::getMusic(), Loader::getRescaled(), Loader::getShader(), Loader::getShaderProgram(), Loader::getSoundEffect(), Loader::getSprite(), Loader::getSubImage(), Loader::getSubImageSet(), Loader::getWalkLayer(), and Loader::getXml().

getFromCache() [1/2]

Resource * ResourceManager::getFromCache	(	const std::string &	filename,
		const int	variant
	)

Definition at line 378 of file resourcemanager.cpp.

{
    std::stringstream ss;
    ss << filename << "[" << variant << "]";
    return getFromCache(ss.str());
}

Referenced by AnimatedSprite::delayedLoad(), and get().

getFromCache() [2/2]

Resource * ResourceManager::getFromCache

(

const std::string &

idPath

)

Definition at line 404 of file resourcemanager.cpp.

{
    // Check if the id exists, and return the value if it does.
    ResourceIterator resIter = mResources.find(idPath);
    if (resIter != mResources.end())
    {
        if (resIter->second != nullptr)
            resIter->second->incRef();
        return resIter->second;
    }
 
    resIter = mOrphanedResources.find(idPath);
    if (resIter != mOrphanedResources.end())
    {
        Resource *const res = resIter->second;
        mResources.insert(*resIter);
        mOrphanedResources.erase(resIter);
        if (res != nullptr)
            res->incRef();
        return res;
    }
    return nullptr;
}

References Resource::incRef(), mOrphanedResources, and mResources.

getTempResource()

Resource * ResourceManager::getTempResource

(

const std::string &

idPath

)

Definition at line 392 of file resourcemanager.cpp.

{
    const ResourceCIterator &resIter = mResources.find(idPath);
    if (resIter != mResources.end())
    {
        Resource *const res = resIter->second;
        if (resIter->second != nullptr)
            return res;
    }
    return nullptr;
}

References mResources.

Referenced by AtlasManager::loadEmptyImages(), and AtlasManager::loadImages().

isInCache()

bool ResourceManager::isInCache

(

const std::string &

idPath

)

Definition at line 386 of file resourcemanager.cpp.

{
    const ResourceCIterator &resIter = mResources.find(idPath);
    return (resIter != mResources.end() && (resIter->second != nullptr));
}

References mResources.

logResource()

void ResourceManager::logResource

(

const Resource *const

res

)

Definition at line 271 of file resourcemanager.cpp.

{
    if (res == nullptr)
        return;
#ifdef USE_OPENGL
    const Image *const image = dynamic_cast<const Image *>(res);
    if (image != nullptr)
    {
        std::string src = image->mSource;
        const int count = image->mRefCount;
        if (count != 0)
            src.append(" ").append(toString(count));
        logger->log("resource(%s, %u) %s", res->mIdPath.c_str(),
            image->getGLImage(), src.c_str());
    }
    else
    {
        std::string src = res->mSource;
        const int count = res->mRefCount;
        if (count > 0)
            src.append(" ").append(toString(count));
        logger->log("resource(%s) %s", res->mIdPath.c_str(), src.c_str());
    }
#else  // USE_OPENGL
 
    logger->log("resource(%s)", res->mIdPath.c_str());
#endif  // USE_OPENGL
}

References Logger::log(), logger, Resource::mIdPath, Resource::mRefCount, Resource::mSource, and Catch::toString().

Referenced by cleanOrphans(), clearDeleted(), decRefDelete(), logResources(), and moveToDeleted().

logResources()

void ResourceManager::logResources

(

const std::string &

msg

)

Definition at line 300 of file resourcemanager.cpp.

{
    logger->log("start of resources: " + msg);
    logger->log("resources");
    FOR_EACH(ResourceIterator, it, mResources)
    {
        logResource((*it).second);
    }
    logger->log("orphaned resources");
    FOR_EACH(ResourceIterator, it, mOrphanedResources)
    {
        logResource((*it).second);
    }
    logger->log("deleted resources");
    FOR_EACH(std::set<Resource*>::iterator, it, mDeletedResources)
    {
        logResource(*it);
    }
    logger->log("end of resources");
}

References FOR_EACH, Logger::log(), logger, logResource(), mDeletedResources, mOrphanedResources, mResources, and Actions::msg().

moveToDeleted()

void ResourceManager::moveToDeleted

(

Resource *const

res

)

Move resource to deleted resources list.

Definition at line 526 of file resourcemanager.cpp.

{
    if (res == nullptr)
        return;
 
    bool found(false);
    const int count = res->mRefCount;
    if (count == 1)
        logResource(res);
    res->decRef();
    ResourceIterator resIter = mResources.find(res->mIdPath);
    if (resIter != mResources.end() && resIter->second == res)
    {
        mResources.erase(resIter);
        found = true;
    }
    else
    {
        resIter = mOrphanedResources.find(res->mIdPath);
        if (resIter != mOrphanedResources.end() && resIter->second == res)
        {
            mOrphanedResources.erase(resIter);
            found = true;
        }
    }
    if (found)
    {
        if (count > 1)
            mDeletedResources.insert(res);
        else
            delete res;
    }
}

References Resource::decRef(), logResource(), mDeletedResources, Resource::mIdPath, mOrphanedResources, Resource::mRefCount, and mResources.

Referenced by AtlasManager::loadEmptyImages(), AtlasManager::loadImages(), and AtlasManager::moveToDeleted().

release()

void ResourceManager::release

(

Resource *const

res

)

Releases a resource, placing it in the set of orphaned resources.

Definition at line 476 of file resourcemanager.cpp.

{
    if ((res == nullptr) || mDestruction)
        return;
 
#ifndef DISABLE_RESOURCE_CACHING
    std::set<Resource*>::iterator resDelIter = mDeletedResources.find(res);
    if (resDelIter != mDeletedResources.end())
    {
        // we found zero counted image in deleted list. deleting it and exit.
        mDeletedResources.erase(resDelIter);
        delete res;
        return;
    }
 
    ResourceIterator resIter = mResources.find(res->mIdPath);
 
    if (resIter == mResources.end())
    {
// +++ need reenable after Resource will have type field
//        reportAlways("no resource in cache: %s",
//            res->mIdPath.c_str())
        delete res;
        return;
    }
    if (resIter->second != res)
    {
// +++ need reenable after Resource will have type field
//        reportAlways("in cache other image: %s",
//            res->mIdPath.c_str())
        delete res;
        return;
    }
 
    timeval tv;
    gettimeofday(&tv, nullptr);
    const time_t timestamp = static_cast<time_t>(tv.tv_sec);
 
    res->mTimeStamp = timestamp;
    if (mOrphanedResources.empty())
        mOldestOrphan = timestamp;
 
    mOrphanedResources.insert(*resIter);
    mResources.erase(resIter);
#else  // DISABLE_RESOURCE_CACHING
 
    delete res;
#endif  // DISABLE_RESOURCE_CACHING
}

References mDeletedResources, mDestruction, Resource::mIdPath, mOldestOrphan, mOrphanedResources, mResources, and Resource::mTimeStamp.

Referenced by Resource::decRef().

scheduleDelete()

void ResourceManager::scheduleDelete

(

SDL_Surface *const

surface

)

Definition at line 630 of file resourcemanager.cpp.

{
    deletedSurfaces.insert(surface);
}

References deletedSurfaces.

size()

int ResourceManager::size

(

)

Definition at line 692 of file resourcemanager.cpp.

{
    return CAST_S32(mResources.size());
}

References CAST_S32, and mResources.

Variable Documentation

deletedSurfaces

std::set<SDL_Surface*> ResourceManager::deletedSurfaces

Definition at line 61 of file resourcemanager.cpp.

Referenced by calcMemoryLocal(), clearScheduled(), and scheduleDelete().

mDeletedResources

std::set<Resource*> ResourceManager::mDeletedResources

Definition at line 64 of file resourcemanager.cpp.

Referenced by calcMemoryChilds(), clearDeleted(), logResources(), moveToDeleted(), and release().

mDestruction

bool ResourceManager::mDestruction = false

Definition at line 66 of file resourcemanager.cpp.

Referenced by deleteResourceManager(), and release().

mOldestOrphan

time_t ResourceManager::mOldestOrphan = 0

Definition at line 65 of file resourcemanager.cpp.

Referenced by cleanOrphans(), and release().

mOrphanedResources

Resources ResourceManager::mOrphanedResources

Definition at line 63 of file resourcemanager.cpp.

Referenced by calcMemoryChilds(), cleanOrphans(), decRefDelete(), deleteResourceManager(), getFromCache(), logResources(), moveToDeleted(), and release().

mResources

Resources ResourceManager::mResources

Definition at line 62 of file resourcemanager.cpp.

Referenced by addResource(), calcMemoryChilds(), cleanProtected(), decRefDelete(), deleteInstance(), deleteResourceManager(), get(), getFromCache(), getTempResource(), isInCache(), logResources(), moveToDeleted(), release(), and size().