ContinuousQueryCache (Java API Reference for Oracle® Coherence Community Edition)

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>, NamedCollection, Releasable, ConcurrentMap<K,V_FRONT>, InvocableMap<K,V_FRONT>, ObservableMap<K,V_FRONT>, QueryMap<K,V_FRONT>, AutoCloseable, 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

All Methods Static Methods Instance Methods Concrete Methods
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 NamedCollection.
`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 Releasable 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 Releasable instance.
`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, getProcessRandom, getRandom, getRandomBinary, getRandomBinary, getRandomString, getSafeTimeMillis, getStackFrame, getStackFrames, getStackTrace, getStackTrace, getThreadFactory, getTimeZone, getUpTimeMillis, hashCode, hexValue, indentString, indentString, isDecimal, isHex, isLogEcho, isOctal, log, log, log, log, log, makeInteger, makeLong, makeThread, mod, mod, octalValue, out, out, out, out, out, pad, parseBandwidth, parseBandwidth, parseDelimitedString, parseHex, parseHex, parseMemorySize, parseMemorySize, parsePercentage, parseTime, parseTime, parseTimeNanos, parseTimeNanos, printStackTrace, randomize, randomize, randomize, 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, getName, getService, view

Methods inherited from interface com.tangosol.net.Releasable
close

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: Releasable
    
    Specifies whether or not the Releasable is active.
    
    Specified by:
    
    isActive in interface Releasable
    
    Returns:
    
    true if the NamedCache is active; false otherwise
  - release
```
public void release()
```
    Description copied from interface: Releasable
    
    Release local resources associated with this Releasable instance.
    
    Specified by:
    
    release in interface Releasable
  - destroy
```
public void destroy()
```
    Description copied from interface: NamedCollection
    
    Release and destroy this instance of NamedCollection.
    Warning: This method is used to completely destroy the specified collection across the cluster. All references in the entire cluster to this collection will be invalidated, the collection data will be cleared, and all internal resources will be released.
    
    Specified by:
    
    destroy in interface NamedCollection
  - 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

Class ContinuousQueryCache<K,V_BACK,V_FRONT>

Nested Class Summary

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

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

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

Nested classes/interfaces inherited from interface com.tangosol.net.NamedCache

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

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

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

Field Summary

Fields inherited from class com.tangosol.util.Base

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

Fields inherited from interface com.tangosol.util.ConcurrentMap

Constructor Summary

Method Summary

Methods inherited from class com.tangosol.util.AbstractKeySetBasedMap

Methods inherited from class com.tangosol.util.AbstractKeyBasedMap

Methods inherited from class com.tangosol.util.Base

Methods inherited from class java.lang.Object

Methods inherited from interface com.tangosol.net.NamedCache

Methods inherited from interface com.tangosol.net.Releasable

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

Methods inherited from interface java.util.Map

Methods inherited from interface com.tangosol.util.ConcurrentMap

Methods inherited from interface com.tangosol.util.QueryMap

Methods inherited from interface com.tangosol.util.InvocableMap

Field Detail

STATE_DISCONNECTED

STATE_CONFIGURING

STATE_CONFIGURED

STATE_SYNCHRONIZED

m_sName

m_filter

m_fCacheValues

m_transformer

m_fReadOnly

m_cReconnectMillis

m_ldtConnectionTimestamp

m_mapLocal

m_nState

m_mapSyncReq

m_eventQueue

m_fListeners

m_filterAdd

m_filterRemove

m_listenerAdd

m_listenerRemove

m_listenerService

m_mapIndex

m_listenerDeactivation

m_mapListener

m_converterFromBinary

m_converterToBinary

m_loader

m_listenerSupport

Constructor Detail

ContinuousQueryCache

ContinuousQueryCache

ContinuousQueryCache

ContinuousQueryCache

ContinuousQueryCache

ContinuousQueryCache

ContinuousQueryCache

ContinuousQueryCache

ContinuousQueryCache

ContinuousQueryCache

Method Detail

getCache

getFilter

getTransformer

getMapListener

isCacheValues

setCacheValues

isTransformed

isReadOnly

setReadOnly

instantiateInternalCache

ensureInternalCache

getInternalCache

isObserved