public class CompactSerializationCache extends AbstractKeyBasedMap implements ConfigurableCacheMap, Disposable
ConfigurableCacheMap
which is optimized for compact on-heap footprint.
This implementation is partially thread-safe. It assumes that multiple threads will not be accessing the same keys at the same time, nor would any other thread be accessing this cache while a clear() operation were going on, for example. In other words, this implementation assumes that access to this cache is either single-threaded or gated through an object like WrapperConcurrentMap
.
Modifier and Type | Class and Description |
---|---|
protected class |
CompactSerializationCache.HybridEvictionPolicy
The EvictionPolicy object for the Hybrid eviction algorithm.
|
protected class |
CompactSerializationCache.InternalEvictionPolicy
InternalEvictionPolicy is an abstract base implementation of an
ConfigurableCacheMap.EvictionPolicy used by this CompactSerializationCache. |
protected class |
CompactSerializationCache.KeySet
A KeySet implementation optimized for CompactSerializationCache.
|
protected class |
CompactSerializationCache.LFUEvictionPolicy
An EvictionPolicy implementing the Least Frequently Used (LFU) algorithm.
|
protected class |
CompactSerializationCache.LRUEvictionPolicy
An EvictionPolicy implementing the Least Recently Used (LRU) algorithm.
|
protected class |
CompactSerializationCache.MinExpiryVisitor
EntryVisitor implementation that calculates the next eviction time.
|
protected static class |
CompactSerializationCache.TouchCountVisitor
TouchCountVisitor is applied to the touch-count map by EvictionPolicy implementations that rely on the touch-count to retrieve and adjust the touch-count.
|
protected class |
CompactSerializationCache.WrapperEvictionPolicy
WrapperEvictionPolicy is used to wrap external or "custom" EvictionPolicy implementations to adapt the internal Binary key-based API to the
Entry-based API. |
AbstractKeyBasedMap.DeferredCacheEvent<K,V>, AbstractKeyBasedMap.EntrySet, AbstractKeyBasedMap.ValuesCollection
Base.LoggingWriter, Base.StackFrame
ConfigurableCacheMap.Entry, ConfigurableCacheMap.EvictionApprover, ConfigurableCacheMap.EvictionPolicy, ConfigurableCacheMap.UnitCalculator
Modifier and Type | Field and Description |
---|---|
static double |
DEFAULT_PRUNE
By default, when the cache prunes, it reduces its entries to this percentage.
|
protected AtomicLong |
f_atomicCurUnits
Current number of units to in the cache.
|
protected AtomicBoolean |
f_atomicEvictingMutex
The mutex acquired by the thread performing the cache eviction.
|
protected AtomicBoolean |
f_atomicExpiringMutex
The mutex acquired by the thread performing the cache-wide expiration.
|
protected boolean |
f_fBinary
True iff the keys and values are known to be Binary (and not require conversion).
|
protected long |
f_ldtEpoch
The time of the start of the "epoch", relative to which internal time-offsets are stored.
|
protected ClassLoader |
f_loader
The ClassLoader to use for deserialization of non-Binary keys/values.
|
protected MultiBinaryLongMap |
f_mblm
The MultiBinaryLongMap used for compact key (and entry-attribute) storage.
|
protected SimpleCacheStatistics |
f_stats
The CacheStatistics for JMX.
|
protected BinaryStore.KeySetAware |
f_store
The BinaryStore.KeySetAware that this CompactSerializationCache uses to store data.
|
protected BinaryLongMap.EntryVisitor |
f_visitorDefaultExpiry
The singleton stateless EntryVisitor used to update the ExpiryMap with the default expiry.
|
protected ConfigurableCacheMap.EvictionApprover |
m_apprvrEvict
The EvictionApprover.
|
protected BinaryLongMap |
m_blmExpiry
The BinaryLongMap holding the expiry information for the entries in the Cache Map.
|
protected BinaryLongMap |
m_blmTouchCount
The BinaryLongMap holding the touch-count information for the entries in the Cache Map.
|
protected BinaryLongMap |
m_blmTouchTime
The BinaryLongMap holding the touch-time information for the entries in the Cache Map.
|
protected BinaryLongMap |
m_blmUnits
The BinaryLongMap holding the units for each entry in the Cache Map.
|
protected ConfigurableCacheMap.UnitCalculator |
m_calculator
The unit calculator to use to limit size of the cache.
|
protected int |
m_cExpiryDelay
The default expiry int milliseconds, or 0 for no timeout.
|
protected long |
m_cMaxUnits
Maximum number of units to manage in the cache.
|
protected long |
m_cPruneUnits
The number of units to prune the cache down to.
|
protected double |
m_dflPruneLevel
The percentage of the total number of units that will remain after the cache manager prunes the cache (i.e. this is the "low water mark" value); this value is in the range 0.0 to 1.0.
|
protected boolean |
m_fBlind
True iff this Map should operate in blind mode.
|
protected long |
m_ldtNextExpiryCheck
The time that the last cache-wide expiry check was performed.
|
protected MapListenerSupport |
m_listenerSupport
The MapListenerSupport object.
|
protected int |
m_nUnitFactor
The unit factor.
|
protected CompactSerializationCache.InternalEvictionPolicy |
m_policy
The EvictionPolicy.
|
LOG_ALWAYS, LOG_DEBUG, LOG_ERR, LOG_INFO, LOG_MAX, LOG_MIN, LOG_QUIET, LOG_WARN, POWER_0, POWER_G, POWER_K, POWER_M, POWER_T, UNIT_D, UNIT_H, UNIT_M, UNIT_MS, UNIT_NS, UNIT_S, UNIT_US
EXPIRY_DEFAULT, EXPIRY_NEVER
Modifier | Constructor and Description |
---|---|
|
CompactSerializationCache(BinaryStoreManager mgr, boolean fBinary)
Construct a CompactSerializationCache using the specified BinaryStoreManager, optionally storing only Binary keys and values
|
|
CompactSerializationCache(BinaryStoreManager mgr, ClassLoader loader)
Construct a CompactSerializationCache using the specified BinaryStoreManager and classloader.
|
protected |
CompactSerializationCache(BinaryStoreManager mgr, ClassLoader loader, boolean fBinary)
Construct a CompactSerializationCache using the specified BinaryStoreManager.
|
Modifier and Type | Method and Description |
---|---|
void |
addMapListener(MapListener listener)
Add a standard map listener that will receive all events (inserts, updates, deletes) that occur against the map, with the key, old-value and new-value included.
|
void |
addMapListener(MapListener listener, Filter filter, boolean fLite)
Add a map listener that receives events based on a filter evaluation.
|
void |
addMapListener(MapListener listener, Object oKey, boolean fLite)
Add a map listener for a specific key.
|
protected int |
calculateUnits(Binary binKey, Binary binValue)
Calculate the unit cost of the specified cache entry, according to the configured unit-calculator.
|
protected void |
checkExpiry(Binary binKey)
Check the specified key to see if it is expired, removing it if necessary.
|
protected void |
checkExpiry(boolean fForce)
Check the cache entries for expiration, removing expired entries as necessary.
|
protected void |
checkSize()
Check the current size of the cache to see that it is within the configured
high-units , evicting entries according to the configured ConfigurableCacheMap.EvictionPolicy if necessary. |
protected void |
checkSize(boolean fCheckExpiry)
Check the current size of the cache to see that it is within the configured
high-units , evicting entries according to the configured ConfigurableCacheMap.EvictionPolicy if necessary. |
void |
clear()
Clear all key/value mappings.
|
protected void |
configureEviction()
Ensure that the BinaryLongMaps required for eviction support are configured.
|
boolean |
containsKey(Object oKey)
Returns true if this map contains a mapping for the specified key.
|
boolean |
containsValue(Object oValue)
Returns true if this Map maps one or more keys to the specified value.
|
protected long |
decodeExpiry(long cExpiryEncoded)
Decode the specified encoded expiry value into an absolute time.
|
protected long |
decodeTime(int cEncoded)
Decode the specified encoded time into an absolute ldt.
|
protected void |
dispatchEvent(int nId, Binary binKey, Object oKey, Object oValueOld, Object oValueNew, boolean fSynthetic)
Dispatch the passed event.
|
void |
dispose()
Invoked when all resources owned by the implementer can safely be released.
|
protected long |
encodeExpiry(long cExpiryDelay)
Encode the specified expiry delay (relative to current time) into the internal format.
|
protected int |
encodeTime(long ldt)
Encode the specified time into an opaque 32-bit value.
|
protected BinaryLongMap |
ensureExpiryMap()
Ensure that the expiry-map is initialized.
|
void |
evict()
Evict all entries from the cache that are no longer valid, and potentially prune the cache size if the cache is size-limited and its size is above the caching low water mark.
|
void |
evict(Object oKey)
Evict a specified key from the cache, as if it had expired from the cache.
|
void |
evictAll(Collection colKeys)
Evict the specified keys from the cache, as if they had each expired from the cache.
|
protected int |
evictInternal(Binary binKey)
Attempt to evict the cache entry for the specified key from the cache as a result of either expiration or size-triggered eviction, returning the unit-size of the evicted entry, or 0 if the eviction was disallowed by the
ConfigurableCacheMap.EvictionApprover . |
protected Object |
fromBinary(Binary bin)
Translate the passed Binary object into an Object object.
|
Object |
get(Object oKey)
Returns the value to which this map maps the specified key.
|
BinaryStore.KeySetAware |
getBinaryStore()
Returns the BinaryStore that this map uses for its storage.
|
ConfigurableCacheMap.Entry |
getCacheEntry(Object oKey)
Locate a cache Entry in the cache based on its key.
|
protected ConfigurableCacheMap.Entry |
getCacheEntryInternal(Binary binKey)
Return a
ConfigurableCacheMap.Entry for the specified key. |
protected ConfigurableCacheMap.Entry |
getCacheEntryInternal(Binary binKey, Object oKey)
Return a
ConfigurableCacheMap.Entry for the specified key. |
CacheStatistics |
getCacheStatistics()
Returns the CacheStatistics for this cache.
|
ClassLoader |
getClassLoader()
Return the configured ClassLoader, or null if none is configured.
|
protected int |
getEntryUnits(Binary binKey)
Return the unit-size of the entry associated with the specified key, or 0 if the key does not exist.
|
ConfigurableCacheMap.EvictionApprover |
getEvictionApprover()
Obtain the registered EvictionApprover.
|
ConfigurableCacheMap.EvictionPolicy |
getEvictionPolicy()
Obtain the current EvictionPolicy used by the cache.
|
int |
getExpiryDelay()
Determine the default "time to live" for each individual cache entry.
|
BinaryLongMap |
getExpiryMap()
Return the BinaryLongMap associating the entries in this cache map with their corresponding expiry.
|
int |
getHighUnits()
Determine the limit of the cache size in units.
|
protected CompactSerializationCache.InternalEvictionPolicy |
getInternalEvictionPolicy()
Return the InternalEvictionPolicy used by this CompactSerializationCache.
|
protected BinaryLongMap |
getKeyMap()
Return a BinaryLongMap whose values have no meaning, but whose keys can be used internally to detect the presence of an entry in the cache map.
|
int |
getLowUnits()
Determine the point to which the cache will shrink when it prunes.
|
long |
getNextExpiryTime()
Determine the next expiry time for the cache entries.
|
BinaryLongMap |
getTouchCountMap()
Return the BinaryLongMap associating the entries in this cache map with their corresponding touch count.
|
BinaryLongMap |
getTouchTimeMap()
Return the BinaryLongMap associating the entries in this cache map with their corresponding last "touch" time.
|
ConfigurableCacheMap.UnitCalculator |
getUnitCalculator()
Obtain the current UnitCalculator used by the cache.
|
int |
getUnitFactor()
Determine the factor by which the Units, LowUnits and HighUnits properties are adjusted.
|
int |
getUnits()
Determine the number of units that the cache currently stores.
|
BinaryLongMap |
getUnitsMap()
Return the BinaryLongMap associating the entries in this cache map with their size in "units".
|
protected boolean |
hasListeners()
Determine if the cache map has any listeners at all.
|
protected AbstractKeyBasedMap.DeferredCacheEvent |
instantiateDeferredCacheEvent(int nId, Binary binKey, Object oKey, Object oValueOld, Object oValueNew, boolean fSynthetic)
Create a DeferredCacheEvent object with the provided arguments.
|
protected Set |
instantiateKeySet()
Factory pattern: Create a Set that represents the keys in the Map
|
boolean |
isBinaryMap()
Determine if the keys and values in this map are known to be all Binary.
|
boolean |
isBlind()
Return whether this CompactSerializationCache instance is in blind mode.
|
protected Iterator |
iterateKeys()
Create an iterator over the keys in this Map.
|
Object |
put(Object oKey, Object oValue)
Associates the specified value with the specified key in this map.
|
Object |
put(Object oKey, Object oValue, long cExpiry)
Associates the specified value with the specified key in this cache.
|
protected void |
registerExpiry(Binary binKey, long cExpiry)
Register the expiry for the specified key.
|
Object |
remove(Object oKey)
Removes the mapping for this key from this map if present.
|
protected boolean |
removeBlind(Object oKey)
Removes the mapping for this key from this map if present.
|
protected Object |
removeInternal(Object oKey, Binary binKey, boolean fBlind)
Remove the given key from the
BinaryStore only loading the value if necessary. |
void |
removeMapListener(MapListener listener)
Remove a standard map listener that previously signed up for all events.
|
void |
removeMapListener(MapListener listener, Filter filter)
Remove a map listener that previously signed up for events based on a filter evaluation.
|
void |
removeMapListener(MapListener listener, Object oKey)
Remove a map listener that previously signed up for events about a specific key.
|
void |
setBlind(boolean fBlind)
Set whether this CompactSerializationCache instance should operate under a blind mode.
|
void |
setEvictionApprover(ConfigurableCacheMap.EvictionApprover approver)
Set the EvictionApprover for this ConfigurableCacheMap.
|
void |
setEvictionPolicy(ConfigurableCacheMap.EvictionPolicy policy)
Set the EvictionPolicy for the cache to use.
|
void |
setExpiryDelay(int cMillis)
Specify the default "time to live" for cache entries.
|
protected void |
setExpiryMap(BinaryLongMap blmExpiry)
Set the BinaryLongMap to use to associate the entries in this cache map with their corresponding expiry.
|
void |
setHighUnits(int cMax)
Update the maximum size of the cache in units.
|
void |
setLowUnits(int cUnits)
Specify the point to which the cache will shrink when it prunes.
|
protected void |
setTouchCountMap(BinaryLongMap blmTouch)
Return the BinaryLongMap to use to associate the entries in this cache map with their corresponding "touch" count.
|
protected void |
setTouchTimeMap(BinaryLongMap blmTouch)
Return the BinaryLongMap to use to associate the entries in this cache map with their corresponding last "touch" time.
|
void |
setUnitCalculator(ConfigurableCacheMap.UnitCalculator calculator)
Set the UnitCalculator for the cache to use.
|
void |
setUnitFactor(int nFactor)
Determine the factor by which the Units, LowUnits and HighUnits properties are adjusted.
|
protected void |
setUnitsMap(BinaryLongMap blmUnits)
Set the BinaryLongMap to use to associate the entries in this cache map with their size in "units".
|
int |
size()
Returns the number of key-value mappings in this map.
|
protected Binary |
toBinary(Object o)
Translate the passed Object object into an Binary object.
|
protected static int |
toExternalUnits(long cUnits, int nFactor)
Convert from an internal 64-bit unit value to an external 32-bit unit value using the configured units factor.
|
protected static long |
toInternalUnits(int cUnits, int nFactor)
Convert from an external 32-bit unit value to an internal 64-bit unit value using the configured units factor.
|
String |
toString()
Returns a string representation of this Map.
|
protected void |
touch(Binary binKey)
Register a "touch" of the specified key.
|
protected void |
updateUnits(Binary binKey, int cUnits)
Update the units associated with the specified key.
|
clone, entrySet, equals, getAll, hashCode, instantiateEntrySet, instantiateValues, isEmpty, keySet, putAll, values
azzert, azzert, azzert, azzertFailed, breakLines, breakLines, capitalize, checkNotEmpty, checkNotNull, checkRange, computeSafeWaitTime, decimalValue, dup, dup, ensureBigDecimal, ensureClassLoader, ensureRuntimeException, ensureRuntimeException, equals, equalsDeep, err, err, err, err, err, escape, formatDateTime, getCallerStackFrame, getCommonMonitor, getCommonMonitor, getCommonMonitor, getContextClassLoader, getContextClassLoader, getDeepMessage, getErr, getLastSafeTimeMillis, getLog, getMaxDecDigits, getMaxHexDigits, getOriginalException, getOut, getRandom, getRandomBinary, getRandomBinary, getRandomString, getSafeTimeMillis, getStackFrame, getStackFrames, getStackTrace, getStackTrace, getThreadFactory, getTimeZone, getUpTimeMillis, hashCode, hexValue, indentString, indentString, isDecimal, isHex, isLogEcho, isOctal, log, log, log, log, log, makeInteger, makeLong, makeThread, octalValue, out, out, out, out, out, pad, parseBandwidth, parseBandwidth, parseDelimitedString, parseHex, parseHex, parseMemorySize, parseMemorySize, parsePercentage, parseTime, parseTime, parseTimeNanos, parseTimeNanos, printStackTrace, randomize, randomize, randomize, read, read, read, read, read, read, read, replace, setErr, setLog, setLogEcho, setOut, sleep, toBandwidthString, toBandwidthString, toCharEscape, toCrc, toCrc, toCrc, toCrc, toCrc, toDecString, toDelimitedString, toDelimitedString, toDelimitedString, toDelimitedString, toHex, toHex, toHexDump, toHexEscape, toHexEscape, toHexEscape, toHexEscape, toHexString, toMemorySizeString, toMemorySizeString, toQuotedCharEscape, toQuotedStringEscape, toSqlString, toString, toString, toStringEscape, toUnicodeEscape, trace, trace, trace, trace, trace, trace, trace, trace, trace, truncateString, truncateString, wait
finalize, getClass, notify, notifyAll, wait, wait, wait
compute, computeIfAbsent, computeIfPresent, entrySet, equals, forEach, getOrDefault, hashCode, isEmpty, keySet, merge, putAll, putIfAbsent, remove, replace, replace, replaceAll, values
close
public static final double DEFAULT_PRUNE
protected BinaryLongMap m_blmExpiry
protected BinaryLongMap m_blmTouchTime
protected BinaryLongMap m_blmTouchCount
protected BinaryLongMap m_blmUnits
protected final BinaryStore.KeySetAware f_store
protected long m_cMaxUnits
protected double m_dflPruneLevel
protected long m_cPruneUnits
protected final AtomicLong f_atomicCurUnits
protected ConfigurableCacheMap.UnitCalculator m_calculator
protected int m_nUnitFactor
protected int m_cExpiryDelay
protected long m_ldtNextExpiryCheck
protected CompactSerializationCache.InternalEvictionPolicy m_policy
protected ConfigurableCacheMap.EvictionApprover m_apprvrEvict
protected MapListenerSupport m_listenerSupport
protected boolean m_fBlind
protected final MultiBinaryLongMap f_mblm
protected final AtomicBoolean f_atomicExpiringMutex
protected final AtomicBoolean f_atomicEvictingMutex
protected final boolean f_fBinary
protected final ClassLoader f_loader
protected final long f_ldtEpoch
protected final BinaryLongMap.EntryVisitor f_visitorDefaultExpiry
registerExpiry(com.tangosol.util.Binary, long)
.protected final SimpleCacheStatistics f_stats
public CompactSerializationCache(BinaryStoreManager mgr, ClassLoader loader)
mgr
- the BinaryStoreManager to use to create the BinaryStoreloader
- the ClassLoader to use for deserializationpublic CompactSerializationCache(BinaryStoreManager mgr, boolean fBinary)
mgr
- the BinaryStoreManager to use to create the BinaryStorefBinary
- true iff only Binary keys and values are to be storedprotected CompactSerializationCache(BinaryStoreManager mgr, ClassLoader loader, boolean fBinary)
mgr
- the BinaryStoreManager to use to create the BinaryStoreloader
- the ClassLoader to use for deserializationfBinary
- true iff only Binary keys and values are to be storedpublic BinaryStore.KeySetAware getBinaryStore()
public ClassLoader getClassLoader()
public boolean isBinaryMap()
public BinaryLongMap getExpiryMap()
Note: it is legal for an expiry to be 0 (meaning no-expiry), but the contract of the BinaryLongMap considers 0 to be missing, so operations such as size() and keys() on the returned BLM will not reflect the entire set of keys in this cache
protected void setExpiryMap(BinaryLongMap blmExpiry)
blmExpiry
- the BinaryLongMap to use to hold the expiry informationprotected BinaryLongMap getKeyMap()
Note: the returned BinaryLongMap may not be mutated.
public BinaryLongMap getTouchTimeMap()
protected void setTouchTimeMap(BinaryLongMap blmTouch)
blmTouch
- the BinaryLongMap holding the touch-time informationpublic BinaryLongMap getTouchCountMap()
protected void setTouchCountMap(BinaryLongMap blmTouch)
blmTouch
- the BinaryLongMap holding the touch count informationpublic BinaryLongMap getUnitsMap()
protected void setUnitsMap(BinaryLongMap blmUnits)
blmUnits
- the BinaryLongMap to use for storing the unitsprotected boolean hasListeners()
public CacheStatistics getCacheStatistics()
Note: this method is invoked reflectively by the CacheModel
public boolean isBlind()
public void setBlind(boolean fBlind)
fBlind
- whether this CompactSerializationCache should operate under a blind modepublic int size()
size
in interface Map
size
in class AbstractKeyBasedMap
public boolean containsKey(Object oKey)
containsKey
in interface Map
containsKey
in class AbstractKeyBasedMap
public boolean containsValue(Object oValue)
containsValue
in interface Map
containsValue
in class AbstractKeyBasedMap
public Object get(Object oKey)
get
in interface Map
get
in class AbstractKeyBasedMap
oKey
- the key objectpublic Object remove(Object oKey)
remove
in interface Map
remove
in class AbstractKeyBasedMap
oKey
- key whose mapping is to be removed from the mappublic void clear()
clear
in interface Map
clear
in class AbstractKeyBasedMap
public Object put(Object oKey, Object oValue)
put
in interface CacheMap
put
in interface Map
put
in class AbstractKeyBasedMap
oKey
- key with which the specified value is to be associatedoValue
- value to be associated with the specified keypublic Object put(Object oKey, Object oValue, long cExpiry)
CacheMap.put(Object oKey, Object oValue)
method allows the caller to specify an expiry (or "time to live") for the cache entry.put
in interface CacheMap
oKey
- key with which the specified value is to be associatedoValue
- value to be associated with the specified keycExpiry
- the number of milliseconds until the cache entry will expire, also referred to as the entry's "time to live"; pass CacheMap.EXPIRY_DEFAULT
to use the cache's default time-to-live setting; pass CacheMap.EXPIRY_NEVER
to indicate that the cache entry should never expire; this milliseconds value is not a date/time value, such as is returned from System.currentTimeMillis()protected Set instantiateKeySet()
instantiateKeySet
in class AbstractKeyBasedMap
protected Iterator iterateKeys()
iterateKeys
in class AbstractKeyBasedMap
protected boolean removeBlind(Object oKey)
removeBlind
in class AbstractKeyBasedMap
oKey
- key whose mapping is to be removed from the mappublic int getUnits()
Note: It is expected that the return type will be widened to a long in Coherence 4.
getUnits
in interface ConfigurableCacheMap
public int getHighUnits()
Note: It is expected that the return type will be widened to a long in Coherence 4.
getHighUnits
in interface ConfigurableCacheMap
public void setHighUnits(int cMax)
Note: It is expected that the parameter will be widened to a long in Coherence 4.
setHighUnits
in interface ConfigurableCacheMap
cMax
- the new maximum size of the cache, in unitspublic int getLowUnits()
Note: It is expected that the parameter will be widened to a long in Coherence 4.
getLowUnits
in interface ConfigurableCacheMap
public void setLowUnits(int cUnits)
Note: It is expected that the parameter will be widened to a long in Coherence 4.
setLowUnits
in interface ConfigurableCacheMap
cUnits
- the number of units that the cache prunes topublic int getUnitFactor()
Note: This property exists only to avoid changing the type of the units, low units and high units properties from 32-bit values to 64-bit values. It is expected that the parameter will be dropped in Coherence 4.
getUnitFactor
in interface ConfigurableCacheMap
public void setUnitFactor(int nFactor)
Note: This property exists only to avoid changing the type of the units, low units and high units properties from 32-bit values to 64-bit values. It is expected that the parameter will be dropped in Coherence 4.
setUnitFactor
in interface ConfigurableCacheMap
nFactor
- the units factor; the default is 1public void evict(Object oKey)
evict
in interface ConfigurableCacheMap
oKey
- the key to evict from the cachepublic void evictAll(Collection colKeys)
The result of this method is defined to be semantically the same as the following implementation:
for (Iterator iter = colKeys.iterator(); iter.hasNext(); ) { Object oKey = iter.next(); evict(oKey); }
evictAll
in interface ConfigurableCacheMap
colKeys
- a collection of keys to evict from the cachepublic void evict()
evict
in interface ConfigurableCacheMap
public ConfigurableCacheMap.EvictionApprover getEvictionApprover()
getEvictionApprover
in interface ConfigurableCacheMap
public void setEvictionApprover(ConfigurableCacheMap.EvictionApprover approver)
setEvictionApprover
in interface ConfigurableCacheMap
approver
- the EvictionApproverpublic int getExpiryDelay()
getExpiryDelay
in interface ConfigurableCacheMap
public void setExpiryDelay(int cMillis)
setExpiryDelay
in interface ConfigurableCacheMap
cMillis
- the number of milliseconds that cache entries will live, or zero to disable automatic expirypublic long getNextExpiryTime()
getNextExpiryTime
in interface ConfigurableCacheMap
SafeClock
) that one or more cache entries will expire or zero if the cache is empty, its entries never expire or the implementation chooses to avoid the pro-active evictionpublic ConfigurableCacheMap.Entry getCacheEntry(Object oKey)
getCacheEntry
in interface ConfigurableCacheMap
oKey
- the key object to search forpublic ConfigurableCacheMap.EvictionPolicy getEvictionPolicy()
getEvictionPolicy
in interface ConfigurableCacheMap
protected CompactSerializationCache.InternalEvictionPolicy getInternalEvictionPolicy()
Note: this method returns the actual instance of EvictionPolicy being used by this cache, which may differ in implementation from the configured policy returned by getEvictionPolicy()
.
public void setEvictionPolicy(ConfigurableCacheMap.EvictionPolicy policy)
setEvictionPolicy
in interface ConfigurableCacheMap
policy
- an EvictionPolicypublic ConfigurableCacheMap.UnitCalculator getUnitCalculator()
getUnitCalculator
in interface ConfigurableCacheMap
public void setUnitCalculator(ConfigurableCacheMap.UnitCalculator calculator)
setUnitCalculator
in interface ConfigurableCacheMap
calculator
- a UnitCalculatorpublic void addMapListener(MapListener listener)
addMapListener(listener, (Filter) null, false);
addMapListener
in interface ObservableMap
listener
- the MapEvent
listener to addpublic void removeMapListener(MapListener listener)
removeMapListener(listener, (Filter) null);
removeMapListener
in interface ObservableMap
listener
- the listener to removepublic void addMapListener(MapListener listener, Object oKey, boolean fLite)
The listeners will receive MapEvent objects, but if fLite is passed as true, they might not contain the OldValue and NewValue properties.
To unregister the MapListener, use the ObservableMap.removeMapListener(MapListener, Object)
method.
addMapListener
in interface ObservableMap
listener
- the MapEvent
listener to addoKey
- the key that identifies the entry for which to raise eventsfLite
- true to indicate that the MapEvent
objects do not have to include the OldValue and NewValue property values in order to allow optimizationspublic void removeMapListener(MapListener listener, Object oKey)
removeMapListener
in interface ObservableMap
listener
- the listener to removeoKey
- the key that identifies the entry for which to raise eventspublic void addMapListener(MapListener listener, Filter filter, boolean fLite)
The listeners will receive MapEvent objects, but if fLite is passed as true, they might not contain the OldValue and NewValue properties.
To unregister the MapListener, use the ObservableMap.removeMapListener(MapListener, Filter)
method.
addMapListener
in interface ObservableMap
listener
- the MapEvent
listener to addfilter
- a filter that will be passed MapEvent objects to select from; a MapEvent will be delivered to the listener only if the filter evaluates to true for that MapEvent (see MapEventFilter
); null is equivalent to a filter that alway returns truefLite
- true to indicate that the MapEvent
objects do not have to include the OldValue and NewValue property values in order to allow optimizationspublic void removeMapListener(MapListener listener, Filter filter)
removeMapListener
in interface ObservableMap
listener
- the listener to removefilter
- the filter that was passed into the corresponding addMapListener() callpublic void dispose()
Once disposed of the object should no longer be considered to be usable.
Note the Disposable interface is compatible with try-with-resources which will automatically invoke this method.
dispose
in interface Disposable
protected AbstractKeyBasedMap.DeferredCacheEvent instantiateDeferredCacheEvent(int nId, Binary binKey, Object oKey, Object oValueOld, Object oValueNew, boolean fSynthetic)
oValueOld
may be null as the deferred event may call load
upon request.nId
- this event's id, one of DeferredCacheEvent#ENTRY_INSERTED
, DeferredCacheEvent#ENTRY_UPDATED
or DeferredCacheEvent#ENTRY_DELETED
binKey
- the binary key into the mapoKey
- the key into the mapoValueOld
- optional old value (for update and delete events); if not provided a call to getOldValue will load the old value from the BinaryStoreoValueNew
- the new value (for insert and update events)fSynthetic
- true iff the event is caused by the cache internal processing such as eviction or loadingprotected void dispatchEvent(int nId, Binary binKey, Object oKey, Object oValueOld, Object oValueNew, boolean fSynthetic)
nId
- this event's id, one of DeferredCacheEvent#ENTRY_INSERTED
, DeferredCacheEvent#ENTRY_UPDATED
or DeferredCacheEvent#ENTRY_DELETED
binKey
- the binary key into the mapoKey
- the key into the mapoValueOld
- optional old value (for update and delete events); if not provided a call to getOldValue will load the old value from the BinaryStoreoValueNew
- the new value (for insert and update events)fSynthetic
- true iff the event is caused by the cache internal processing such as eviction or loadingpublic String toString()
toString
in class AbstractKeyBasedMap
protected Object removeInternal(Object oKey, Binary binKey, boolean fBlind)
BinaryStore
only loading the value if necessary.oKey
- the key to be removedbinKey
- the binary key to be removedfBlind
- whether the remove should be blindOBJECT_EXISTS
) to suggest the object did exist if fBlind
is trueprotected void configureEviction()
protected BinaryLongMap ensureExpiryMap()
protected void checkExpiry(boolean fForce)
fForce
- pass true to force the expiry check, or false to only run it if it hasn't been run in a whileprotected void checkExpiry(Binary binKey)
binKey
- the key to check for expirationprotected void checkSize()
high-units
, evicting entries according to the configured ConfigurableCacheMap.EvictionPolicy
if necessary.protected void checkSize(boolean fCheckExpiry)
high-units
, evicting entries according to the configured ConfigurableCacheMap.EvictionPolicy
if necessary.fCheckExpiry
- true iff the expiry should be checked if eviction is called forprotected void touch(Binary binKey)
binKey
- the key that was touchedprotected int evictInternal(Binary binKey)
ConfigurableCacheMap.EvictionApprover
.binKey
- the key to evictprotected void registerExpiry(Binary binKey, long cExpiry)
binKey
- the keycExpiry
- the number of milliseconds until the cache entry will expire, also referred to as the entry's "time to live" or 0 to indicate that the cache entry should never expireprotected int getEntryUnits(Binary binKey)
binKey
- the keyprotected int calculateUnits(Binary binKey, Binary binValue)
binKey
- the keybinValue
- the valueprotected void updateUnits(Binary binKey, int cUnits)
binKey
- the keycUnits
- the unitsprotected Binary toBinary(Object o)
o
- the Object to serialize into a Binary objectprotected Object fromBinary(Binary bin)
bin
- the Binary object to deserializeprotected ConfigurableCacheMap.Entry getCacheEntryInternal(Binary binKey)
ConfigurableCacheMap.Entry
for the specified key.binKey
- the binary or "raw" form of the keyprotected ConfigurableCacheMap.Entry getCacheEntryInternal(Binary binKey, Object oKey)
ConfigurableCacheMap.Entry
for the specified key.binKey
- the binary or "raw" form of the keyoKey
- the Object or "natural" form of the keyprotected static int toExternalUnits(long cUnits, int nFactor)
cUnits
- an internal 64-bit units valuenFactor
- the unit factorprotected static long toInternalUnits(int cUnits, int nFactor)
cUnits
- an external 32-bit units valueprotected long encodeExpiry(long cExpiryDelay)
decoded
to yield an absolute date-time that is approximately equivalent to the the specified delay from the current time.cExpiryDelay
- the relative delay from the current time; must be >= 0protected long decodeExpiry(long cExpiryEncoded)
cExpiryEncoded
- the encoded expiry valueprotected int encodeTime(long ldt)
ldt
- the time to encodeprotected long decodeTime(int cEncoded)
cEncoded
- the 32-bit encoded time