An abstract base class for ICacheLoader.

An abstract base class for the ICacheStore.

An abstract base class for custom cache eviction policies.

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.

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

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

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

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.

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.

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

Basic ICacheEntry implementation.

An ICache is a dictionary that supports caching.

A cache entry (key-value pair).

Enumerates cache elements.

The listener interface for receiving CacheEventArgs.

A cache loader.

An interface for exposing ICache statistics.

A cache store.

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.

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.

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.