/**************************************************************************** ** ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtCore module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** GNU Lesser General Public License Usage ** This file may be used under the terms of the GNU Lesser General Public ** License version 2.1 as published by the Free Software Foundation and ** appearing in the file LICENSE.LGPL included in the packaging of this ** file. Please review the following information to ensure the GNU Lesser ** General Public License version 2.1 requirements will be met: ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain additional ** rights. These rights are described in the Nokia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU General ** Public License version 3.0 as published by the Free Software Foundation ** and appearing in the file LICENSE.GPL included in the packaging of this ** file. Please review the following information to ensure the GNU General ** Public License version 3.0 requirements will be met: ** http://www.gnu.org/copyleft/gpl.html. ** ** Other Usage ** Alternatively, this file may be used in accordance with the terms and ** conditions contained in a signed written agreement between you and Nokia. ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #ifndef QCACHE_H #define QCACHE_H #include QT_BEGIN_HEADER QT_BEGIN_NAMESPACE QT_MODULE(Core) template class QCache { struct Node { inline Node() : keyPtr(0) {} inline Node(T *data, int cost) : keyPtr(0), t(data), c(cost), p(0), n(0) {} const Key *keyPtr; T *t; int c; Node *p,*n; }; Node *f, *l; QHash hash; void *unused; // ### Qt5: remove int mx, total; inline void unlink(Node &n) { if (n.p) n.p->n = n.n; if (n.n) n.n->p = n.p; if (l == &n) l = n.p; if (f == &n) f = n.n; total -= n.c; T *obj = n.t; hash.remove(*n.keyPtr); delete obj; } inline T *relink(const Key &key) { typename QHash::iterator i = hash.find(key); if (typename QHash::const_iterator(i) == hash.constEnd()) return 0; Node &n = *i; if (f != &n) { if (n.p) n.p->n = n.n; if (n.n) n.n->p = n.p; if (l == &n) l = n.p; n.p = 0; n.n = f; f->p = &n; f = &n; } return n.t; } Q_DISABLE_COPY(QCache) public: inline explicit QCache(int maxCost = 100); inline ~QCache() { clear(); } inline int maxCost() const { return mx; } void setMaxCost(int m); inline int totalCost() const { return total; } inline int size() const { return hash.size(); } inline int count() const { return hash.size(); } inline bool isEmpty() const { return hash.isEmpty(); } inline QList keys() const { return hash.keys(); } void clear(); bool insert(const Key &key, T *object, int cost = 1); T *object(const Key &key) const; inline bool contains(const Key &key) const { return hash.contains(key); } T *operator[](const Key &key) const; bool remove(const Key &key); T *take(const Key &key); private: void trim(int m); }; template inline QCache::QCache(int amaxCost) : f(0), l(0), unused(0), mx(amaxCost), total(0) {} template inline void QCache::clear() { while (f) { delete f->t; f = f->n; } hash.clear(); l = 0; total = 0; } template inline void QCache::setMaxCost(int m) { mx = m; trim(mx); } template inline T *QCache::object(const Key &key) const { return const_cast*>(this)->relink(key); } template inline T *QCache::operator[](const Key &key) const { return object(key); } template inline bool QCache::remove(const Key &key) { typename QHash::iterator i = hash.find(key); if (typename QHash::const_iterator(i) == hash.constEnd()) { return false; } else { unlink(*i); return true; } } template inline T *QCache::take(const Key &key) { typename QHash::iterator i = hash.find(key); if (i == hash.end()) return 0; Node &n = *i; T *t = n.t; n.t = 0; unlink(n); return t; } template bool QCache::insert(const Key &akey, T *aobject, int acost) { remove(akey); if (acost > mx) { delete aobject; return false; } trim(mx - acost); Node sn(aobject, acost); typename QHash::iterator i = hash.insert(akey, sn); total += acost; Node *n = &i.value(); n->keyPtr = &i.key(); if (f) f->p = n; n->n = f; f = n; if (!l) l = f; return true; } template void QCache::trim(int m) { Node *n = l; while (n && total > m) { Node *u = n; n = n->p; if (qIsDetached(*u->t)) unlink(*u); } } QT_END_NAMESPACE QT_END_HEADER #endif // QCACHE_H