StelTextureCache.hpp

/*
 * Stellarium
 * Copyright (C) 2012 Ferdinand Majerech
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELTEXTURECACHE_HPP_
#define _STELTEXTURECACHE_HPP_

#include <QMap>
#include <QString>

template<class TextureBackend>
class StelTextureCache
{
private:
    struct TextureBackendRefCounted
    {
        int refCount;
        TextureBackend* backend;

        TextureBackendRefCounted(){}
        TextureBackendRefCounted(TextureBackend* backend):refCount(1),backend(backend){}
    };

public:
    virtual TextureBackend* get(const QString& name, const TextureLoadingMode loadingMode)
    {
        Q_ASSERT_X(!name.isEmpty(), Q_FUNC_INFO, "Can't cache textures without a name");

        if(!cache.contains(name)) {return NULL;}

        TextureBackend* result = cache[name].backend;

        switch(loadingMode)
        {
            case TextureLoadingMode_Normal:
                //If cached texture is loading (asynchronous), wait,
                //if uninitialized(lazy), start loading and wait
                if(result->getStatus() == TextureStatus_Uninitialized)
                {
                    result->startAsynchronousLoading();
                }
                //Waiting in a hot loop, this could be done better
                while(result->getStatus() == TextureStatus_Loading)
                {
                    continue;
                }
            case TextureLoadingMode_Asynchronous:
                //If cached texture is uninitialized (lazy), start loading and wait.
                if(result->getStatus() == TextureStatus_Uninitialized)
                {
                    result->startAsynchronousLoading();
                }
                break;
            case TextureLoadingMode_LazyAsynchronous: 
                break;
            default:
                Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown texture loading mode");
        }

        (cache[name].refCount)++;

        return result;
    }

    virtual void add(TextureBackend* backend)
    {
        const QString& name = backend->getName();
        Q_ASSERT_X(!name.isEmpty(), Q_FUNC_INFO, "Can't cache textures without a name");
        Q_ASSERT_X(!cache.contains(name), Q_FUNC_INFO, 
                   "Adding the same texture to the cache more than once");

        cache.insert(name, TextureBackendRefCounted(backend));
    }

    virtual void remove(TextureBackend* backend)
    {
        const QString& name = backend->getName();
        Q_ASSERT_X(!name.isEmpty(), Q_FUNC_INFO, "Can't cache textures without a name");
        Q_ASSERT_X(cache.contains(name), Q_FUNC_INFO,
                   "Trying to remove unknown texture from cache");

        TextureBackendRefCounted& cached = cache[name];
        --(cached.refCount);
        Q_ASSERT_X(cached.refCount >= 0, Q_FUNC_INFO,
                   "Negative reference count of a texture in texture cache");

        // If reference count hits 0, delete the texture.
        if(cached.refCount == 0)
        {
            // Assert that we're really deleting what we thing we're deleting
            // instead of having two textures with the same name.
            Q_ASSERT_X(backend == cached.backend, Q_FUNC_INFO,
                       "Texture in cache has the same name as but is not specified texture");
            cache.remove(name);
            delete backend;
        }
    }

private:
    QMap<QString, TextureBackendRefCounted> cache;
};

#endif // _STELTEXTURECACHE_HPP_