An abstract base for processors that implement bundling strategy.

Bundle represents a unit of optimized execution.

Statistics class contains the latest bundler statistics.

An abstract base class for ICacheLoader.

An abstract base class for the ICacheStore.

An abstract entry-based bundler serves as a base for NamedCache.Insert() operation bundling.

Bundle represents a unit of optimized execution.

An abstract base class for custom cache eviction policies.

An abstract key-based bundler serves as a base for NamedCache get() and remove() operation bundling.

Bundle represents a unit of optimized execution.

An event which indicates that the content of a cache has changed.

Cache expiration constants.

ICache implementation that wraps two caches - a front cache (assumed to be "inexpensive" and probably "incomplete") and a back cache (assumed to be "complete" and "correct", but more "expensive") - using a read-through/write-through approach.

DeactivationListener for the back NamedCache.

ICacheListener for front cache responsible for deregistering back cache listeners upon front cache eviction.

ICacheListener for back cache responsible for keeping the front cache coherent with the back cache.

ICacheListener for back cache responsible for keeping the front cache coherent with the back cache.

ConditionalIndex is an ICacheIndex implementation that uses an associated filter to evaluate whether or not an entry should be indexed. An entry's extracted value is only added to the index if the filter evaluates to true.

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

DeactivationListener for the underlying NamedCache.

Daemon used to dispatch asynchronous CacheEventArgss.

An EventRouter routes events from the internal cache of the ContinuousQueryCache to the client listeners, and it can do so asynchronously when appropriate.

An extension of the CacheEventArgs which may carry no values (old or new), but instead holds on an array of IFilter objects being the "cause" of the event.

Contains extension methods for IInvocableCache for the new Java 8 InvocableMap methods.

A local in-memory cache implementation.

A lock object.

KeyMask implementation that ignores nothing.

A holder for a cached value.

An internal ICacheListener that listens to this cache and reports changes to the ICacheStore.

A class that masks certain changes so that they are not reported back to the ICacheStore.

KeyMask implementation used in LoadAll().

KeyMask implementation used in Load().

Constants that define the scope of a cache lock.

A "near cache" is a CompositeCache whose front cache is a size-limited and/or auto-expiring local cache, and whose back cache is a distributed cache.

SimpleCacheIndex is an ICacheIndex implementation used to correlate property values extracted from resource cache entries with corresponding keys using what is commonly known as an Inverted Index algorithm..

Implementation of the ICacheStatistics interface intended for use by a cache to maintain its statistics.

Wrapper for a given NamedCache.

Basic ICacheEntry implementation.

An ICache is a dictionary that supports caching.

A cache entry (key-value pair).

Enumerates cache elements.

ICacheEventTransformer interface is used to allow an event consumer to change the content of a CacheEventArgs destined for the corresponding ICacheListener.

ICacheIndex is used to correlate values stored in an indexed ICache (or attributes of those values) to the corresponding keys in the indexed ICache.

The listener interface for receiving CacheEventArgs.

A cache loader.

An interface for exposing ICache statistics.

A cache store.

ICacheTrigger represents a functional agent that allows to validate, reject or modify mutating operations against an underlying cache.

A ICacheTrigger entry represents a pending change to an entry that is about to committed to the underlying cache.

ICache with additional concurrency features.

An extension to the ICache interface that supports runtime configuration and monitoring of various caching properties.

A cache Entry carries information additional to the base Map Entry in order to support eviction and expiry.

An IEntryAggregator represents processing that can be directed to occur against some subset of the entries in an IInvocableCache, resulting in a aggregated result.

An invocable agent that operates against the entry objects within a cache.

An eviction policy is an object that the cache provides with access information, and when requested, the eviction policy selects and evicts entries from the cache.

An IInvocableCache is an ICache against which both entry-targeted processing and aggregating operations can be invoked.

An IInvocableCacheEntry contains additional information and exposes additional operations that the basic ICacheEntry does not.

An ICacheLoader extension that exposes an IEnumerator for the collection of keys in the underlying ICache.

A KeyAssociation represents a key object that has a natural association with another key object.

The IObservableCache interface represents an object with a model being an ICache that allows for pluggable notifications for occuring changes.

An IParallelAwareAggregator is an advanced extension to IEntryAggregator that is explicitly capable of being run in parallel, for example in a distributed environment.

PartialResultAggregator allows for the intermediate {@link #AggregatePartialResults aggregation} of the partial results of a {@link ParallelAwareAggregator parallel aggregation}.

ICache with additional query features.

An IQueryCacheEntry exposes additional index-related functionality that the basic ICacheEntry does not.

A unit calculator is an object that can calculate the cost of caching an object.

TransformationState describes how a CacheEvent has been or should be transformed.

Cache event type enumeration.

Type of CompositeCache invalidation strategy.

The ContinuousQueryCache state values.

Enumerator mode.

The type of eviction policy employed by the cache.

The type of unit calculator used by the cache.