#include <KoColorConversionCache.h>

Classes
struct	CachedTransformation

struct	Private

Public Member Functions
KoCachedColorConversionTransformation	cachedConverter (const KoColorSpace src, const KoColorSpace dst, KoColorConversionTransformation::Intent _renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)

void	colorSpaceIsDestroyed (const KoColorSpace *src)

	KoColorConversionCache ()

	~KoColorConversionCache ()

Private Attributes
Private *const	d

Detailed Description

This class holds a cache of KoColorConversionTransformations.

This class is not part of public API, and can be changed without notice.

Definition at line 20 of file KoColorConversionCache.h.

Constructor & Destructor Documentation

◆ KoColorConversionCache()

KoColorConversionCache::KoColorConversionCache ( )

Definition at line 74 of file KoColorConversionCache.cpp.

                                               : d(new Private)
{
}

◆ ~KoColorConversionCache()

KoColorConversionCache::~KoColorConversionCache ( )

Definition at line 78 of file KoColorConversionCache.cpp.

{
    Q_FOREACH (CachedTransformation* transfo, d->cache) {
        delete transfo;
    }
    delete d;
}

References KoColorConversionCache::Private::cache, and d.

Member Function Documentation

◆ cachedConverter()

KoCachedColorConversionTransformation KoColorConversionCache::cachedConverter	(	const KoColorSpace *	src,
		const KoColorSpace *	dst,
		KoColorConversionTransformation::Intent	_renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags )

This function returns a cached color transformation if available or create one.

Parameters

src	source color space
dst	destination color space
_renderingIntent	rendering intent
conversionFlags	conversion flags

Definition at line 86 of file KoColorConversionCache.cpp.

{
    KoColorConversionCacheKey key(src, dst, _renderingIntent, _conversionFlags);
 
    FastPathCacheItem *cacheItem =
        d->fastStorage.localData();
 
    if (cacheItem) {
        if (cacheItem->first == key) {
            return cacheItem->second;
        }
    }
 
    cacheItem = 0;
 
    QMutexLocker lock(&d->cacheMutex);
    QList< CachedTransformation* > cachedTransfos = d->cache.values(key);
    if (cachedTransfos.size() != 0) {
        Q_FOREACH (CachedTransformation* ct, cachedTransfos) {
            ct->transfo->setSrcColorSpace(src);
            ct->transfo->setDstColorSpace(dst);
 
            cacheItem = new FastPathCacheItem(key, KoCachedColorConversionTransformation(ct));
            break;
        }
    }
    if (!cacheItem) {
        KoColorConversionTransformation* transfo = src->createColorConverter(dst, _renderingIntent, _conversionFlags);
        CachedTransformation* ct = new CachedTransformation(transfo);
        d->cache.insert(key, ct);
        cacheItem = new FastPathCacheItem(key, KoCachedColorConversionTransformation(ct));
    }
 
    d->fastStorage.setLocalData(cacheItem);
    return cacheItem->second;
}

References KoColorConversionCache::Private::cache, KoColorConversionCache::Private::cacheMutex, d, KoColorConversionCache::Private::fastStorage, KoColorConversionTransformation::setDstColorSpace(), KoColorConversionTransformation::setSrcColorSpace(), and KoColorConversionCache::CachedTransformation::transfo.

◆ colorSpaceIsDestroyed()

void KoColorConversionCache::colorSpaceIsDestroyed ( const KoColorSpace * src )

This function is called by the destructor of the color space to warn the cache that any pointers to this color space is going to be invalid and that the cache needs to stop using those pointers.

Parameters

src	source color space

Definition at line 126 of file KoColorConversionCache.cpp.

{
    d->fastStorage.setLocalData(0);
 
    QMutexLocker lock(&d->cacheMutex);
    QMultiHash< KoColorConversionCacheKey, CachedTransformation*>::iterator endIt = d->cache.end();
    for (QMultiHash< KoColorConversionCacheKey, CachedTransformation*>::iterator it = d->cache.begin(); it != endIt;) {
        if (it.key().src == cs || it.key().dst == cs) {
            Q_ASSERT(it.value()->isNotInUse()); // That's terribly evil, if that assert fails, that means that someone is using a color transformation with a color space which is currently being deleted
            delete it.value();
            it = d->cache.erase(it);
        } else {
            ++it;
        }
    }
}