blob: bb94cbd75f8dc5a21a663f258f47b336bd55cdad (
plain) (
blame)
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
/***************************************************************************
* Copyright (c) 2004 - 2008 Eike Stepper, Germany.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Eike Stepper - initial API and implementation
**************************************************************************/
package org.eclipse.net4j.util.cache;
/**
* @author Eike Stepper
*/
public class CacheRegistration implements ICacheRegistration
{
public static final float DEFAULT_RECONSTRUCTION_COST_DECAY_FACTOR = 0.1f;
private ICacheMonitor cacheMonitor;
private ICache cache;
private int elementCount;
private long cacheSize;
private long reconstructionCost;
public CacheRegistration(ICacheMonitor cacheMonitor, ICache cache)
{
this.cacheMonitor = cacheMonitor;
this.cache = cache;
}
public void dispose()
{
cacheMonitor = null;
cache = null;
}
public boolean isDisposed()
{
return cacheMonitor == null || cache == null;
}
public ICacheMonitor getCacheMonitor()
{
return cacheMonitor;
}
public ICache getCache()
{
return cache;
}
public int getElementCount()
{
return elementCount;
}
public long getCacheSize()
{
return cacheSize;
}
public long getAverageElementSize()
{
return cacheSize / elementCount;
}
public long getReconstructionCost()
{
return reconstructionCost;
}
public void elementCached(int elementSize)
{
checkDisposal();
++elementCount;
cacheSize += elementSize;
}
public void elementEvicted(int elementSize)
{
checkDisposal();
--elementCount;
cacheSize -= elementSize;
}
public void elementReconstructed(long reconstructionTime)
{
checkDisposal();
float decayFactor = getReconstructionCostDecayFactor();
this.reconstructionCost = (long)(decayFactor * this.reconstructionCost + (1 - decayFactor) * reconstructionTime);
}
protected float getReconstructionCostDecayFactor()
{
return DEFAULT_RECONSTRUCTION_COST_DECAY_FACTOR;
}
private void checkDisposal()
{
if (isDisposed())
{
throw new IllegalStateException("disposed");
}
}
}
|
