com.tangosol.net.cache

Class ContinuousQueryCache<K,V_BACK,V_FRONT>

java.lang.Object

com.tangosol.util.Base

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

com.tangosol.util.AbstractKeySetBasedMap<K,V_FRONT>

com.tangosol.net.cache.ContinuousQueryCache<K,V_BACK,V_FRONT>

Type Parameters:

K - the type of the cache entry keys

V_BACK - the type of the entry values in the back cache that is used as the source for this ContinuousQueryCache

V_FRONT - the type of the entry values in this ContinuousQueryCache, which will be the same as V_BACK, unless a transformer is specified when creating this ContinuousQueryCache

All Implemented Interfaces:

CacheMap<K,V_FRONT>, NamedCache<K,V_FRONT>, ConcurrentMap<K,V_FRONT>, InvocableMap<K,V_FRONT>, ObservableMap<K,V_FRONT>, QueryMap<K,V_FRONT>, Map<K,V_FRONT>

public class ContinuousQueryCache<K,V_BACK,V_FRONT>
extends AbstractKeySetBasedMap<K,V_FRONT>
implements NamedCache<K,V_FRONT>

Create a materialized view of a NamedCache using the Coherence Continuous Query capability.

In addition to providing an up-to-date view of the backing NamedCache, this class supports server-side transformation of cache values. For example, you could create a client-side view of a cache containing Portfolio instances that only contains the value of each portfolio:

   NamedCache<String, Portfolio> cache =
         CacheFactory.getTypedCache("portfolio", TypeAssertion.withoutTypeChecking());
   NamedCache<String, Double>    cqc   = new ContinuousQueryCache<>(cache,
                                                                    AlwaysFilter.INSTANCE,
                                                                    Portfolio::getValue);
 

Since:

Coherence 3.1

Author:

cp 2006.01.19

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	ContinuousQueryCache.AddListener A MapListener for adding items to the ContinuousQueryCache.
protected class	ContinuousQueryCache.ConverterAsynchronousProcessor Wraps an AsynchronousProcessor to ensure the result of the EntryProcessor execution is deserialized prior to passing to the provided AsynchronousProcessor.
protected class	ContinuousQueryCache.DeactivationListener DeactivationListener for the underlying NamedCache.
protected class	ContinuousQueryCache.EventRouter<K,V> An EventRouter routes events from the internal cache of the ContinuousQueryCache to the client listeners, and it can do so asynchronously when appropriate.
protected class	ContinuousQueryCache.InternalMapListener This listener allows interception of all events triggered by the the internal ObservableMap of the ContinuousQueryCache.
class	ContinuousQueryCache.RemoveListener A MapListener for evicting items from the ContinuousQueryCache.
protected class	ContinuousQueryCache.ServiceListener MemberListener for the underlying cache's service.

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

AbstractKeySetBasedMap.EntrySet, 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.NamedCache

NamedCache.Option

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K,V>

Nested classes/interfaces inherited from interface com.tangosol.util.QueryMap

QueryMap.Entry<K,V>

Nested classes/interfaces inherited from interface com.tangosol.util.InvocableMap

InvocableMap.Entry<K,V>, InvocableMap.EntryAggregator<K,V,R>, InvocableMap.EntryProcessor<K,V,R>, InvocableMap.ParallelAwareAggregator<K,V,P,R>, InvocableMap.StreamingAggregator<K,V,P,R>

Field Summary

Fields

Modifier and Type	Field and Description
protected Converter	m_converterFromBinary Converter that will be used to convert values from binary.
protected Converter	m_converterToBinary Converter that will be used to convert values to binary.
protected long	m_cReconnectMillis The interval (in milliseconds) that indicates how often the ContinuousQueryCache should attempt to synchronize its content with the underlying cache in case the connection is severed.
protected TaskDaemon	m_eventQueue The event queue for this ContinuousQueryCache.
protected boolean	m_fCacheValues The option of whether or not to locally cache values.
protected Filter	m_filter The filter that represents the subset of information from the underlying NamedCache that this ContinuousQueryCache represents.
protected MapEventFilter	m_filterAdd The MapEventFilter that uses the ContinuousQueryCache's filter to select events that would add elements to this cache's contents.
protected MapEventFilter	m_filterRemove The MapEventFilter that uses the ContinuousQueryCache's filter to select events that would remove elements from this cache's contents.
protected boolean	m_fListeners Keeps track of whether the ContinuousQueryCache has listeners that require this cache to cache values.
protected boolean	m_fReadOnly The option to disallow modifications through this ContinuousQueryCache interface.
protected long	m_ldtConnectionTimestamp The timestamp when the synchronization was last attempted.
protected MapListener<K,V_FRONT>	m_listenerAdd The listener that gets information about what should be in this cache.
protected com.tangosol.internal.net.NamedCacheDeactivationListener	m_listenerDeactivation The NamedCacheDeactivationListener.
protected MapListener<K,V_FRONT>	m_listenerRemove The listener that gets information about what should be thrown out of this cache.
protected MemberListener	m_listenerService The cache service MemberListener for the underlying NamedCache.
protected MapListenerSupport	m_listenerSupport Local listener support to allow the ContinuousQueryCache to intercept all events dispatched by the internal ObservableMap.
protected ClassLoader	m_loader The ClassLoader to use when de-serializing/serializing keys and values.
protected Map	m_mapIndex The map of indexes maintained by this cache.
protected MapListener<? super K,? super V_FRONT>	m_mapListener The optional MapListener that may be provided during ContinuousQueryCache construction.
protected ObservableMap<K,V_FRONT>	m_mapLocal The keys that are in this ContinuousQueryCache, and (if m_fCacheValues is true) the corresponding values as well.
protected Map	m_mapSyncReq While the ContinuousQueryCache is configuring or re-configuring its listeners and content, any events that are received must be logged to ensure that the corresponding content is in sync.
protected int	m_nState State of the ContinuousQueryCache.
protected String	m_sName The name of the underlying NamedCache.
protected ValueExtractor<? super V_BACK,? extends V_FRONT>	m_transformer The transformer that should be used to convert values from the underlying cache.
static int	STATE_CONFIGURED State: The ContinuousQueryCache has been configured.
static int	STATE_CONFIGURING State: The ContinuousQueryCache is configuring or re-configuring its listeners and content.
static int	STATE_DISCONNECTED State: Disconnected state.
static int	STATE_SYNCHRONIZED State: The ContinuousQueryCache has been configured and fully synchronized.

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

Fields inherited from interface com.tangosol.util.ConcurrentMap

LOCK_ALL

Constructor Summary

Constructors

Constructor and Description
ContinuousQueryCache(NamedCache<K,V_BACK> cache) Create a locally materialized view of a NamedCache using a Filter.
ContinuousQueryCache(NamedCache<K,V_BACK> cache, Filter filter) Create a locally materialized view of a NamedCache using a Filter.
ContinuousQueryCache(NamedCache<K,V_BACK> cache, Filter filter, boolean fCacheValues) Create a materialized view of a NamedCache using a Filter.
ContinuousQueryCache(NamedCache<K,V_BACK> cache, Filter filter, boolean fCacheValues, MapListener<? super K,? super V_FRONT> listener, ValueExtractor<? super V_BACK,? extends V_FRONT> transformer) Construct the ContinuousQueryCache.
ContinuousQueryCache(NamedCache<K,V_BACK> cache, Filter filter, MapListener<? super K,? super V_FRONT> listener) Create a materialized view of a NamedCache using a Filter.
ContinuousQueryCache(NamedCache<K,V_BACK> cache, Filter filter, MapListener<? super K,? super V_FRONT> listener, ValueExtractor<? super V_BACK,? extends V_FRONT> transformer) Create a materialized view of a NamedCache using a Filter.
ContinuousQueryCache(NamedCache<K,V_BACK> cache, Filter filter, ValueExtractor<? super V_BACK,? extends V_FRONT> transformer) Create a locally materialized view of a NamedCache using a Filter and a transformer.
ContinuousQueryCache(Supplier<NamedCache<K,V_BACK>> supplierCache) Create a locally materialized view of a NamedCache using a Filter.
ContinuousQueryCache(Supplier<NamedCache<K,V_BACK>> supplierCache, Filter filter) Create a locally materialized view of a NamedCache using a Filter.
ContinuousQueryCache(Supplier<NamedCache<K,V_BACK>> supplierCache, Filter filter, boolean fCacheValues, MapListener<? super K,? super V_FRONT> listener, ValueExtractor<? super V_BACK,? extends V_FRONT> transformer, ClassLoader loader) Create a materialized view of a NamedCache using a Filter.

Method Summary

Modifier and Type	Method and Description
<T,E> void	addIndex(ValueExtractor<? super T,? extends E> extractor, boolean fOrdered, Comparator<? super E> comparator) If isCacheValues() is true, the index will be created locally as well as on the NamedCache this ContinuousQueryCache wraps, otherwise, the index will be created on the wrapped NamedCache only.
void	addMapListener(MapListener<? super K,? super V_FRONT> 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<? super K,? super V_FRONT> listener, Filter filter, boolean fLite) Add a map listener that receives events based on a filter evaluation.
void	addMapListener(MapListener<? super K,? super V_FRONT> listener, K oKey, boolean fLite) Add a map listener for a specific key.
<R> R	aggregate(Collection<? extends K> collKeys, InvocableMap.EntryAggregator<? super K,? super V_FRONT,R> aggregator) Perform an aggregating operation against the entries specified by the passed keys.
<R> R	aggregate(Filter filter, InvocableMap.EntryAggregator<? super K,? super V_FRONT,R> aggregator) Perform an aggregating operation against the set of entries that are selected by the given Filter.
protected void	changeState(int nState) Change the state of the ContinuousQueryCache.
protected void	checkEntry(Map.Entry entry) Check the passed value to verify that it does belong in this ContinuousQueryCache.
protected void	checkEntry(Object oKey, Object oValue) Check the passed value to verify that it does belong in this ContinuousQueryCache.
protected void	checkReadOnly() Check the read-only setting to verify that the cache is NOT read-only.
void	clear() Clear all key/value mappings.
protected void	configureSynchronization(boolean fReload) Set up the listeners that keep the ContinuousQueryCache up-to-date.
protected Filter	createTransformerFilter(MapEventFilter filterAdd) Wrap specified MapEventFilter with a MapEventTransformerFilter that will either transform cache value using transformer defined for this ContinuousQueryCache, or remove the old value from the event using SemiLiteEventTransformer, if no transformer is defined for this ContinuousQueryCache.
protected RuntimeException	createUnexpectedStateException(int nExpectedState, int nActualState) Simple helper to create an exception for communicating invalid state transitions.
void	destroy() Release and destroy this instance of NamedCache.
protected InvocableMap.EntryProcessor	ensureConverted(InvocableMap.EntryProcessor processor) Wrap any AsynchronousProcessor instances with a custom wrapper to perform conversion of result returned by the processor.
protected NamedCache	ensureConverters(NamedCache cache) Instantiate the converters necessary to support the processing mode that this ContinuousQueryCache will be operating under.
protected TaskDaemon	ensureEventQueue() Obtain the existing event queue or create one if none exists.
protected Map	ensureIndexMap() Ensure that the map of indexes maintained by this cache exists.
protected V_FRONT	ensureInflated(Object oKey, Object oValue) If the internal cache value associated with the provided key is Binary, deserialize the value and store it back to the internal cache in its deserialized form.
protected ObservableMap<K,V_FRONT>	ensureInternalCache() Create and initialize this ContinuousQueryCache's (if not already present) internal cache.
protected MapListenerSupport	ensureListenerSupport() Configure the local MapListenerSupport and register the intercepting MapListener with the internal ObservableMap.
protected void	ensureSynchronized(boolean fReload) Ensure that the ContinuousQueryCache listeners have been registered and its content synchronized with the underlying NamedCache.
Set<Map.Entry<K,V_FRONT>>	entrySet(Filter filter) Return a set view of the entries contained in this map that satisfy the criteria expressed by the filter.
Set<Map.Entry<K,V_FRONT>>	entrySet(Filter filter, Comparator comparator) Return a set view of the entries contained in this map that satisfy the criteria expressed by the filter.
protected Set<Map.Entry<K,V_FRONT>>	entrySetInternal(Filter filter) Return multiple values from the back cache based on a filter, transforming them in the process if necessary.
protected Set<Map.Entry<K,V_FRONT>>	entrySetInternal(Filter filter, Comparator comparator) Return multiple values from the back cache based on a filter, transforming them in the process if necessary.
protected <T> T	fromInternal(Object binValue) Deserialize the provided Binary value.
V_FRONT	get(Object oKey) Returns the value to which this map maps the specified key.
Map<K,V_FRONT>	getAll(Collection<? extends K> colKeys) Get all the specified keys, if they are in the Map.
protected Map<K,V_FRONT>	getAllInternal(Collection<? extends K> colKeys) Return multiple values from the back cache, transforming them in the process if necessary.
NamedCache<K,V_BACK>	getCache() Obtain the NamedCache that this ContinuousQueryCache is based on.
String	getCacheName() Return the cache name.
CacheService	getCacheService() Return the CacheService that this NamedCache is a part of.
protected static String	getDefaultName(String sCacheName, Filter filter, ValueExtractor transformer) Return the default name used by the CQC.
protected TaskDaemon	getEventQueue() Obtain this ContinuousQueryCache's event queue.
Filter	getFilter() Obtain the Filter that this ContinuousQueryCache is using to query the underlying NamedCache.
protected Map	getIndexMap() Get the map of indexes maintained by this cache.
protected V_FRONT	getInternal(Object oKey) Return the value from the back cache, transforming it in the process if necessary.
protected ObservableMap<K,V_FRONT>	getInternalCache() Obtain a reference to the internal cache.
protected Set<K>	getInternalKeySet() Obtain a set of keys that are represented by this Map.
MapListener<? super K,? super V_FRONT>	getMapListener() Obtain the configured MapListener for this ContinuousQueryCache.
long	getReconnectInterval() Return the reconnection interval (in milliseconds).
int	getState() Obtain the state of the ContinuousQueryCache.
protected String	getStateString(int nState) Return a String description of the provided STATE_* variables.
ValueExtractor<? super V_BACK,? extends V_FRONT>	getTransformer() Obtain the transformer that this ContinuousQueryCache is using to transform the results from the underlying cache prior to storing them locally.
protected MapListener<K,V_FRONT>	instantiateAddListener() Factory Method: Instantiate a MapListener for adding items to the ContinuousQueryCache, and (if there are listeners on the ContinuousQueryCache) for dispatching inserts and updates.
protected Map<K,V_FRONT>	instantiateConverterMap(Map<K,V_FRONT> map) Provides out-bound conversion (i.e. conversion to values clients expect) of internal values.
protected TaskDaemon	instantiateEventQueue() Create a self-processing event queue.
protected ContinuousQueryCache.EventRouter<K,V_FRONT>	instantiateEventRouter(MapListener<? super K,? super V_FRONT> listener, boolean fLite) Factory Method: Instantiate a listener on the internal map that will direct events to the passed listener, either synchronously or asynchronously as appropriate.
protected ObservableMap<K,V_FRONT>	instantiateInternalCache() Create the internal cache used by the ContinuousQueryCache.
protected MapListener<K,V_FRONT>	instantiateRemoveListener() Factory Method: Instantiate a MapListener for evicting items from the ContinuousQueryCache.
protected Serializer	instantiateSerializer() Create a Serializer appropriate for the mode this cache is operating under (i.e., binary vs non-binary).
<R> R	invoke(K key, InvocableMap.EntryProcessor<K,V_FRONT,R> processor) Invoke the passed EntryProcessor against the Entry specified by the passed key, returning the result of the invocation.
<R> Map<K,R>	invokeAll(Collection<? extends K> collKeys, InvocableMap.EntryProcessor<K,V_FRONT,R> processor) Invoke the passed EntryProcessor against the entries specified by the passed keys, returning the result of the invocation for each.
<R> Map<K,R>	invokeAll(Filter filter, InvocableMap.EntryProcessor<K,V_FRONT,R> processor) Invoke the passed EntryProcessor against the set of entries that are selected by the given Filter, returning the result of the invocation for each.
boolean	isActive() Specifies whether or not the NamedCache is active.
protected boolean	isBinaryNamedCache() Return true if the current back cache is configured to use Binary values.
protected boolean	isBinaryNamedCache(NamedCache cache) Returns true if provided cache is configured to use the NullImplementation classloader which means the values to/from from the cache will be Binary.
boolean	isCacheValues() Determine if this ContinuousQueryCache caches values locally.
boolean	isDestroyed() Specifies whether or not the NamedCache has been destroyed.
protected boolean	isEventDeferred(Object oKey) Called when an event has occurred.
protected boolean	isObserved() Determine if the ContinuousQueryCache has any listeners that cannot be served by this Map listening to lite events.
boolean	isReadOnly() Determine if this ContinuousQueryCache disallows data modification operations.
boolean	isReleased() Specifies whether or not the NamedCache has been released.
boolean	isTransformed() Determine if this ContinuousQueryCache transforms values.
Set<K>	keySet(Filter filter) Return a set view of the keys contained in this map for entries that satisfy the criteria expressed by the filter.
boolean	lock(Object oKey) Attempt to lock the specified item and return immediately.
boolean	lock(Object oKey, long cWait) Attempt to lock the specified item within the specified period of time.
protected Filter	mergeFilter(Filter filter) Return a filter which merges the ContinuousQueueCache's filter with the supplied filter.
V_FRONT	put(K oKey, V_FRONT oValue) Associates the specified value with the specified key in this map.
V_FRONT	put(K oKey, V_FRONT oValue, long cMillis) Associates the specified value with the specified key in this cache and allows to specify an expiry for the cache entry.
void	putAll(Map<? extends K,? extends V_FRONT> map) Copies all of the mappings from the specified map to this map.
protected void	registerDeactivationListener() Instantiate and register a NamedCacheDeactivationListener with the underlying cache service.
protected void	registerServiceListener() Instantiate and register a MemberListener with the underlying cache service.
void	release() Release local resources associated with this instance of NamedCache.
protected void	releaseIndexMap() Release the the entire index map.
protected void	releaseListeners() Release the listeners.
V_FRONT	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.
<T,E> void	removeIndex(ValueExtractor<? super T,? extends E> extractor) If isCacheValues() is true, the index will be removed locally, however, this call will not cause the index on the NamedCache this ContinuousQueryCache wraps.
void	removeMapListener(MapListener<? super K,? super V_FRONT> listener) Remove a standard map listener that previously signed up for all events.
void	removeMapListener(MapListener<? super K,? super V_FRONT> listener, Filter filter) Remove a map listener that previously signed up for events based on a filter evaluation.
void	removeMapListener(MapListener<? super K,? super V_FRONT> listener, K oKey) Remove a map listener that previously signed up for events about a specific key.
protected void	resetCacheRefs() Reset cache references to null.
void	setCacheName(String sCacheName) Set the cache name for this ContinuousQueryCache as returned by getCacheName().
void	setCacheValues(boolean fCacheValues) Modify the local-caching option for the ContinuousQueryCache.
protected void	setObserved(boolean fObserved) Specify whether the ContinuousQueryCache has any listeners that cannot be served by this Map listening to lite events.
void	setReadOnly(boolean fReadOnly) Modify the read-only option for the ContinuousQueryCache.
void	setReconnectInterval(long cReconnectMillis) Specify the reconnection interval (in milliseconds).
protected void	shutdownEventQueue() Shut down running event queue.
protected Binary	toInternal(Object oValue) Serialize the provided value into a Binary.
protected Map<K,V_FRONT>	transform(Set<Map.Entry<K,V_BACK>> setIn, ValueExtractor<? super V_BACK,? extends V_FRONT> transformer) Transform a set of entries.
void	truncate() Removes all mappings from this map.
boolean	unlock(Object oKey) Unlock the specified item.
protected void	unregisterDeactivationListener() Unregister underlying cache service member listener.
protected void	unregisterServiceListener() Unregister underlying cache service member listener.

Methods inherited from class com.tangosol.util.AbstractKeySetBasedMap

containsKey, instantiateEntrySet, instantiateKeyIterator, instantiateKeySet, instantiateValues, isEmpty, isInternalKeySetIteratorMutable, iterateKeys, size

Methods inherited from class com.tangosol.util.AbstractKeyBasedMap

clone, containsValue, entrySet, equals, hashCode, keySet, toString, 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, getStackTrace, getThreadFactory, getTimeZone, getUpTimeMillis, hashCode, hexValue, indentString, indentString, isDecimal, isHex, isLogEcho, isOctal, log, log, log, log, log, makeInteger, makeLong, makeThread, mergeArray, mergeBooleanArray, mergeByteArray, mergeCharArray, mergeDoubleArray, mergeFloatArray, mergeIntArray, mergeLongArray, 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, 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.NamedCache

as, async, async, view

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

forEach

Methods inherited from interface java.util.Map

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

Methods inherited from interface com.tangosol.util.ConcurrentMap

containsKey, containsValue, isEmpty, size

Methods inherited from interface com.tangosol.util.QueryMap

forEach, forEach, values, values

Methods inherited from interface com.tangosol.util.InvocableMap

aggregate, compute, compute, computeIfAbsent, computeIfAbsent, computeIfPresent, computeIfPresent, getOrDefault, invokeAll, merge, merge, putIfAbsent, remove, replace, replace, replaceAll, replaceAll, replaceAll, replaceAll, stream, stream, stream, stream, stream, stream

Field Detail

STATE_DISCONNECTED

public static final int STATE_DISCONNECTED

State: Disconnected state. The content of the ContinuousQueryCache is not fully synchronized with the underlying [clustered] cache. If the value of the ReconnectInterval property is zero, it must be configured (synchronized) before it can be used.

Since:

Coherence 3.4

See Also:

Constant Field Values

STATE_CONFIGURING

public static final int STATE_CONFIGURING

State: The ContinuousQueryCache is configuring or re-configuring its listeners and content.

See Also:

Constant Field Values

STATE_CONFIGURED

public static final int STATE_CONFIGURED

State: The ContinuousQueryCache has been configured.

See Also:

Constant Field Values

STATE_SYNCHRONIZED

public static final int STATE_SYNCHRONIZED

State: The ContinuousQueryCache has been configured and fully synchronized.

See Also:

Constant Field Values

m_sName

protected String m_sName

The name of the underlying NamedCache. A copy is kept here because the reference to the underlying NamedCache is discarded when this cache is released.

m_filter

protected Filter m_filter

The filter that represents the subset of information from the underlying NamedCache that this ContinuousQueryCache represents.

m_fCacheValues

protected boolean m_fCacheValues

The option of whether or not to locally cache values.

m_transformer

protected ValueExtractor<? super V_BACK,? extends V_FRONT> m_transformer

The transformer that should be used to convert values from the underlying cache.

m_fReadOnly

protected boolean m_fReadOnly

The option to disallow modifications through this ContinuousQueryCache interface.

m_cReconnectMillis

protected long m_cReconnectMillis

The interval (in milliseconds) that indicates how often the ContinuousQueryCache should attempt to synchronize its content with the underlying cache in case the connection is severed.

m_ldtConnectionTimestamp

protected volatile long m_ldtConnectionTimestamp

The timestamp when the synchronization was last attempted.

m_mapLocal

protected ObservableMap<K,V_FRONT> m_mapLocal

The keys that are in this ContinuousQueryCache, and (if m_fCacheValues is true) the corresponding values as well.

m_nState

protected volatile int m_nState

State of the ContinuousQueryCache. One of the STATE_* enums.

m_mapSyncReq

protected volatile Map m_mapSyncReq

While the ContinuousQueryCache is configuring or re-configuring its listeners and content, any events that are received must be logged to ensure that the corresponding content is in sync.

m_eventQueue

protected volatile TaskDaemon m_eventQueue

The event queue for this ContinuousQueryCache.

m_fListeners

protected boolean m_fListeners

Keeps track of whether the ContinuousQueryCache has listeners that require this cache to cache values.

m_filterAdd

protected MapEventFilter m_filterAdd

The MapEventFilter that uses the ContinuousQueryCache's filter to select events that would add elements to this cache's contents.

m_filterRemove

protected MapEventFilter m_filterRemove

The MapEventFilter that uses the ContinuousQueryCache's filter to select events that would remove elements from this cache's contents.

m_listenerAdd

protected MapListener<K,V_FRONT> m_listenerAdd

The listener that gets information about what should be in this cache.

m_listenerRemove

protected MapListener<K,V_FRONT> m_listenerRemove

The listener that gets information about what should be thrown out of this cache.

m_listenerService

protected MemberListener m_listenerService

The cache service MemberListener for the underlying NamedCache.

m_mapIndex

protected Map m_mapIndex

The map of indexes maintained by this cache. The keys of the Map are ValueExtractor objects, and for each key, the corresponding value stored in the Map is a MapIndex object.

m_listenerDeactivation

protected com.tangosol.internal.net.NamedCacheDeactivationListener m_listenerDeactivation

The NamedCacheDeactivationListener.

Since:

12.2.1.4

m_mapListener

protected MapListener<? super K,? super V_FRONT> m_mapListener

The optional MapListener that may be provided during ContinuousQueryCache construction.

Since:

12.2.1.4

m_converterFromBinary

protected Converter m_converterFromBinary

Converter that will be used to convert values from binary.

Since:

12.2.1.4

m_converterToBinary

protected Converter m_converterToBinary

Converter that will be used to convert values to binary.

Since:

12.2.1.4

m_loader

protected ClassLoader m_loader

The ClassLoader to use when de-serializing/serializing keys and values.

Since:

12.2.1.4

m_listenerSupport

protected MapListenerSupport m_listenerSupport

Local listener support to allow the ContinuousQueryCache to intercept all events dispatched by the internal ObservableMap.

Since:

12.2.1.4

Constructor Detail

ContinuousQueryCache

public ContinuousQueryCache(NamedCache<K,V_BACK> cache)

Create a locally materialized view of a NamedCache using a Filter. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API.

This constructor will result in a ContinuousQueryCache that caches both its keys and values locally.

Parameters:

cache - the NamedCache with which the view will be created

Since:

12.2.1.4

ContinuousQueryCache

public ContinuousQueryCache(Supplier<NamedCache<K,V_BACK>> supplierCache)

Create a locally materialized view of a NamedCache using a Filter. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API.

This constructor will result in a ContinuousQueryCache that caches both its keys and values locally.

Parameters:

supplierCache - a Supplier that returns a NamedCache with which the ContinuousQueryCache will be created The Supplier must return a new instance each time Supplier.get() is called

Since:

12.2.1.4

ContinuousQueryCache

public ContinuousQueryCache(NamedCache<K,V_BACK> cache,
                            Filter filter)

Create a locally materialized view of a NamedCache using a Filter. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API.

This constructor will result in a ContinuousQueryCache that caches both its keys and values locally.

Parameters:

cache - the NamedCache to create a view of

filter - the filter that defines the view

ContinuousQueryCache

public ContinuousQueryCache(Supplier<NamedCache<K,V_BACK>> supplierCache,
                            Filter filter)

Create a locally materialized view of a NamedCache using a Filter. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API.

This constructor will result in a ContinuousQueryCache that caches both its keys and values locally.

Parameters:

supplierCache - a Supplier that returns a NamedCache with which the ContinuousQueryCache will be created The Supplier must return a new instance each time Supplier.get() is called

filter - the Filter that defines the view

Since:

12.2.1.4

ContinuousQueryCache

public ContinuousQueryCache(NamedCache<K,V_BACK> cache,
                            Filter filter,
                            ValueExtractor<? super V_BACK,? extends V_FRONT> transformer)

Create a locally materialized view of a NamedCache using a Filter and a transformer. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API.

This constructor will result in a read-only ContinuousQueryCache that caches both its keys and transformed values locally.

Parameters:

cache - the NamedCache to create a view of

filter - the Filter that defines the view

transformer - the ValueExtractor that should be used to transform values retrieved from the underlying NamedCache before storing them locally

ContinuousQueryCache

public ContinuousQueryCache(NamedCache<K,V_BACK> cache,
                            Filter filter,
                            boolean fCacheValues)

Create a materialized view of a NamedCache using a Filter. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API.

Parameters:

cache - the NamedCache to create a view of

filter - the Filter that defines the view

fCacheValues - pass true to cache both the keys and values of the materialized view locally, or false to only cache the keys

ContinuousQueryCache

public ContinuousQueryCache(NamedCache<K,V_BACK> cache,
                            Filter filter,
                            MapListener<? super K,? super V_FRONT> listener)

Create a materialized view of a NamedCache using a Filter. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API. This constructor allows a client to receive all events, including those that result from the initial population of the ContinuousQueryCache. In other words, all contents of the ContinuousQueryCache will be delivered to the listener as a sequence of events, including those items that already exist in the underlying (unfiltered) cache.

Parameters:

cache - the NamedCache to create a view of

filter - the Filter that defines the view

listener - a MapListener that will receive all the events from the ContinuousQueryCache, including those corresponding to its initial population

ContinuousQueryCache

public ContinuousQueryCache(NamedCache<K,V_BACK> cache,
                            Filter filter,
                            MapListener<? super K,? super V_FRONT> listener,
                            ValueExtractor<? super V_BACK,? extends V_FRONT> transformer)

Create a materialized view of a NamedCache using a Filter. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API.

This constructor will result in a read-only ContinuousQueryCache that caches both its keys and transformed values locally. It will also allow a client to receive all events, including those that result from the initial population of the ContinuousQueryCache. In other words, all contents of the ContinuousQueryCache will be delivered to the listener as a sequence of events, including those items that already exist in the underlying (unfiltered) cache.

Parameters:

cache - the NamedCache to create a view of

filter - the Filter that defines the view

listener - a MapListener that will receive all the events from the ContinuousQueryCache, including those corresponding to its initial population

transformer - the ValueExtractor that should be used to transform values retrieved from the underlying NamedCache before storing them locally

ContinuousQueryCache

public ContinuousQueryCache(NamedCache<K,V_BACK> cache,
                            Filter filter,
                            boolean fCacheValues,
                            MapListener<? super K,? super V_FRONT> listener,
                            ValueExtractor<? super V_BACK,? extends V_FRONT> transformer)

Construct the ContinuousQueryCache.

Parameters:

cache - the NamedCache to create a view of

filter - the Filter that defines the view

fCacheValues - pass true to cache both the keys and values of the materialized view locally, or false to only cache the keys

listener - an optional MapListener that will receive all events starting from the initialization of the ContinuousQueryCache

transformer - an optional ValueExtractor that would be used to transform values retrieved from the underlying cache before storing them locally; if specified, this ContinuousQueryCache will become "read-only"

ContinuousQueryCache

public ContinuousQueryCache(Supplier<NamedCache<K,V_BACK>> supplierCache,
                            Filter filter,
                            boolean fCacheValues,
                            MapListener<? super K,? super V_FRONT> listener,
                            ValueExtractor<? super V_BACK,? extends V_FRONT> transformer,
                            ClassLoader loader)

Create a materialized view of a NamedCache using a Filter. A materialized view is an implementation of Continuous Query exposed through the standard NamedCache API.

This constructor will result in a read-only ContinuousQueryCache that caches both its keys and transformed values locally. It will also allow a client to receive all events, including those that result from the initial population of the ContinuousQueryCache. In other words, all contents of the ContinuousQueryCache will be delivered to the listener as a sequence of events, including those items that already exist in the underlying (unfiltered) cache.

Parameters:

supplierCache - a Supplier that returns a NamedCache with which the ContinuousQueryCache will be created. The Supplier must return a new instance each time Supplier.get() is called

filter - the Filter that defines the view

fCacheValues - pass true to cache both the keys and values of the materialized view locally, or false to only cache the keys

listener - an optional MapListener that will receive all events starting from the initialization of the ContinuousQueryCache

transformer - an optional ValueExtractor that would be used to transform values retrieved from the underlying cache before storing them locally; if specified, this ContinuousQueryCache will become read-only

loader - an optional ClassLoader

Since:

12.2.1.4

Method Detail

getCache

public NamedCache<K,V_BACK> getCache()

Obtain the NamedCache that this ContinuousQueryCache is based on.

Returns:

the underlying NamedCache

getFilter

public Filter getFilter()

Obtain the Filter that this ContinuousQueryCache is using to query the underlying NamedCache.

Returns:

the Filter that this cache uses to select its contents from the underlying NamedCache

getTransformer

public ValueExtractor<? super V_BACK,? extends V_FRONT> getTransformer()

Obtain the transformer that this ContinuousQueryCache is using to transform the results from the underlying cache prior to storing them locally.

Returns:

the ValueExtractor that this cache uses to transform entries from the underlying cache

Since:

12.2.1.4

getMapListener

public MapListener<? super K,? super V_FRONT> getMapListener()

Obtain the configured MapListener for this ContinuousQueryCache.

Returns:

the MapListener for this ContinuousQueryCache

Since:

12.2.1.4

isCacheValues

public boolean isCacheValues()

Determine if this ContinuousQueryCache caches values locally.

Returns:

true if this object caches values locally, and false if it relies on the underlying NamedCache

setCacheValues

public void setCacheValues(boolean fCacheValues)

Modify the local-caching option for the ContinuousQueryCache. By changing this value from false to true, the ContinuousQueryCache will fully realize its contents locally and maintain them coherently in a manner analogous to the Coherence Near Cache. By changing this value from true to false, the ContinuousQueryCache will discard its locally cached data and rely on the underlying NamedCache.

Parameters:

fCacheValues - pass true to enable local caching, or false to disable it

isTransformed

public boolean isTransformed()

Determine if this ContinuousQueryCache transforms values.

Returns:

true if this ContinuousQueryCache has been configured to transform values

isReadOnly

public boolean isReadOnly()

Determine if this ContinuousQueryCache disallows data modification operations.

Returns:

true if this ContinuousQueryCache has been configured as read-only

setReadOnly

public void setReadOnly(boolean fReadOnly)

Modify the read-only option for the ContinuousQueryCache. Note that the cache can be made read-only, but the opposite (making it mutable) is explicitly disallowed.

Parameters:

fReadOnly - pass true to prohibit clients from making modifications to this cache

instantiateInternalCache

protected ObservableMap<K,V_FRONT> instantiateInternalCache()

Create the internal cache used by the ContinuousQueryCache.

Returns:

a new ObservableMap that will represent the materialized view of the ContinuousQueryCache

ensureInternalCache

protected ObservableMap<K,V_FRONT> ensureInternalCache()

Create and initialize this ContinuousQueryCache's (if not already present) internal cache. This method is called by configureSynchronization(boolean), as such, it shouldn't be called directly. Use getInternalCache().

Returns:

the ObservableMap functioning as this ContinuousQueryCache's internal cache

Since:

12.2.1.4

getInternalCache

protected ObservableMap<K,V_FRONT> getInternalCache()

Obtain a reference to the internal cache. The internal cache maintains all of the keys in the ContinuousQueryCache, and if isCacheValues() is true, it also maintains the up-to-date values corresponding to those keys.

Returns:

the internal cache that represents the materialized view of the ContinuousQueryCache

isObserved

protected boolean isObserved()

Determine if the ContinuousQueryCache has any listeners that cannot be served by this Map listening to lite events.

Returns:

true iff there is at least one listener

setObserved

protected void setObserved(boolean fObserved)

Specify whether the ContinuousQueryCache has any listeners that cannot be served by this Map listening to lite events.

Parameters:

fObserved - true iff there is at least one listener

getState

public int getState()

Obtain the state of the ContinuousQueryCache.

Returns:

one of the STATE_ enums

changeState

protected void changeState(int nState)

Change the state of the ContinuousQueryCache.

Parameters:

nState - one of the STATE_ enums

resetCacheRefs

protected void resetCacheRefs()

Reset cache references to null.

getReconnectInterval

public long getReconnectInterval()

Return the reconnection interval (in milliseconds). This value indicates the period in which re-synchronization with the underlying cache will be delayed in the case the connection is severed. During this time period, local content can be accessed without triggering re-synchronization of the local content.

Returns:

a reconnection interval (in milliseconds)

Since:

Coherence 3.4

See Also:

setReconnectInterval(long)

setReconnectInterval

public void setReconnectInterval(long cReconnectMillis)

Specify the reconnection interval (in milliseconds). This value indicates the period in which re-synchronization with the underlying cache will be delayed in the case the connection is severed. During this time period, local content can be accessed without triggering re-synchronization of the local content.

Parameters:

cReconnectMillis - reconnection interval (in milliseconds). A value of zero or less means that the ContinuousQueryCache cannot be used when not connected.

Since:

Coherence 3.4

setCacheName

public void setCacheName(String sCacheName)

Set the cache name for this ContinuousQueryCache as returned by getCacheName().

Note: setting the cache name to be consistent with the cache name of the NamedCache this CQC is backed by will ensure data structures that cache NamedCache instances based upon the reported cache name would result in an appropriate cache hit.

Parameters:

sCacheName - the name this CQC should report as its cache name

Since:

12.2.1.4

clear

public void clear()

Description copied from class: AbstractKeyBasedMap

Clear all key/value mappings.

Specified by:

clear in interface NamedCache<K,V_FRONT>

Specified by:

clear in interface ConcurrentMap<K,V_FRONT>

Specified by:

clear in interface Map<K,V_FRONT>

Overrides:

clear in class AbstractKeyBasedMap<K,V_FRONT>

get

public V_FRONT get(Object oKey)

Description copied from class: AbstractKeyBasedMap

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

Specified by:

get in interface ConcurrentMap<K,V_FRONT>

Specified by:

get in interface Map<K,V_FRONT>

Specified by:

get in class AbstractKeyBasedMap<K,V_FRONT>

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

See Also:

ConcurrentMap.containsKey(Object)

put

public V_FRONT put(K oKey,
                   V_FRONT oValue)

Description copied from class: AbstractKeyBasedMap

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

Specified by:

put in interface CacheMap<K,V_FRONT>

Specified by:

put in interface ConcurrentMap<K,V_FRONT>

Specified by:

put in interface Map<K,V_FRONT>

Overrides:

put in class AbstractKeyBasedMap<K,V_FRONT>

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<? extends K,? extends V_FRONT> map)

Description copied from class: AbstractKeyBasedMap

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 ConcurrentMap<K,V_FRONT>

Specified by:

putAll in interface Map<K,V_FRONT>

Overrides:

putAll in class AbstractKeyBasedMap<K,V_FRONT>

Parameters:

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

remove

public V_FRONT remove(Object oKey)

Description copied from class: AbstractKeyBasedMap

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 ConcurrentMap<K,V_FRONT>

Specified by:

remove in interface Map<K,V_FRONT>

Overrides:

remove in class AbstractKeyBasedMap<K,V_FRONT>

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.

getAll

public Map<K,V_FRONT> getAll(Collection<? extends K> colKeys)

Description copied from class: AbstractKeyBasedMap

Get all the specified keys, if they are in the Map. For each key that is in the cache, that key and its corresponding value will be placed in the map that is returned by this method. The absence of a key in the returned map indicates that it was not in the cache, which may imply (for caches that can load behind the scenes) that the requested data could not be loaded.

Specified by:

getAll in interface CacheMap<K,V_FRONT>

Overrides:

getAll in class AbstractKeyBasedMap<K,V_FRONT>

Parameters:

colKeys - a collection of keys that may be in the named cache

Returns:

a Map of keys to values for the specified keys passed in colKeys

put

public V_FRONT put(K oKey,
                   V_FRONT oValue,
                   long cMillis)

Description copied from interface: NamedCache

Associates the specified value with the specified key in this cache and allows to specify an expiry for the cache entry.

Note: Though NamedCache interface extends CacheMap, not all implementations currently support this functionality.

For example, if a cache is configured to be a replicated, optimistic or distributed cache then its backing map must be configured as a local cache. If a cache is configured to be a near cache then the front map must to be configured as a local cache and the back map must support this feature as well, typically by being a distributed cache backed by a local cache (as above.)

Specified by:

put in interface CacheMap<K,V_FRONT>

Specified by:

put in interface NamedCache<K,V_FRONT>

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

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 AbstractKeyBasedMap<K,V_FRONT>

Parameters:

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

Returns:

true iff the Map changed as the result of this operation

getInternalKeySet

protected Set<K> getInternalKeySet()

Description copied from class: AbstractKeySetBasedMap

Obtain a set of keys that are represented by this Map.

The AbstractKeySetBasedMap only utilizes the internal key set as a read-only resource.

Specified by:

getInternalKeySet in class AbstractKeySetBasedMap<K,V_FRONT>

Returns:

an internal Set of keys that are contained by this Map

addMapListener

public void addMapListener(MapListener<? super K,? super V_FRONT> listener)

Description copied from interface: ObservableMap

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. This has the same result as the following call:

   addMapListener(listener, (Filter) null, false);
 

Specified by:

addMapListener in interface ObservableMap<K,V_FRONT>

Parameters:

listener - the MapEvent listener to add

removeMapListener

public void removeMapListener(MapListener<? super K,? super V_FRONT> listener)

Description copied from interface: ObservableMap

Remove a standard map listener that previously signed up for all events. This has the same result as the following call:

   removeMapListener(listener, (Filter) null);
 

Specified by:

removeMapListener in interface ObservableMap<K,V_FRONT>

Parameters:

listener - the listener to remove

addMapListener

public void addMapListener(MapListener<? super K,? super V_FRONT> listener,
                           K oKey,
                           boolean fLite)

Description copied from interface: ObservableMap

Add a map listener for a specific key.

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.

Specified by:

addMapListener in interface ObservableMap<K,V_FRONT>

Parameters:

listener - the MapEvent listener to add

oKey - the key that identifies the entry for which to raise events

fLite - true to indicate that the MapEvent objects do not have to include the OldValue and NewValue property values in order to allow optimizations

removeMapListener

public void removeMapListener(MapListener<? super K,? super V_FRONT> listener,
                              K oKey)

Description copied from interface: ObservableMap

Remove a map listener that previously signed up for events about a specific key.

Specified by:

removeMapListener in interface ObservableMap<K,V_FRONT>

Parameters:

listener - the listener to remove

oKey - the key that identifies the entry for which to raise events

addMapListener

public void addMapListener(MapListener<? super K,? super V_FRONT> listener,
                           Filter filter,
                           boolean fLite)

Description copied from interface: ObservableMap

Add a map listener that receives events based on a filter evaluation.

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.

Specified by:

addMapListener in interface ObservableMap<K,V_FRONT>

Parameters:

listener - the MapEvent listener to add

filter - 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 true

fLite - true to indicate that the MapEvent objects do not have to include the OldValue and NewValue property values in order to allow optimizations

removeMapListener

public void removeMapListener(MapListener<? super K,? super V_FRONT> listener,
                              Filter filter)

Description copied from interface: ObservableMap

Remove a map listener that previously signed up for events based on a filter evaluation.

Specified by:

removeMapListener in interface ObservableMap<K,V_FRONT>

Parameters:

listener - the listener to remove

filter - the filter that was passed into the corresponding addMapListener() call

keySet

public Set<K> keySet(Filter filter)

Description copied from interface: QueryMap

Return a set view of the keys contained in this map for entries that satisfy the criteria expressed by the filter.

Unlike the Map.keySet() method, the set returned by this method may not be backed by the map, so changes to the set may not reflected in the map, and vice-versa.

Note: When using the Coherence Enterprise Edition or Grid Edition, the Partitioned Cache implements the QueryMap interface using the Parallel Query feature. When using Coherence Standard Edition, the Parallel Query feature is not available, resulting in lower performance for most queries, and particularly when querying large data sets.

Specified by:

keySet in interface QueryMap<K,V_FRONT>

Parameters:

filter - the Filter object representing the criteria that the entries of this map should satisfy

Returns:

a set of keys for entries that satisfy the specified criteria

entrySet

public Set<Map.Entry<K,V_FRONT>> entrySet(Filter filter)

Description copied from interface: QueryMap

Return a set view of the entries contained in this map that satisfy the criteria expressed by the filter. Each element in the returned set is a Map.Entry.

Unlike the Map.entrySet() method, the set returned by this method may not be backed by the map, so changes to the set may not be reflected in the map, and vice-versa.

Note: When using the Coherence Enterprise Edition or Grid Edition, the Partitioned Cache implements the QueryMap interface using the Parallel Query feature. When using Coherence Standard Edition, the Parallel Query feature is not available, resulting in lower performance for most queries, and particularly when querying large data sets.

Specified by:

entrySet in interface QueryMap<K,V_FRONT>

Parameters:

filter - the Filter object representing the criteria that the entries of this map should satisfy

Returns:

a set of entries that satisfy the specified criteria

entrySet

public Set<Map.Entry<K,V_FRONT>> entrySet(Filter filter,
                                          Comparator comparator)

Description copied from interface: QueryMap

Return a set view of the entries contained in this map that satisfy the criteria expressed by the filter. Each element in the returned set is a Map.Entry. It is further guaranteed that its iterator will traverse the set in such a way that the entry values come up in ascending order, sorted by the specified Comparator or according to the natural ordering (see Comparable).

Unlike the Map.entrySet() method, the set returned by this method may not be backed by the map, so changes to the set may not be reflected in the map, and vice-versa.

Note: When using the Coherence Enterprise Edition or Grid Edition, the Partitioned Cache implements the QueryMap interface using the Parallel Query feature. When using Coherence Standard Edition, the Parallel Query feature is not available, resulting in lower performance for most queries, and particularly when querying large data sets.

Specified by:

entrySet in interface QueryMap<K,V_FRONT>

Parameters:

filter - the Filter object representing the criteria that the entries of this map should satisfy

comparator - the Comparator object which imposes an ordering on entries in the resulting set; or null if the entries' values natural ordering should be used

Returns:

a set of entries that satisfy the specified criteria

See Also:

ChainedComparator

addIndex

public <T,E> void addIndex(ValueExtractor<? super T,? extends E> extractor,
                           boolean fOrdered,
                           Comparator<? super E> comparator)

If isCacheValues() is true, the index will be created locally as well as on the NamedCache this ContinuousQueryCache wraps, otherwise, the index will be created on the wrapped NamedCache only.

Specified by:

addIndex in interface QueryMap<K,V_FRONT>

Type Parameters:

T - the type of the value to extract from

E - the type of value that will be extracted

Parameters:

extractor - the ValueExtractor object that is used to extract an indexable Object from a value stored in the indexed Map. Must not be null.

fOrdered - true iff the contents of the indexed information should be ordered; false otherwise

comparator - the Comparator object which imposes an ordering on entries in the indexed map; or null if the entries' values natural ordering should be used

Throws:

IllegalArgumentException - if extractor is an instance of MapTriggerListener

See Also:

QueryMap.addIndex(ValueExtractor, boolean, Comparator)

removeIndex

public <T,E> void removeIndex(ValueExtractor<? super T,? extends E> extractor)

If isCacheValues() is true, the index will be removed locally, however, this call will not cause the index on the NamedCache this ContinuousQueryCache wraps. Developers must remove the index on the wrapped cache manually.

Specified by:

removeIndex in interface QueryMap<K,V_FRONT>

Type Parameters:

T - the type of the value to extract from

E - the type of value that will be extracted

Parameters:

extractor - the ValueExtractor object that is used to extract an indexable Object from a value stored in the Map.

See Also:

QueryMap.removeIndex(ValueExtractor), getCache()

truncate

public void truncate()

Description copied from interface: NamedCache

Removes all mappings from this map.

Note: the removal of entries caused by this truncate operation will not be observable. This includes any registered listeners, triggers, or interceptors. However, a CacheLifecycleEvent is raised to notify subscribers of the execution of this operation.

Specified by:

truncate in interface NamedCache<K,V_FRONT>

invoke

public <R> R invoke(K key,
                    InvocableMap.EntryProcessor<K,V_FRONT,R> processor)

Invoke the passed EntryProcessor against the Entry specified by the passed key, returning the result of the invocation.

In order to invoke an entry processor on a back cache in a type-safe manner you must use getCache().invoke() instead.

Specified by:

invoke in interface InvocableMap<K,V_FRONT>

Type Parameters:

R - the type of value returned by the EntryProcessor

Parameters:

key - the key to process; it is not required to exist within the Map

processor - the EntryProcessor to use to process the specified key

Returns:

the result of the invocation as returned from the EntryProcessor

invokeAll

public <R> Map<K,R> invokeAll(Collection<? extends K> collKeys,
                              InvocableMap.EntryProcessor<K,V_FRONT,R> processor)

Invoke the passed EntryProcessor against the entries specified by the passed keys, returning the result of the invocation for each.

In order to invoke an entry processor on a back cache in a type-safe manner you must use getCache().invokeAll() instead.

Specified by:

invokeAll in interface InvocableMap<K,V_FRONT>

Type Parameters:

R - the type of value returned by the EntryProcessor

Parameters:

collKeys - the keys to process; these keys are not required to exist within the Map

processor - the EntryProcessor to use to process the specified keys

Returns:

a Map containing the results of invoking the EntryProcessor against each of the specified keys

invokeAll

public <R> Map<K,R> invokeAll(Filter filter,
                              InvocableMap.EntryProcessor<K,V_FRONT,R> processor)

Invoke the passed EntryProcessor against the set of entries that are selected by the given Filter, returning the result of the invocation for each.

Unless specified otherwise, InvocableMap implementations will perform this operation in two steps: (1) use the filter to retrieve a matching entry set; (2) apply the agent to every filtered entry. This algorithm assumes that the agent's processing does not affect the result of the specified filter evaluation, since the filtering and processing could be performed in parallel on different threads. If this assumption does not hold, the processor logic has to be idempotent, or at least re-evaluate the filter. This could be easily accomplished by wrapping the processor with the ConditionalProcessor.

In order to invoke an entry processor on a back cache in a type-safe manner you must use getCache().invokeAll() instead.

Specified by:

invokeAll in interface InvocableMap<K,V_FRONT>

Type Parameters:

R - the type of value returned by the EntryProcessor

Parameters:

filter - a Filter that results in the set of keys to be processed

processor - the EntryProcessor to use to process the specified keys

Returns:

a Map containing the results of invoking the EntryProcessor against the keys that are selected by the given Filter

aggregate

public <R> R aggregate(Collection<? extends K> collKeys,
                       InvocableMap.EntryAggregator<? super K,? super V_FRONT,R> aggregator)

Description copied from interface: InvocableMap

Perform an aggregating operation against the entries specified by the passed keys.

Specified by:

aggregate in interface InvocableMap<K,V_FRONT>

Type Parameters:

R - the type of value returned by the EntryAggregator

Parameters:

collKeys - the Collection of keys that specify the entries within this Map to aggregate across

aggregator - the EntryAggregator that is used to aggregate across the specified entries of this Map

Returns:

the result of the aggregation

aggregate

public <R> R aggregate(Filter filter,
                       InvocableMap.EntryAggregator<? super K,? super V_FRONT,R> aggregator)

Description copied from interface: InvocableMap

Perform an aggregating operation against the set of entries that are selected by the given Filter.

Specified by:

aggregate in interface InvocableMap<K,V_FRONT>

Type Parameters:

R - the type of value returned by the EntryAggregator

Parameters:

filter - the Filter that is used to select entries within this Map to aggregate across

aggregator - the EntryAggregator that is used to aggregate across the selected entries of this Map

Returns:

the result of the aggregation

lock

public boolean lock(Object oKey,
                    long cWait)

Description copied from interface: ConcurrentMap

Attempt to lock the specified item within the specified period of time.

The item doesn't have to exist to be locked. While the item is locked there is known to be a lock holder which has an exclusive right to modify (calling put and remove methods) that item.

Lock holder is an abstract concept that depends on the ConcurrentMap implementation. For example, holder could be a cluster member or a thread (or both).

Locking strategy may vary for concrete implementations as well. Lock could have an expiration time (this lock is sometimes called a "lease") or be held indefinitely (until the lock holder terminates).

Some implementations may allow the entire map to be locked. If the map is locked in such a way, then only a lock holder is allowed to perform any of the "put" or "remove" operations. Pass the special constant ConcurrentMap.LOCK_ALL as the oKey parameter to indicate the map lock.

Specified by:

lock in interface ConcurrentMap<K,V_FRONT>

Parameters:

oKey - key being locked

cWait - the number of milliseconds to continue trying to obtain a lock; pass zero to return immediately; pass -1 to block the calling thread until the lock could be obtained

Returns:

true if the item was successfully locked within the specified time; false otherwise

lock

public boolean lock(Object oKey)

Description copied from interface: ConcurrentMap

Attempt to lock the specified item and return immediately.

This method behaves exactly as if it simply performs the call lock(oKey, 0).

Specified by:

lock in interface ConcurrentMap<K,V_FRONT>

Parameters:

oKey - key being locked

Returns:

true if the item was successfully locked; false otherwise

unlock

public boolean unlock(Object oKey)

Description copied from interface: ConcurrentMap

Unlock the specified item. The item doesn't have to exist to be unlocked. If the item is currently locked, only the holder of the lock could successfully unlock it.

Specified by:

unlock in interface ConcurrentMap<K,V_FRONT>

Parameters:

oKey - key being unlocked

Returns:

true if the item was successfully unlocked; false otherwise

getCacheName

public String getCacheName()

Description copied from interface: NamedCache

Return the cache name.

Specified by:

getCacheName in interface NamedCache<K,V_FRONT>

Returns:

the cache name

getCacheService

public CacheService getCacheService()

Description copied from interface: NamedCache

Return the CacheService that this NamedCache is a part of.

Specified by:

getCacheService in interface NamedCache<K,V_FRONT>

Returns:

the CacheService

isActive

public boolean isActive()

Description copied from interface: NamedCache

Specifies whether or not the NamedCache is active.

Specified by:

isActive in interface NamedCache<K,V_FRONT>

Returns:

true if the NamedCache is active; false otherwise

release

public void release()

Description copied from interface: NamedCache

Release local resources associated with this instance of NamedCache.

Releasing a cache makes it no longer usable, but does not affect the cache itself. In other words, all other references to the cache will still be valid, and the cache data is not affected by releasing the reference. Any attempt to use this reference afterward will result in an exception.

Caches should be released by the same mechanism in which they were obtained. For example:

• new Cache() - cache.release()
• CacheFactory.getCache() - CacheFactory.releaseCache()
• ConfigurableCacheFactory.ensureCache() - ConfigurableCacheFactory.releaseCache()

Except for the case where the application code explicitly allocated the cache, this method should not be called by application code.

The purpose for releasing a cache is to allow the cache implementation to release the ClassLoader used to deserialize items in the cache. The cache implementation ensures that all references to that ClassLoader are released. This implies that objects in the cache that were loaded by that ClassLoader will be re-serialized to release their hold on that ClassLoader. The result is that the ClassLoader can be garbage-collected by Java in situations where the cache is operating in an application server and applications are dynamically loaded and unloaded.

Specified by:

release in interface NamedCache<K,V_FRONT>

See Also:

CacheFactory.releaseCache(NamedCache), ConfigurableCacheFactory.releaseCache(NamedCache)

destroy

public void destroy()

Description copied from interface: NamedCache

Release and destroy this instance of NamedCache.

Warning: This method is used to completely destroy the specified cache across the cluster. All references in the entire cluster to this cache will be invalidated, the cached data will be cleared, and all internal resources will be released.

Caches should be destroyed by the same mechanism in which they were obtained. For example:

• new Cache() - cache.destroy()
• CacheFactory.getCache() - CacheFactory.destroyCache()
• ConfigurableCacheFactory.ensureCache() - ConfigurableCacheFactory.destroyCache()

Except for the case where the application code explicitly allocated the cache, this method should not be called by application code.

Specified by:

destroy in interface NamedCache<K,V_FRONT>

See Also:

CacheFactory.destroyCache(NamedCache), ConfigurableCacheFactory.destroyCache(NamedCache)

isDestroyed

public boolean isDestroyed()

Description copied from interface: NamedCache

Specifies whether or not the NamedCache has been destroyed. Implementations must override this method to provide the necessary information.

Specified by:

isDestroyed in interface NamedCache<K,V_FRONT>

Returns:

true if the NamedCache has been destroyed; false otherwise

isReleased

public boolean isReleased()

Description copied from interface: NamedCache

Specifies whether or not the NamedCache has been released. Implementations must override this method to provide the necessary information.

Specified by:

isReleased in interface NamedCache<K,V_FRONT>

Returns:

true if the NamedCache has been released; false otherwise

getInternal

protected V_FRONT getInternal(Object oKey)

Return the value from the back cache, transforming it in the process if necessary.

Parameters:

oKey - the key to get the associated value for

Returns:

the value for the given key

getAllInternal

protected Map<K,V_FRONT> getAllInternal(Collection<? extends K> colKeys)

Return multiple values from the back cache, transforming them in the process if necessary.

Parameters:

colKeys - the keys to get the associated values for

Returns:

the value for the given key

entrySetInternal

protected Set<Map.Entry<K,V_FRONT>> entrySetInternal(Filter filter)

Return multiple values from the back cache based on a filter, transforming them in the process if necessary.

Parameters:

filter - the Filter to find the entries for

Returns:

the value for the given key

entrySetInternal

protected Set<Map.Entry<K,V_FRONT>> entrySetInternal(Filter filter,
                                                     Comparator comparator)

Return multiple values from the back cache based on a filter, transforming them in the process if necessary.

Parameters:

filter - the Filter to find the entries for

comparator - the Comparator

Returns:

the value for the given key

transform

protected Map<K,V_FRONT> transform(Set<Map.Entry<K,V_BACK>> setIn,
                                   ValueExtractor<? super V_BACK,? extends V_FRONT> transformer)

Transform a set of entries.

Parameters:

setIn - the set of entries to transform

transformer - the transformer to use

Returns:

a Map containing transformed entries

mergeFilter

protected Filter mergeFilter(Filter filter)

Return a filter which merges the ContinuousQueueCache's filter with the supplied filter.

Parameters:

filter - the filter to merge with this cache's filter

Returns:

the merged filter

checkReadOnly

protected void checkReadOnly()

Check the read-only setting to verify that the cache is NOT read-only.

Throws:

IllegalStateException - if the ContinuousQueryCache is read-only

checkEntry

protected void checkEntry(Map.Entry entry)

Check the passed value to verify that it does belong in this ContinuousQueryCache.

Parameters:

entry - a key value pair to check.

Throws:

IllegalArgumentException - if the entry does not belong in this ContinuousQueryCache (based on the cache's filter)

checkEntry

protected void checkEntry(Object oKey,
                          Object oValue)

Check the passed value to verify that it does belong in this ContinuousQueryCache.

Parameters:

oKey - the key for the entry

oValue - the value for the entry

Throws:

IllegalArgumentException - if the entry does not belong in this ContinuousQueryCache (based on the cache's filter)

getStateString

protected String getStateString(int nState)

Return a String description of the provided STATE_* variables.

Parameters:

nState - the state for which a description will be returned

Returns:

the state description

Throws:

IllegalStateException - if an unknown state is provided

Since:

12.2.1.4.5

configureSynchronization

protected void configureSynchronization(boolean fReload)

Set up the listeners that keep the ContinuousQueryCache up-to-date.

Parameters:

fReload - pass true to force a data reload

createUnexpectedStateException

protected RuntimeException createUnexpectedStateException(int nExpectedState,
                                                          int nActualState)

Simple helper to create an exception for communicating invalid state transitions.

Parameters:

nExpectedState - expected state

nActualState - actual state

Returns:

a new RuntimeException with a description of the invalid state transition

Since:

12.2.1.4.5

createTransformerFilter

protected Filter createTransformerFilter(MapEventFilter filterAdd)

Wrap specified MapEventFilter with a MapEventTransformerFilter that will either transform cache value using transformer defined for this ContinuousQueryCache, or remove the old value from the event using SemiLiteEventTransformer, if no transformer is defined for this ContinuousQueryCache.

Parameters:

filterAdd - add MapEventFilter to wrap

Returns:

MapEventTransformerFilter that wraps specified add MapEventFilter

ensureSynchronized

protected void ensureSynchronized(boolean fReload)

Ensure that the ContinuousQueryCache listeners have been registered and its content synchronized with the underlying NamedCache.

Parameters:

fReload - the value to pass to the #configureSynchronization method if the ContinuousQueryCache needs to be configured and synchronized

isEventDeferred

protected boolean isEventDeferred(Object oKey)

Called when an event has occurred. Allows the key to be logged as requiring deferred synchronization if the event occurs during the configuration or population of the ContinuousQueryCache.

Parameters:

oKey - the key that the event is related to

Returns:

true if the event processing has been deferred

ensureIndexMap

protected Map ensureIndexMap()

Ensure that the map of indexes maintained by this cache exists.

Returns:

the map of indexes.

getIndexMap

protected Map getIndexMap()

Get the map of indexes maintained by this cache.

Returns:

the map of indexes.

releaseIndexMap

protected void releaseIndexMap()

Release the the entire index map.

releaseListeners

protected void releaseListeners()

Release the listeners.

instantiateAddListener

protected MapListener<K,V_FRONT> instantiateAddListener()

Factory Method: Instantiate a MapListener for adding items to the ContinuousQueryCache, and (if there are listeners on the ContinuousQueryCache) for dispatching inserts and updates.

Returns:

a new MapListener that will add items to and update items in the ContinuousQueryCache

instantiateRemoveListener

protected MapListener<K,V_FRONT> instantiateRemoveListener()

Factory Method: Instantiate a MapListener for evicting items from the ContinuousQueryCache.

Returns:

a new MapListener that will listen to all events that will remove items from the ContinuousQueryCache

registerServiceListener

protected void registerServiceListener()

Instantiate and register a MemberListener with the underlying cache service.

The primary goal of that listener is invalidation of the front map in case of the service [automatic] restart.

unregisterServiceListener

protected void unregisterServiceListener()

Unregister underlying cache service member listener.

registerDeactivationListener

protected void registerDeactivationListener()

Instantiate and register a NamedCacheDeactivationListener with the underlying cache service.

The primary goal of that listener is invalidation of the named cache in case the named caches is destroyed / truncated.

Since:

12.2.1.4

unregisterDeactivationListener

protected void unregisterDeactivationListener()

Unregister underlying cache service member listener.

instantiateEventRouter

protected ContinuousQueryCache.EventRouter<K,V_FRONT> instantiateEventRouter(MapListener<? super K,? super V_FRONT> listener,
                                                                             boolean fLite)

Factory Method: Instantiate a listener on the internal map that will direct events to the passed listener, either synchronously or asynchronously as appropriate.

Parameters:

listener - the listener to route to

fLite - true to indicate that the MapEvent objects do not have to include the OldValue and NewValue property values in order to allow optimizations

Returns:

a new ContinuousQueryCache.EventRouter specific to the passed listener

instantiateEventQueue

protected TaskDaemon instantiateEventQueue()

Create a self-processing event queue.

Returns:

a TaskDaemon onto which events can be placed in order to be dispatched asynchronously

getEventQueue

protected TaskDaemon getEventQueue()

Obtain this ContinuousQueryCache's event queue.

Returns:

the event queue that this ContinuousQueryCache uses to dispatch its events to its non-synchronous listeners

ensureEventQueue

protected TaskDaemon ensureEventQueue()

Obtain the existing event queue or create one if none exists.

Returns:

the event queue that this ContinuousQueryCache uses to dispatch its events to its non-synchronous listeners

shutdownEventQueue

protected void shutdownEventQueue()

Shut down running event queue.

ensureListenerSupport

protected MapListenerSupport ensureListenerSupport()

Configure the local MapListenerSupport and register the intercepting MapListener with the internal ObservableMap.

Since:

12.2.1.4

ensureInflated

protected V_FRONT ensureInflated(Object oKey,
                                 Object oValue)

If the internal cache value associated with the provided key is Binary, deserialize the value and store it back to the internal cache in its deserialized form.

Parameters:

oKey - the key

oValue - optional original value associated with the key. If not provided, there will be a cost of an additional call to obtain the value currently associated with the key

Returns:

the deserialized value

Since:

12.2.1.4

fromInternal

protected <T> T fromInternal(Object binValue)

Deserialize the provided Binary value.

Type Parameters:

T - the type parameter

Parameters:

binValue - the Binary value to deserialize

Returns:

the deserialized result

Since:

12.2.1.4

toInternal

protected Binary toInternal(Object oValue)

Serialize the provided value into a Binary.

Parameters:

oValue - the object to serialize.

Returns:

the serialized result

Since:

12.2.1.4

instantiateConverterMap

protected Map<K,V_FRONT> instantiateConverterMap(Map<K,V_FRONT> map)

Provides out-bound conversion (i.e. conversion to values clients expect) of internal values.

Parameters:

map - the Map to wrap

Returns:

the Map that will be returned to the client

Since:

12.2.1.4

ensureConverted

protected InvocableMap.EntryProcessor ensureConverted(InvocableMap.EntryProcessor processor)

Wrap any AsynchronousProcessor instances with a custom wrapper to perform conversion of result returned by the processor.

Parameters:

processor - the EntryProcessor

Returns:

the EntryProcessor to leverage when dispatching aggregation requests.

Since:

12.2.1.4

isBinaryNamedCache

protected boolean isBinaryNamedCache(NamedCache cache)

Returns true if provided cache is configured to use the NullImplementation classloader which means the values to/from from the cache will be Binary.

Parameters:

cache - the cache

Returns:

true if the cache is configured to use the NullImplementation classloader

Since:

12.2.1.4

isBinaryNamedCache

protected boolean isBinaryNamedCache()

Return true if the current back cache is configured to use Binary values.

Returns:

true if the back cache is configured to use Binary values

Since:

12.2.1.4

instantiateSerializer

protected Serializer instantiateSerializer()

Create a Serializer appropriate for the mode this cache is operating under (i.e., binary vs non-binary).

Returns:

a new Serializer

Since:

12.2.1.4

ensureConverters

protected NamedCache ensureConverters(NamedCache cache)

Instantiate the converters necessary to support the processing mode that this ContinuousQueryCache will be operating under.

Parameters:

cache - the underlying cache

Returns:

the named cache

Since:

12.2.1.4

getDefaultName

protected static String getDefaultName(String sCacheName,
                                       Filter filter,
                                       ValueExtractor transformer)

Return the default name used by the CQC.

Parameters:

sCacheName - the cache name this CQC is backed by

filter - the filter that reduces the set of entries of this CQC

transformer - the transformer to apply to the raw entries

Returns:

the default name used by the CQC