1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
#ifndef __CACHE_H__
#define __CACHE_H__
//---------------------------------------------------------
// BaseCache
//---------------------------------------------------------
template<typename T> class BaseCache: public QCache<quint64, T> {
bool _enabled;
public:
//! constructor
BaseCache(int maxCost) : QCache<quint64, T>(maxCost), _enabled(true) {}
explicit BaseCache() : _enabled(true) { }
~BaseCache() {}
//! enable
void setEnabled(bool value) {
_enabled = value;
}
//! enable state
bool enabled() const {
return _enabled;
}
//! access
T* object(const quint64& key) {
return _enabled ? QCache<quint64, T>::object(key) : 0;
}
//! max cost
void setMaxCost( int cost ) {
if ( cost <= 0 ) {
QCache<quint64, T>::clear();
QCache<quint64, T>::setMaxCost(1);
setEnabled( false );
}
else {
setEnabled(true);
QCache<quint64, T>::setMaxCost(cost);
}
}
};
//---------------------------------------------------------
// Cache
//---------------------------------------------------------
template<typename T> class Cache {
public:
Cache() {}
~Cache() {}
//! return cache matching a given key
//typedef QCache<quint64, T> Value;
typedef BaseCache<T> Value;
Value* get(const QColor& color) {
quint64 key = (quint64(color.rgba()) << 32);
Value* cache = data_.object(key);
if (!cache) {
cache = new Value( data_.maxCost() );
data_.insert(key, cache);
}
return cache;
}
void clear() {
data_.clear();
}
//! max cache size
void setMaxCacheSize(int value) {
data_.setMaxCost(value);
foreach(quint64 key, data_.keys()) {
data_.object(key)->setMaxCost(value);
}
}
private:
BaseCache<Value> data_;
};
#endif
|
