com.tangosol.net.cache

Class SerializationCache

java.lang.Object

com.tangosol.util.Base

com.tangosol.util.AbstractKeyBasedMap<K,V>

com.tangosol.util.AbstractKeySetBasedMap

com.tangosol.net.cache.SerializationMap

com.tangosol.net.cache.AbstractSerializationCache

com.tangosol.net.cache.SerializationCache

All Implemented Interfaces:

CacheMap, ConfigurableCacheMap, ObservableMap, Map

public class SerializationCache
extends AbstractSerializationCache
implements CacheMap, ConfigurableCacheMap

A version of SerializationMap that implements an LRU policy.

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.

The primary reason why SerializationCache is a sub-class of SerializationMap instead of combining their functionality is that SerializationMap represents a passive store, and thus does not implement the ObservableMap interface, while SerializationCache represents an active store, and thus clients of it would have to always handle potential events, even if it were not size-limited.

Since:

Coherence 2.2

Author:

cp 2003.05.28

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	SerializationCache.EntryAttributes A class that holds on to the expiry time and touch order for an entry.
class	SerializationCache.EntrySet A set of entries backed by this map.
static class	SerializationCache.InternalEvictionPolicy The InternalEvictionPolicy represents a pluggable eviction policy for the non-pluggable built-in (internal) eviction policies supported by this cache implementation.

Nested classes/interfaces inherited from class com.tangosol.util.AbstractKeySetBasedMap

AbstractKeySetBasedMap.KeyIterator, AbstractKeySetBasedMap.KeySet, AbstractKeySetBasedMap.ValuesCollection

Nested classes/interfaces inherited from class com.tangosol.util.AbstractKeyBasedMap

AbstractKeyBasedMap.DeferredCacheEvent<K,V>

Nested classes/interfaces inherited from class com.tangosol.util.Base

Base.LoggingWriter, Base.StackFrame

Nested classes/interfaces inherited from interface com.tangosol.net.cache.ConfigurableCacheMap

ConfigurableCacheMap.Entry, ConfigurableCacheMap.EvictionApprover, ConfigurableCacheMap.EvictionPolicy, ConfigurableCacheMap.UnitCalculator

Field Summary

Fields

Modifier and Type	Field and Description
protected ConfigurableCacheMap.EvictionApprover	m_apprvrEvict The EvictionApprover.
protected ConfigurableCacheMap.UnitCalculator	m_calculator The unit calculator to use to limit size of the cache.
protected long	m_cCurUnits Current number of units to in the cache.
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 int	m_nUnitFactor The unit factor.

Fields inherited from class com.tangosol.util.Base

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

Fields inherited from interface com.tangosol.net.cache.CacheMap

EXPIRY_DEFAULT, EXPIRY_NEVER

Constructor Summary

Constructors

Constructor and Description
SerializationCache(BinaryStore store, int cMax) Construct a SerializationCache on top of a BinaryStore.
SerializationCache(BinaryStore store, int cMax, boolean fBinaryMap) Construct a SerializationCache on top of a BinaryStore.
SerializationCache(BinaryStore store, int cMax, ClassLoader loader) Construct a SerializationCache on top of a BinaryStore.

Method Summary

Modifier and Type	Method and Description
protected void	checkExpiry() Make sure that the cache does not contain expired items.
protected void	checkSize() Make sure the size of the cache isn't too big.
void	clear() Clear all key/value mappings.
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.
void	evict() Flush items that have expired.
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.
void	flush() Deprecated. use evict()
Object	get(Object oKey) Returns the value to which this map maps the specified key.
ConfigurableCacheMap.Entry	getCacheEntry(Object oKey) Locate a cache Entry in the cache based on its key.
protected String	getDescription() Assemble a human-readable description.
ConfigurableCacheMap.EvictionApprover	getEvictionApprover() Obtain the registered EvictionApprover.
ConfigurableCacheMap.EvictionPolicy	getEvictionPolicy() Obtain the current EvictionPolicy used by the cache.
protected LongArray	getExpiryArray() Get the Expiry data structure.
int	getExpiryDelay() Determine the default "time to live" for each individual cache entry.
int	getHighUnits() Determine the limit of the cache size in units.
int	getLowUnits() Determine the point to which the cache will shrink when it prunes.
protected LongArray	getLruArray() Get the LRU data structure.
long	getNextExpiryTime() Determine the next expiry time for the cache entries.
protected long	getTouchCounter() Determine the next value from the touch counter.
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.
SerializationCache.EntryAttributes	instantiateEntryAttributes(SerializationCache.EntryAttributes attrOrig, long ldtExpires, long nTouch, int cUnits) Factory pattern: Construct an attribute holder for an entry.
protected Set	instantiateEntrySet() Factory pattern: Create a Set that represents the entries in the Map.
boolean	isEmpty() Returns true if this map contains no key-value mappings.
Object	put(Object oKey, Object oValue) Associates the specified value with the specified key in this map.
Object	put(Object oKey, Object oValue, long cMillis) Associates the specified value with the specified key in this cache.
void	putAll(Map map) Copies all of the mappings from the specified map to this map.
protected void	registerKey(Object oKey, Binary binKey, Binary binValue) Register a new key for the SerializationMap.
protected void	registerKey(Object oKey, Binary binKey, Binary binValue, int cMillis) Register a new key for the SerializationMap.
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 void	setBinaryStore(BinaryStore store) Configures the BinaryStore that this map will use for its storage.
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.
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.
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.
int	size() Returns the number of key-value mappings in this map.
String	toString() Returns a string representation of this Map.
protected void	touch(Object oKey) Touch an object to pop it to the top of the LRU
protected void	unregisterKey(Object oKey) Unregister a key from the SerializationMap.

Methods inherited from class com.tangosol.net.cache.AbstractSerializationCache

addMapListener, addMapListener, addMapListener, dispatchEvent, dispatchPendingEvent, getMapListenerSupport, hasListeners, removeMapListener, removeMapListener, removeMapListener

Methods inherited from class com.tangosol.net.cache.SerializationMap

eraseStore, fromBinary, getBinaryStore, getCacheStatistics, getClassLoader, getInternalKeySet, getKeyMap, instantiateKeyMap, isBinaryMap, setBinaryMap, setClassLoader, toBinary

Methods inherited from class com.tangosol.util.AbstractKeySetBasedMap

instantiateKeyIterator, instantiateKeySet, instantiateValues, isInternalKeySetIteratorMutable, iterateKeys

Methods inherited from class com.tangosol.util.AbstractKeyBasedMap

clone, entrySet, equals, getAll, hashCode, keySet, values

Methods inherited from class com.tangosol.util.Base

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, mod, mod, 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

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.tangosol.net.cache.CacheMap

forEach, getAll

Methods inherited from interface com.tangosol.util.ObservableMap

addMapListener, addMapListener, addMapListener, removeMapListener, removeMapListener, removeMapListener

Methods inherited from interface java.util.Map

compute, computeIfAbsent, computeIfPresent, entrySet, equals, forEach, getOrDefault, hashCode, keySet, merge, putIfAbsent, remove, replace, replace, replaceAll, values

Field Detail

m_cMaxUnits

protected long m_cMaxUnits

Maximum number of units to manage in the cache.

m_cCurUnits

protected long m_cCurUnits

Current number of units to in the cache.

m_cPruneUnits

protected long m_cPruneUnits

The number of units to prune the cache down to.

m_calculator

protected ConfigurableCacheMap.UnitCalculator m_calculator

The unit calculator to use to limit size of the cache.

m_nUnitFactor

protected int m_nUnitFactor

The unit factor.

m_apprvrEvict

protected ConfigurableCacheMap.EvictionApprover m_apprvrEvict

The EvictionApprover.

Constructor Detail

SerializationCache

public SerializationCache(BinaryStore store,
                          int cMax)

Construct a SerializationCache on top of a BinaryStore.

Parameters:

store - the BinaryStore to use to write the serialized objects to

cMax - the maximum number of items to store in the binary store

SerializationCache

public SerializationCache(BinaryStore store,
                          int cMax,
                          ClassLoader loader)

Construct a SerializationCache on top of a BinaryStore.

Parameters:

store - the BinaryStore to use to write the serialized objects to

cMax - the maximum number of items to store in the binary store

loader - the ClassLoader to use for deserialization

SerializationCache

public SerializationCache(BinaryStore store,
                          int cMax,
                          boolean fBinaryMap)

Construct a SerializationCache on top of a BinaryStore.

Parameters:

store - the BinaryStore to use to write the serialized objects to

cMax - the maximum number of items to store in the binary store

fBinaryMap - true indicates that this map will only manage binary keys and values

Since:

Coherence 2.4

Method Detail

clear

public void clear()

Clear all key/value mappings.

Specified by:

clear in interface Map

Overrides:

clear in class AbstractSerializationCache

containsKey

public boolean containsKey(Object oKey)

Returns true if this map contains a mapping for the specified key.

Specified by:

containsKey in interface Map

Overrides:

containsKey in class AbstractKeySetBasedMap

Returns:

true if this map contains a mapping for the specified key, false otherwise.

containsValue

public boolean containsValue(Object oValue)

Returns true if this Map maps one or more keys to the specified value.

Specified by:

containsValue in interface Map

Overrides:

containsValue in class SerializationMap

Returns:

true if this Map maps one or more keys to the specified value, false otherwise

get

public Object get(Object oKey)

Returns the value to which this map maps the specified key.

Specified by:

get in interface Map

Overrides:

get in class SerializationMap

Parameters:

oKey - the key object

Returns:

the value to which this map maps the specified key, or null if the map contains no mapping for this key

isEmpty

public boolean isEmpty()

Returns true if this map contains no key-value mappings.

Specified by:

isEmpty in interface Map

Overrides:

isEmpty in class AbstractKeySetBasedMap

Returns:

true if this map contains no key-value mappings

put

public Object put(Object oKey,
                  Object oValue)

Associates the specified value with the specified key in this map.

Specified by:

put in interface CacheMap

Specified by:

put in interface Map

Overrides:

put in class AbstractSerializationCache

Parameters:

oKey - key with which the specified value is to be associated

oValue - value to be associated with the specified key

Returns:

previous value associated with specified key, or null if there was no mapping for key

putAll

public void putAll(Map map)

Copies all of the mappings from the specified map to this map. The effect of this call is equivalent to that of calling AbstractKeyBasedMap.put(K, V) on this map once for each mapping in the passed map. The behavior of this operation is unspecified if the passed map is modified while the operation is in progress.

Specified by:

putAll in interface Map

Overrides:

putAll in class AbstractSerializationCache

Parameters:

map - the Map containing the key/value pairings to put into this Map

remove

public Object remove(Object oKey)

Removes the mapping for this key from this map if present. Expensive: updates both the underlying cache and the local cache.

Specified by:

remove in interface Map

Overrides:

remove in class AbstractSerializationCache

Parameters:

oKey - key whose mapping is to be removed from the map

Returns:

previous value associated with specified key, or null if there was no mapping for key. A null return can also indicate that the map previously associated null with the specified key, if the implementation supports null values.

size

public int size()

Returns the number of key-value mappings in this map.

Specified by:

size in interface Map

Overrides:

size in class AbstractKeySetBasedMap

Returns:

the number of key-value mappings in this map

removeBlind

protected boolean removeBlind(Object oKey)

Removes the mapping for this key from this map if present. This method exists to allow sub-classes to optimize remove functionality for situations in which the original value is not required.

Overrides:

removeBlind in class AbstractSerializationCache

Parameters:

oKey - key whose mapping is to be removed from the map

Returns:

true iff the Map changed as the result of this operation

put

public Object put(Object oKey,
                  Object oValue,
                  long cMillis)

Associates the specified value with the specified key in this cache. If the cache previously contained a mapping for this key, the old value is replaced. This variation of the CacheMap.put(Object oKey, Object oValue) method allows the caller to specify an expiry (or "time to live") for the cache entry.

Specified by:

put in interface CacheMap

Parameters:

oKey - key with which the specified value is to be associated

oValue - value to be associated with the specified key

cMillis - 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()

Returns:

previous value associated with specified key, or null if there was no mapping for key. A null return can also indicate that the map previously associated null with the specified key, if the implementation supports null values

getUnits

public int getUnits()

Determine the number of units that the cache currently stores.

Note: It is expected that the return type will be widened to a long in Coherence 4.

Specified by:

getUnits in interface ConfigurableCacheMap

Returns:

the current size of the cache in units

getHighUnits

public int getHighUnits()

Determine the limit of the cache size in units. The cache will prune itself automatically once it reaches its maximum unit level. This is often referred to as the "high water mark" of the cache.

Note: It is expected that the return type will be widened to a long in Coherence 4.

Specified by:

getHighUnits in interface ConfigurableCacheMap

Returns:

the limit of the cache size in units

setHighUnits

public void setHighUnits(int cMax)

Update the maximum size of the cache in units. This is often referred to as the "high water mark" of the cache.

Note: It is expected that the parameter will be widened to a long in Coherence 4.

Specified by:

setHighUnits in interface ConfigurableCacheMap

Parameters:

cMax - the new maximum size of the cache, in units

getLowUnits

public int getLowUnits()

Determine the point to which the cache will shrink when it prunes. This is often referred to as a "low water mark" of the cache. If the cache incrementally prunes, then this setting will have no effect.

Note: It is expected that the parameter will be widened to a long in Coherence 4.

Specified by:

getLowUnits in interface ConfigurableCacheMap

Returns:

the number of units that the cache prunes to

setLowUnits

public void setLowUnits(int cUnits)

Specify the point to which the cache will shrink when it prunes. This is often referred to as a "low water mark" of the cache.

Note: It is expected that the parameter will be widened to a long in Coherence 4.

Specified by:

setLowUnits in interface ConfigurableCacheMap

Parameters:

cUnits - the number of units that the cache prunes to

getUnitFactor

public int getUnitFactor()

Determine the factor by which the Units, LowUnits and HighUnits properties are adjusted. Using a binary unit calculator, for example, the factor 1048576 could be used to count megabytes instead of bytes.

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.

Specified by:

getUnitFactor in interface ConfigurableCacheMap

Returns:

the units factor; the default is 1

setUnitFactor

public void setUnitFactor(int nFactor)

Determine the factor by which the Units, LowUnits and HighUnits properties are adjusted. Using a binary unit calculator, for example, the factor 1048576 could be used to count megabytes instead of bytes.

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.

Specified by:

setUnitFactor in interface ConfigurableCacheMap

Parameters:

nFactor - the units factor; the default is 1

getEvictionPolicy

public ConfigurableCacheMap.EvictionPolicy getEvictionPolicy()

Obtain the current EvictionPolicy used by the cache.

Specified by:

getEvictionPolicy in interface ConfigurableCacheMap

Returns:

the EvictionPolicy used by the cache

setEvictionPolicy

public void setEvictionPolicy(ConfigurableCacheMap.EvictionPolicy policy)

Set the EvictionPolicy for the cache to use.

Specified by:

setEvictionPolicy in interface ConfigurableCacheMap

Parameters:

policy - an EvictionPolicy

evict

public void evict(Object oKey)

Evict a specified key from the cache, as if it had expired from the cache. If the key is not in the cache, then the method has no effect.

Specified by:

evict in interface ConfigurableCacheMap

Parameters:

oKey - the key to evict from the cache

evictAll

public void evictAll(Collection colKeys)

Evict the specified keys from the cache, as if they had each expired from the cache.

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);
     }
 

Specified by:

evictAll in interface ConfigurableCacheMap

Parameters:

colKeys - a collection of keys to evict from the cache

evict

public void evict()

Flush items that have expired.

Specified by:

evict in interface ConfigurableCacheMap

Specified by:

evict in class AbstractSerializationCache

getExpiryDelay

public int getExpiryDelay()

Determine the default "time to live" for each individual cache entry.

Specified by:

getExpiryDelay in interface ConfigurableCacheMap

Returns:

the number of milliseconds that a cache entry value will live, or zero if cache entries are never automatically expired

setExpiryDelay

public void setExpiryDelay(int cMillis)

Specify the default "time to live" for cache entries. This does not affect the already-scheduled expiry of existing entries.

Specified by:

setExpiryDelay in interface ConfigurableCacheMap

Parameters:

cMillis - the number of milliseconds that cache entries will live, or zero to disable automatic expiry

getNextExpiryTime

public long getNextExpiryTime()

Determine the next expiry time for the cache entries. This value is supposed to be used only by the "active" expiry algorithms, so for implementations that choose to return the value of zero the entries will be evicted as with pre-existing "passive" expiry approach.

Specified by:

getNextExpiryTime in interface ConfigurableCacheMap

Returns:

the earliest time (using the 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 eviction

getEvictionApprover

public ConfigurableCacheMap.EvictionApprover getEvictionApprover()

Obtain the registered EvictionApprover.

Specified by:

getEvictionApprover in interface ConfigurableCacheMap

Returns:

the EvictionApprover (could be null)

setEvictionApprover

public void setEvictionApprover(ConfigurableCacheMap.EvictionApprover approver)

Set the EvictionApprover for this ConfigurableCacheMap.

Specified by:

setEvictionApprover in interface ConfigurableCacheMap

Parameters:

approver - the EvictionApprover

getCacheEntry

public ConfigurableCacheMap.Entry getCacheEntry(Object oKey)

Locate a cache Entry in the cache based on its key.

Specified by:

getCacheEntry in interface ConfigurableCacheMap

Parameters:

oKey - the key object to search for

Returns:

the Entry or null

getUnitCalculator

public ConfigurableCacheMap.UnitCalculator getUnitCalculator()

Obtain the current UnitCalculator used by the cache.

Specified by:

getUnitCalculator in interface ConfigurableCacheMap

Returns:

the UnitCalculator used by the cache

setUnitCalculator

public void setUnitCalculator(ConfigurableCacheMap.UnitCalculator calculator)

Set the UnitCalculator for the cache to use.

Specified by:

setUnitCalculator in interface ConfigurableCacheMap

Parameters:

calculator - a UnitCalculator

flush

public void flush()

Deprecated. use evict()

Flush items that have expired.

toString

public String toString()

Returns a string representation of this Map. The string representation consists of a list of key-value mappings in the order returned by the Map's entrySet view's iterator, enclosed in braces ("{}"). Adjacent mappings are separated by the characters ", " (comma and space). Each key-value mapping is rendered as the key followed by an equals sign ("=") followed by the associated value. Keys and values are converted to strings as by String.valueOf(Object).

Overrides:

toString in class SerializationMap

Returns:

a String representation of this Map

setBinaryStore

protected void setBinaryStore(BinaryStore store)

Configures the BinaryStore that this map will use for its storage.

Overrides:

setBinaryStore in class SerializationMap

Parameters:

store - the BinaryStore to use

getTouchCounter

protected long getTouchCounter()

Determine the next value from the touch counter.

Returns:

the next value from the touch counter

getLruArray

protected LongArray getLruArray()

Get the LRU data structure. The key is a touch count, the value is the Object key for the cache.

Returns:

the the LRU data structure

getExpiryArray

protected LongArray getExpiryArray()

Get the Expiry data structure. The key is a date/time value, the value is a set of Object keys for the cache that expire at that time.

Returns:

the the Expiry data structure

getDescription

protected String getDescription()

Assemble a human-readable description.

Overrides:

getDescription in class AbstractSerializationCache

Returns:

a description of this Map

registerKey

protected void registerKey(Object oKey,
                           Binary binKey,
                           Binary binValue)

Register a new key for the SerializationMap. This method maintains the internal key Set for the SerializationMap.

Overrides:

registerKey in class SerializationMap

Parameters:

oKey - the key that has been added to the map

binKey - the binary form of the key

binValue - the binary form of the value

registerKey

protected void registerKey(Object oKey,
                           Binary binKey,
                           Binary binValue,
                           int cMillis)

Register a new key for the SerializationMap. This method maintains the internal key Set for the SerializationMap.

Parameters:

oKey - the key that has been added to the map

binKey - the binary form of the key (null if only TTL change)

binValue - the binary form of the value (null if only TTL change)

cMillis - the TTL value (in milliseconds) for the entry

touch

protected void touch(Object oKey)

Touch an object to pop it to the top of the LRU

Parameters:

oKey - the key of the object to touch

unregisterKey

protected void unregisterKey(Object oKey)

Unregister a key from the SerializationMap. This method maintains the internal key Set for the SerializationMap.

Overrides:

unregisterKey in class SerializationMap

Parameters:

oKey - the key that has been removed from the map

checkSize

protected void checkSize()

Make sure the size of the cache isn't too big.

checkExpiry

protected void checkExpiry()

Make sure that the cache does not contain expired items.

instantiateEntryAttributes

public SerializationCache.EntryAttributes instantiateEntryAttributes(SerializationCache.EntryAttributes attrOrig,
                                                                     long ldtExpires,
                                                                     long nTouch,
                                                                     int cUnits)

Factory pattern: Construct an attribute holder for an entry.

Parameters:

attrOrig - the previous attributes for this entry, if any

ldtExpires - the date/time at which the entry expires, or zero

nTouch - the touch counter assigned to the entry

cUnits - the number of storage units used by the entry

instantiateEntrySet

protected Set instantiateEntrySet()

Factory pattern: Create a Set that represents the entries in the Map.

Overrides:

instantiateEntrySet in class AbstractKeySetBasedMap

Returns:

a new instance of Set that represents the entries in the Map