Package com.tangosol.net.cache

Contains classes providing various caching strategies.

Interface Summary

Interface	Description
BinaryEntryStore<K,V>	BinaryEntryStore is analogous to the CacheStore, but operates on BinaryEntry objects.
CacheLoader<K,V>	A JCache CacheLoader.
CacheMap<K,V>	A CacheMap is a Map that supports caching.
CacheStatistics	An interface for exposing Cache statistics.
CacheStore<K,V>	A JCache cache store.
ConfigurableCacheMap	An extension to the CacheMap interface that supports runtime configuration and monitoring of various caching properties.
ConfigurableCacheMap.Entry	A cache Entry carries information additional to the base Map Entry in order to support eviction and expiry.
ConfigurableCacheMap.EvictionApprover	EvictionApprover is used to approve the eviction of an entry from the underlying ConfigurableCacheMap.
ConfigurableCacheMap.EvictionPolicy	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.
ConfigurableCacheMap.UnitCalculator	A unit calculator is an object that can calculate the cost of caching an object.
IterableCacheLoader<K,V>	A JCache CacheLoader that can iterate its underlying contents.
KeyAssociation<T>	A KeyAssociation represents a key object that has a natural association with another key object.
NonBlockingEntryStore<K,V>	NonBlockingEntryStore provides a means to integrate Coherence with an underlying data source that offers a non-blocking API.
OldCache.EvictionPolicy	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.
OldCache.UnitCalculator	A unit calculator is an object that can calculate the cost of caching an object.
StoreObserver<K,V>	StoreObserver implementations provide a means for receivers, such as NonBlockingEntryStore, to notify the provider of successful completion (StoreObserver.onNext(com.tangosol.util.BinaryEntry<K, V>)) or unsuccessful completion (StoreObserver.onError(com.tangosol.util.BinaryEntry<K, V>, java.lang.Exception)).
TypeAssertion<K,V>	Defines a NamedMap.Option for asserting the type of keys and values used with a NamedCache.

Class Summary

Class	Description
AbstractBinaryEntryBundler	An abstract BinaryEntry-based bundler that serves as a base for BinaryEntryStore operation bundling.
AbstractBundler	An abstract base for processors that implement bundling strategy.
AbstractBundler.Statistics	Statistics class contains the latest bundler statistics.
AbstractCacheLoader<K,V>	An abstract base class for the JCache CacheLoader.
AbstractCacheStore<K,V>	An abstract base class for the JCache CacheLoader.
AbstractEntryBundler	An abstract entry-based bundler serves as a base for NamedCache.put() and CacheStore.store() operation bundling.
AbstractEvictionPolicy	An abstract base class for custom cache eviction policies.
AbstractKeyBundler	An abstract key-based bundler serves as a base for NamedCache get() and remove() operation bundling as well as the CacheStore load() and erase() operation bundling.
AbstractSerializationCache	An abstract base class for serialization-based caches.
BackingMapBinaryEntry	An implementation of the BinaryEntry interface that is based on specified binary key, binary value and BackingMapManagerContext.
BinaryMemoryCalculator	A UnitCalculator implementation that weighs a cache entry based upon the amount of physical memory (in bytes) required to store the entry.
BinaryStoreCacheStore<K,V>	A CacheStore that sits directly on top of a BinaryStore.
BlindCompactSerializationCache	BlindCompactSerializationCache is a CompactSerializationCache extension enforcing CompactSerializationCache to operate under a blind mode.
BundlingNamedCache	Bundling NamedCache implementation.
CacheEvent<K,V>	An extension of the MapEvent which allows to differentiate between client driven (natural) events and cache internal (synthetic) events.
CacheLoaderCacheStore<K,V>	A read-only CacheStore that wraps a CacheLoader.
CacheLoaderCacheStore.Iterable<K,V>	An extension to the CacheLoaderCacheStore that implements the IterableCacheLoader interface.
CacheStoreMap	A backing Map implementation that delegates all operations to a CacheStore.
CacheStoreMap.ReadWriteMap	A Map implementation that delegates straight through to a CacheStore.
CachingMap<K,V>	Map implementation that wraps two maps - a front map (assumed to be "inexpensive" and probably "incomplete") and a back map (assumed to be "complete" and "correct", but more "expensive") - using a read-through/write-through approach.
CompactSerializationCache	CompactSerializationCache is an implementation of ConfigurableCacheMap which is optimized for compact on-heap footprint.
CompactSerializationCache.TouchCountVisitor	TouchCountVisitor is applied to the touch-count map by EvictionPolicy implementations that rely on the touch-count to retrieve and adjust the touch-count.
ContinuousQueryCache<K,V_BACK,V_FRONT>	Create a materialized view of a NamedCache using the Coherence Continuous Query capability.
LocalCache	A LocalCache implementation that supports the JCache API, CacheLoader and CacheStore objects.
MapCacheStore<K,V>	A CacheStore that sits directly on top of a Map.
NearCache<K,V>	A "near cache" is a CachingMap whose front map is a size-limited and/or auto-expiring local cache, and whose back map is a distributed cache.
OldCache	Deprecated. As of Coherence 3.1, use LocalCache instead
OldCache.InternalEvictionPolicy	The InternalEvictionPolicy represents a pluggable eviction policy for the non-pluggable built-in (internal) eviction policies supported by this cache implementation.
OldCache.InternalUnitCalculator	The InternalUnitCalculator represents a pluggable UnitCalculator for the non-pluggable built-in (internal) UnitCalculator implementation provided by this cache implementation.
OverflowMap	An Observable Map implementation that wraps two maps - a front map (assumed to be fast but limited in its maximum size) and a back map (assumed to be slower but much less limited in its maximum size).
OverflowMap.ExpirableStatus	The ExpirableStatus adds expiry to the base Status object.
OverflowMap.HistoricCacheEvent	A CacheEvent that carries a recent value (to avoid it being lost during eviction).
OverflowMap.Status	The Status object is used to manage concurrency at the key level for the key-level operations against the Map, to track all the items in the front Map, to manage the state transition for operations occurring against the Map, and to coordinate events across multiple threads.
ReadonlyNamedCache<K,V>	A simple extension of the WrapperNamedCache implementation that shields all content mutating operations such as put(), remove(), lock() etc.
ReadWriteBackingMap	Backing Map implementation that provides a size-limited cache of a persistent store and supports configurable write-behind and refresh- ahead caching.
ReadWriteBackingMap.CacheLoaderCacheStore	A CacheStore wrapped around a CacheLoader.
ReadWriteBackingMap.EvictingBackupMap	A Map implementation used for a backup map that evicts all data that has been successfully written.
ReadWriteBackingMap.ReadLatch	A synchronization construct used to coordinate asynchronous loads by the refresh-ahead thread with cache accesses by other threads.
SeppukuMapListener	A map listener that follows the "seppuku" pattern, invalidating the Map entries when MapEvents for another related ObservableMap are delivered.
SerializationCache	A version of SerializationMap that implements an LRU policy.
SerializationCache.InternalEvictionPolicy	The InternalEvictionPolicy represents a pluggable eviction policy for the non-pluggable built-in (internal) eviction policies supported by this cache implementation.
SerializationMap	Map implementation that stores its contents in a BinaryStore.
SerializationPagedCache	A version of SerializationMap that implements an LRU policy using time-based paging of the cache.
SerializationPagedCache.FakeBinaryStore	A lite BinaryStore implementation used when the real underlying BinaryStore gets destroyed.
SimpleCacheStatistics	Implementation of the CacheStatistics interface intended for use by a cache to maintain its statistics.
SimpleMemoryCalculator	A UnitCalculator implementation that weighs a cache entry based upon the amount of physical memory (in bytes) required to store the entry.
SimpleOverflowMap	A non-observable Map implementation that wraps two maps - a front map (assumed to be fast but limited in its maximum size) and a back map (assumed to be slower but much less limited in its maximum size).
SimpleOverflowMap.FrontFilterConverter	A combination Filter and Converter used to iterate through the status map in order to iterate through the front keys.
SimpleOverflowMap.HashcodeComparator	A stateless Comparator that compares Object.hashCode() values.
SimpleOverflowMap.Status	The Status object is used to manage concurrency at the key level for the key-level operations against the Map, to track all the items in the front Map, to manage the state transition for operations occurring against the Map, and to coordinate events across multiple threads.
SimpleSerializationMap	Map implementation that stores and accesses its contents through an underlying BinaryStore.
TypeAssertion.WithTypesAssertion<K,V>
VersionedBackingMap	Deprecated. as of Coherence 3.2 all the functionality of this class has been superceded by the ReadWriteBackingMap implementation
VersionedNearCache	Deprecated. as of Coherence 3.2 all the functionality of this class has been superceded by the NearCache implementation
WrapperNamedCache<K,V>	A simple implementation of NamedCache interface built as a wrapper around any Map implementation.

Enum Summary

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