public class OverflowMap extends AbstractKeySetBasedMap implements CacheMap
The OverflowMap is observable, and as such it is allowed to be an active data structure. In other words, it supports item expiration, eviction, and other types of "self-generating" events. (The SimpleOverflowMap
) is an alternative that may be more efficient if the overflow map is passive.) As a consequence of the requirements for managing the overflow map as an active data structure, the OverflowMap maintains information about each entry in the map; in practice, this will limit the size of the OverflowMap since all keys and some additional information for each key will be maintained in memory. On the other hand, by maintaining this information in memory, certain operations will be more efficient, such as the methods containsKey()
, size()
, keySet().iterator()
, etc. (Again, for an alternative, see SimpleOverflowMap
, which does not maintain the entire set of keys in memory.)
The primary reason why OverflowMap is based on the AbstractKeySetBasedMap is that the set of keys within the OverflowMap is considered to be "known", although not altogether stable due to concurrency issues (the OverflowMap is designed to support a high level of concurrency). AbstractKeySetBasedMap conceptually delegates many operations down to its key Set, which the OverflowMap implementation reverses (by having the implementations on the OverflowMap itself). However, the key and entry Sets and the values Collection benefit significantly in terms of their ability to optimize the Collection.iterator()
and Collection.toArray()
methods.
Further, as a result (and sometimes as a consequence) of its observability, the OverflowMap supports (and has to support) a number of capabilities that the SimpleOverflowMap does not:
Modifier and Type | Class and Description |
---|---|
protected class |
OverflowMap.BackMapListener
A listener for the back map.
|
class |
OverflowMap.EntrySet
A set of entries backed by this map.
|
protected static class |
OverflowMap.ExpirableStatus
The ExpirableStatus adds expiry to the base Status object.
|
protected class |
OverflowMap.FrontMapListener
A listener for the front map that moves evictions to the back map.
|
protected static class |
OverflowMap.HistoricCacheEvent
A CacheEvent that carries a recent value (to avoid it being lost during eviction).
|
protected class |
OverflowMap.InternalKeySet
A read-only set of keys backed by this map.
|
protected static class |
OverflowMap.Status
The Status object is used to manage concurrency at the key level for the key-level operations against the Map, to track all the items in the front Map, to manage the state transition for operations occurring against the Map, and to coordinate events across multiple threads.
|
AbstractKeySetBasedMap.KeyIterator, AbstractKeySetBasedMap.KeySet, AbstractKeySetBasedMap.ValuesCollection
AbstractKeyBasedMap.DeferredCacheEvent<K,V>
Base.LoggingWriter, Base.StackFrame
Modifier and Type | Field and Description |
---|---|
static int |
ENTRY_DELETED
This event indicates that an entry has been removed from the map.
|
static int |
ENTRY_INSERTED
This event indicates that an entry has been added to the map.
|
static int |
ENTRY_UPDATED
This event indicates that an entry has been updated in the map.
|
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
Constructor and Description |
---|
OverflowMap(ObservableMap mapFront, Map mapBack)
Construct a OverflowMap using two specified maps: FrontMap (aka "cache" or "shallow") and BackMap (aka "file" or "deep") If the BackMap implements the ObservableMap interface a listener will be added to the BackMap to invalidate items updated [externally] in the back map.
|
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 void |
adjustSize(int cItems)
Adjust the number of entries in the OverflowMap.
|
protected OverflowMap.Status |
beginKeyProcess(Object oKey)
Block until a key is available for processing, and return the Status object for that key.
|
protected void |
beginMapProcess()
Block until this thread has exclusive access to perform operations against the OverflowMap.
|
void |
clear()
Clear all key/value mappings.
|
protected void |
closeStatus(OverflowMap.Status status)
Helper method to close a Status, processing any pending events as part of the process.
|
boolean |
containsKey(Object oKey)
Returns true if this map contains a mapping for the specified key.
|
protected void |
dispatchEvent(OverflowMap.Status status, int nId, Object oKey, Object oValueOld, Object oValueNew, boolean fSynthetic)
Dispatch an event containing the passed event information.
|
protected void |
dispatchEvent(OverflowMap.Status status, MapEvent evt)
Dispatch the passed event.
|
protected void |
endKeyProcess(Object oKey, OverflowMap.Status status)
Finish the processing of a single key.
|
protected void |
endMapProcess()
Release exclusive access for the OverflowMap.
|
void |
evict()
Flush items that have expired.
|
protected static void |
evict(Map map)
If the passed Map supports it, evict its expired data.
|
Object |
get(Object oKey)
Returns the value to which this map maps the specified key.
|
Map |
getAll(Collection colKeys)
Get all the specified keys, if they are in the Map.
|
Map |
getBackMap()
Returns the back Map.
|
protected MapListener |
getBackMapListener()
Get the MapListener for the back map.
|
CacheStatistics |
getCacheStatistics()
Returns the CacheStatistics for this cache.
|
protected List |
getDeferredList()
Obtain the List of keys that may have deferred events.
|
protected LongArray |
getExpiryArray()
Obtain the array of keys that have an expiration, indexed by expiration times.
|
int |
getExpiryDelay()
Determine the "time to live" for each individual cache entry.
|
ObservableMap |
getFrontMap()
Returns the front Map.
|
protected MapListener |
getFrontMapListener()
Get the MapListener for the front map.
|
protected Gate |
getGate()
Obtain the Gate for managing key-level and Collection-level operations against the Map, versus Map-level operations themselves.
|
protected Object |
getInternal(Object oKey, boolean fStats, Map mapResult)
A combined implementation of
get(java.lang.Object) and getAll(java.util.Collection) that eliminates duplicate (and very complex) code. |
protected Set |
getInternalKeySet()
Obtain a set of keys that are represented by this Map.
|
protected static Object |
getLatestOldValue(MapEvent evt)
Obtain the latest old value from the passed event.
|
protected MapListenerSupport |
getMapListenerSupport()
Accessor for the MapListenerSupport for sub-classes.
|
protected int |
getSize()
Obtain the number of entries in the OverflowMap.
|
protected Map |
getStatusMap()
Obtain the Map of Status objects for entries managed by this Overflow Map.
|
protected boolean |
hasListeners()
Determine if the OverflowMap has any listeners at all.
|
protected MapListener |
instantiateBackMapListener()
Factory pattern: Back Map Listener.
|
protected Set |
instantiateEntrySet()
Factory pattern: Create a Set that represents the entries in the Map.
|
protected MapListener |
instantiateFrontMapListener()
Factory pattern: Front Map Listener.
|
protected Set |
instantiateInternalKeySet()
Factory pattern: Create a read-only Set of keys in the Overflow Map
|
protected OverflowMap.Status |
instantiateStatus()
Factory method: Instantiate a Status object.
|
boolean |
isEmpty()
Returns true if this map contains no key-value mappings.
|
boolean |
isExpiryEnabled()
Determine if this OverflowMap supports entry expiry.
|
boolean |
isFrontPutBlind()
Determine if the front Map is more efficiently updated using putAll.
|
protected boolean |
isInternalKeySetIteratorMutable()
Determine if this Iterator should remove an iterated item by calling remove on the internal key Set Iterator, or by calling removeBlind on the map itself.
|
boolean |
isNullValuesAllowed()
Determine if null values are permitted.
|
protected static boolean |
isSynthetic(MapEvent evt)
Helper method to determine if an event is synthetic.
|
protected static MapEvent |
mergeEvents(MapEvent evtOld, MapEvent evtNew)
Merge two events that have been raised in sequence from a given map.
|
protected void |
onBackEvent(MapEvent evtBack)
Handle an event occuring against the "back" map.
|
protected void |
onFrontEvent(MapEvent evt)
Either handle an event by turning it over to another thread that is processing the key specified by the event, or take responsibility on this thread for deferring the event and registering its immediate side-effects.
|
protected boolean |
prepareStatus(Object oKey, OverflowMap.Status status)
Validate the status and process any deferred events or pending expiry.
|
protected void |
processBackEvent(OverflowMap.Status status, MapEvent evtBack)
Process an event.
|
protected void |
processDeferredEvents(boolean fProcessAll)
Process deferred events, if there are any.
|
protected void |
processEvent(OverflowMap.Status status, MapEvent evt)
Process an arbitrary event that has occurred against either the front or back map.
|
protected void |
processFrontEvent(OverflowMap.Status status, MapEvent evtFront)
Process an event.
|
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 Object |
putInternal(Object oKey, Object oValue, boolean fStoreOnly, long cMillis)
A combined implementation of
put(Object, Object) and "void put(Object, Object)" that eliminates duplicate (and muchos complex) code between the put(java.lang.Object, java.lang.Object) and putAll(java.util.Map) methods. |
protected static void |
putOne(Map map, Object oKey, Object oValue, boolean fPutBlind)
Helper to put a value into a map using either the put or putAll method.
|
protected void |
registerExpiry(Object oKey, long ldtExpire)
Register an expiry for the specified key.
|
protected void |
releaseClosedStatus(Object oKey)
Helper method to encapsulate the release of a Status object on which closeProcessing() has already been called.
|
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, boolean fCheckRemovedOnly, boolean fEviction)
A combined implementation of remove() and removeBlind() that eliminates duplicate (and muchos complex) code
|
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.
|
protected void |
setBackMapListener(MapListener listener)
Specify the MapListener for the back map.
|
protected void |
setExpiryArray(LongArray laExpiry)
Specify the array of keys that have an expiration, indexed by expiration times.
|
void |
setExpiryDelay(int cMillis)
Specify the "time to live" for cache entries.
|
void |
setExpiryEnabled(boolean fEnableExpiry)
Specify whether or not entry expiry is supported.
|
protected void |
setFrontMapListener(MapListener listener)
Specify the MapListener for the front map.
|
void |
setFrontPutBlind(boolean fUseFrontPutAll)
Specify whether the front Map is more efficiently updated using putAll.
|
void |
setNullValuesAllowed(boolean fAllowNulls)
Specify whether null values are permitted.
|
protected void |
setSize(int cItems)
Update the number of entries in the OverflowMap.
|
int |
size()
Returns the number of key-value mappings in this map.
|
protected void |
unregisterExpiry(Object oKey, long ldtExpire)
Unregister the specified key expiry that is registered to expire at the specified time.
|
protected static void |
verifyNoNulls(Collection collection, String sAssert)
Check the passed collection for nulls, and fail if it contains any.
|
protected static void |
warnEventSequence(MapEvent evtOld, MapEvent evtNew)
Issue a one-time warning that events are being received in an order than cannot be explained by normal operation according to the contracts expected by this OverflowMap.
|
protected void |
warnMissingEvent(Object oKey, int nId, boolean fFront)
An expected event did not get raised.
|
protected void |
warnUnfathomable(MapEvent evt)
Something totally inexplicable has occurred.
|
instantiateKeyIterator, instantiateKeySet, instantiateValues, iterateKeys
clone, containsValue, entrySet, equals, hashCode, keySet, toString, 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, containsValue, entrySet, equals, forEach, getOrDefault, hashCode, keySet, merge, putIfAbsent, remove, replace, replace, replaceAll, values
public static final int ENTRY_INSERTED
public static final int ENTRY_UPDATED
public static final int ENTRY_DELETED
public OverflowMap(ObservableMap mapFront, Map mapBack)
mapBack
- back mapmapFront
- front mappublic void clear()
clear
in interface Map
clear
in class AbstractKeyBasedMap
public boolean containsKey(Object oKey)
containsKey
in interface Map
containsKey
in class AbstractKeySetBasedMap
public Object get(Object oKey)
get
in interface Map
get
in class AbstractKeyBasedMap
oKey
- the key objectpublic boolean isEmpty()
isEmpty
in interface Map
isEmpty
in class AbstractKeySetBasedMap
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 void putAll(Map map)
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.putAll
in interface Map
putAll
in class AbstractKeyBasedMap
map
- the Map containing the key/value pairings to put into this Mappublic Object remove(Object oKey)
remove
in interface Map
remove
in class AbstractKeyBasedMap
oKey
- key whose mapping is to be removed from the mappublic int size()
size
in interface Map
size
in class AbstractKeySetBasedMap
public Object put(Object oKey, Object oValue, long cMillis)
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 keycMillis
- 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()public Map getAll(Collection colKeys)
getAll
in interface CacheMap
getAll
in class AbstractKeyBasedMap
colKeys
- a collection of keys that may be in the named cachepublic 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() callprotected boolean removeBlind(Object oKey)
removeBlind
in class AbstractKeyBasedMap
oKey
- key whose mapping is to be removed from the mapprotected Set getInternalKeySet()
The AbstractKeySetBasedMap only utilizes the internal key set as a read-only resource.
getInternalKeySet
in class AbstractKeySetBasedMap
protected boolean isInternalKeySetIteratorMutable()
isInternalKeySetIteratorMutable
in class AbstractKeySetBasedMap
AbstractKeyBasedMap.removeBlind(Object)
methodprotected Object getInternal(Object oKey, boolean fStats, Map mapResult)
get(java.lang.Object)
and getAll(java.util.Collection)
that eliminates duplicate (and very complex) code.oKey
- the key to accessfStats
- pass true to update statisticsmapResult
- pass a map into which the key and its value will be put iff the key is contained within the overflow mapprotected Object putInternal(Object oKey, Object oValue, boolean fStoreOnly, long cMillis)
put(Object, Object)
and "void put(Object, Object)" that eliminates duplicate (and muchos complex) code between the put(java.lang.Object, java.lang.Object)
and putAll(java.util.Map)
methods. Additionally implements the put-with-expiry option.oKey
- the key to storeoValue
- the value to storefStoreOnly
- pass true to simply store the new value, or false to both store the new value and return the previous valuecMillis
- the time-to-live for the entry as defined by CacheMap.put(Object, Object, long)
protected Object removeInternal(Object oKey, boolean fCheckRemovedOnly, boolean fEviction)
oKey
- the key to removefCheckRemovedOnly
- pass true to only check for entry existencefEviction
- pass true if the removal is an eviction and if the status is already owned by this threadpublic ObservableMap getFrontMap()
Warning: Direct modifications of the returned map may cause unpredictable behavior of the Overflow Map.
public Map getBackMap()
Warning: Direct modifications of the returned map may cause unpredictable behavior of the Overflow Map.
public int getExpiryDelay()
EXPIRY_NEVER
if the entries never expire by defaultpublic void setExpiryDelay(int cMillis)
cMillis
- the number of milliseconds to specify that cache entries subsequently added without an expiry will live, EXPIRY_DEFAULT
to indicate that the OverflowMap's default expiry be used (which is to never automatically expire values), or EXPIRY_NEVER
to specify that cache entries subsequently added without an expiry will never expireprotected int getSize()
protected void setSize(int cItems)
cItems
- the cached size of the OverflowMapprotected void adjustSize(int cItems)
cItems
- the number of items to adjust the cached size of the OverflowMap by, for example +1 or -1public CacheStatistics getCacheStatistics()
protected Gate getGate()
protected Map getStatusMap()
protected LongArray getExpiryArray()
protected void setExpiryArray(LongArray laExpiry)
laExpiry
- a LongArray to use to keep track of what expires whenprotected MapListener getFrontMapListener()
protected void setFrontMapListener(MapListener listener)
The caller is required to manage all of the thread concurrency issues associated with modifying the listener.
listener
- the MapListener for the front mapprotected MapListener getBackMapListener()
protected void setBackMapListener(MapListener listener)
The caller is required to manage all of the thread concurrency issues associated with modifying the listener.
listener
- the MapListener for the back mapprotected List getDeferredList()
public boolean isNullValuesAllowed()
public void setNullValuesAllowed(boolean fAllowNulls)
fAllowNulls
- pass true to allow null values; false to disallowpublic boolean isExpiryEnabled()
public void setExpiryEnabled(boolean fEnableExpiry)
Note that this feature must be enabled before populating the cache.
fEnableExpiry
- pass true to enable entry expiry, false to disable itpublic boolean isFrontPutBlind()
public void setFrontPutBlind(boolean fUseFrontPutAll)
fUseFrontPutAll
- pass true to allow null values; false to disallowprotected OverflowMap.Status beginKeyProcess(Object oKey)
OverflowMap.Status.closeProcessing()
and then perform its final adjustments to the Status data structure, handling any events that were queued in the meantime on the Status. After completing the processing during this "quiet period" in which all other threads are prevented from accessing this entry or handling events for this entry, then the caller must call endKeyProcess(java.lang.Object, com.tangosol.net.cache.OverflowMap.Status)
passing the Status object returned from this method.oKey
- the key to processprotected void endKeyProcess(Object oKey, OverflowMap.Status status)
status
- the Status object returned from the call to beginKeyProcess(java.lang.Object)
protected void beginMapProcess()
protected void endMapProcess()
protected boolean prepareStatus(Object oKey, OverflowMap.Status status)
oKey
- the entry keystatus
- the Status object for the entryprotected void onFrontEvent(MapEvent evt)
protected void onBackEvent(MapEvent evtBack)
evtBack
- an event from the back mapprotected static MapEvent mergeEvents(MapEvent evtOld, MapEvent evtNew)
evtOld
- the first eventevtNew
- the second eventprotected static Object getLatestOldValue(MapEvent evt)
evt
- an event (which may be a HistoricCacheEvent)protected void processEvent(OverflowMap.Status status, MapEvent evt)
status
- the Status object representing the Overflow Map's entry against which the event was raisedevt
- the MapEvent to processprotected void processFrontEvent(OverflowMap.Status status, MapEvent evtFront)
evtFront
- the event to process; may be nullprotected void processBackEvent(OverflowMap.Status status, MapEvent evtBack)
evtBack
- the event to process; may be nullprotected void processDeferredEvents(boolean fProcessAll)
fProcessAll
- pass true to process all pending events, false to process just a fair portion of themprotected void closeStatus(OverflowMap.Status status)
status
- the Status object to closeprotected void releaseClosedStatus(Object oKey)
oKey
- the entry keyprotected MapListenerSupport getMapListenerSupport()
protected boolean hasListeners()
protected void dispatchEvent(OverflowMap.Status status, int nId, Object oKey, Object oValueOld, Object oValueNew, boolean fSynthetic)
status
- the Status for the entrynId
- this event's idoKey
- the key into the mapoValueOld
- the old valueoValueNew
- the new valuefSynthetic
- true iff the event is caused by the cache internal processing such as eviction or loadingprotected void dispatchEvent(OverflowMap.Status status, MapEvent evt)
status
- the Status for the entryevt
- a MapEvent objectprotected static boolean isSynthetic(MapEvent evt)
evt
- a Map Eventprotected void registerExpiry(Object oKey, long ldtExpire)
oKey
- the key of the entry to expireldtExpire
- the time to expire the entryprotected void unregisterExpiry(Object oKey, long ldtExpire)
oKey
- the key that is set to expireldtExpire
- the time that the key is set to expireprotected static void verifyNoNulls(Collection collection, String sAssert)
collection
- a CollectionsAssert
- the human-readable description of the error if any nulls are found in the passed Collectionprotected static void putOne(Map map, Object oKey, Object oValue, boolean fPutBlind)
map
- the Map to put intooKey
- the key to putoValue
- the value to putfPutBlind
- true to use the putBlind optimizationpublic void evict()
protected static void evict(Map map)
map
- a Map that may or may not support the requesting of an eviction of expired dataprotected void warnMissingEvent(Object oKey, int nId, boolean fFront)
oKey
- the key for which an event is missingnId
- the event type that is missingfFront
- true if the event was expected to come from the front map, false if from the back mapprotected void warnUnfathomable(MapEvent evt)
evt
- the event that cannot be explainedprotected static void warnEventSequence(MapEvent evtOld, MapEvent evtNew)
evtOld
- the previous (potentially amalgamated) eventevtNew
- the new eventprotected Set instantiateEntrySet()
instantiateEntrySet
in class AbstractKeySetBasedMap
protected Set instantiateInternalKeySet()
protected OverflowMap.Status instantiateStatus()
protected MapListener instantiateFrontMapListener()
protected MapListener instantiateBackMapListener()