Package | Description |
---|---|
com.tangosol.coherence.config.builder |
Defines the typical runtime configuration builders for the Coherence
configuration object model.
|
com.tangosol.coherence.config.scheme |
Defines the Coherence configuration object model classes and interfaces for
Caching and Service Schemes.
|
com.tangosol.coherence.jcache.common |
Common utilities used by Coherence JCache.
|
com.tangosol.coherence.jcache.localcache |
Contains classes related to local cache implementation of Coherence JCache.
|
com.tangosol.coherence.jcache.partitionedcache |
Contains classes related to partitioned cache implementation of Coherence JCache.
|
com.tangosol.net |
Contains basic cluster interfaces and factories.
|
com.tangosol.net.cache |
Contains classes providing various caching strategies.
|
com.tangosol.net.partition |
Contains interfaces and classes related to partitioned services.
|
com.tangosol.persistence |
Contains classes and helpers for implementing various types of persistence.
|
com.tangosol.util |
Contains various generic utilities.
|
com.tangosol.util.fsm |
Contains Finite state machine interfaces.
|
Class and Description |
---|
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.
|
Class and Description |
---|
AbstractBundler
An abstract base for processors that implement bundling strategy.
|
BinaryEntryStore
BinaryEntryStore is analogous to the
CacheStore , but operates on
BinaryEntry objects. |
BundlingNamedCache
Bundling NamedCache implementation.
|
CacheLoader
A JCache CacheLoader.
|
LocalCache
A LocalCache implementation that supports the JCache API, CacheLoader and
CacheStore objects.
|
ReadWriteBackingMap
Backing Map implementation that provides a size-limited cache of a
persistent store and supports configurable write-behind and refresh-
ahead caching.
|
ReadWriteBackingMap.StoreWrapper
Abstract wrapper around a cache store to allow operations to be
overridden and extended.
|
SerializationCache
A version of SerializationMap that implements an LRU policy.
|
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.
|
SimpleSerializationMap
Map implementation that stores and accesses its contents through an
underlying BinaryStore.
|
Class and Description |
---|
CacheEvent
An extension of the MapEvent which allows to differentiate between client
driven (natural) events and cache internal (synthetic) events.
|
Class and Description |
---|
CacheEvent
An extension of the MapEvent which allows to differentiate between client
driven (natural) events and cache internal (synthetic) events.
|
Class and Description |
---|
BinaryEntryStore
BinaryEntryStore is analogous to the
CacheStore , but operates on
BinaryEntry objects. |
CacheEvent
An extension of the MapEvent which allows to differentiate between client
driven (natural) events and cache internal (synthetic) events.
|
Class and Description |
---|
AbstractBundler
An abstract base for processors that implement bundling strategy.
|
BinaryEntryStore
BinaryEntryStore is analogous to the
CacheStore , but operates on
BinaryEntry objects. |
BundlingNamedCache
Bundling NamedCache implementation.
|
CacheLoader
A JCache CacheLoader.
|
CacheMap
A CacheMap is a Map that supports caching.
|
CacheStore
A JCache cache store.
|
ConfigurableCacheMap
An extension to the CacheMap interface that supports runtime configuration
and monitoring of various caching properties.
|
LocalCache
A LocalCache implementation that supports the JCache API, CacheLoader and
CacheStore objects.
|
NearCache
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.
|
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).
|
ReadWriteBackingMap
Backing Map implementation that provides a size-limited cache of a
persistent store and supports configurable write-behind and refresh-
ahead caching.
|
SerializationCache
A version of SerializationMap that implements an LRU policy.
|
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.
|
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).
|
SimpleSerializationMap
Map implementation that stores and accesses its contents through an
underlying BinaryStore.
|
TypeAssertion
Defines a
NamedCache.Option for asserting the type
of keys and values used with a NamedCache . |
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
|
Class and Description |
---|
AbstractBundler
An abstract base for processors that implement bundling strategy.
|
AbstractBundler.Bundle
Bundle represents a unit of optimized execution.
|
AbstractCacheLoader
An abstract base class for the JCache CacheLoader.
|
AbstractCacheStore
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.
|
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.
|
BinaryEntryStore
BinaryEntryStore is analogous to the
CacheStore , but operates on
BinaryEntry objects. |
BinaryMemoryCalculator
A UnitCalculator implementation that weighs a cache entry based upon the
amount of physical memory (in bytes) required to store the entry.
|
CacheEvent
An extension of the MapEvent which allows to differentiate between client
driven (natural) events and cache internal (synthetic) events.
|
CacheEvent.TransformationState
TransformationState describes how a CacheEvent has been or should be
transformed . |
CacheLoader
A JCache CacheLoader.
|
CacheLoaderCacheStore
A read-only CacheStore that wraps a CacheLoader.
|
CacheMap
A CacheMap is a Map that supports caching.
|
CacheStatistics
An interface for exposing Cache statistics.
|
CacheStore
A JCache cache store.
|
CachingMap
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.
|
CachingMap.FrontMapListener
MapListener for front map responsible for deregistering back map
listeners upon front map eviction.
|
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.
|
ContinuousQueryCache.EventRouter
An EventRouter routes events from the internal cache of the
ContinuousQueryCache to the client listeners, and it can do so
asynchronously when appropriate. |
IterableCacheLoader
A JCache CacheLoader that can iterate its underlying contents.
|
LocalCache.KeyMask
A class that masks certain changes so that they are not reported back
to the CacheStore.
|
NearCache
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.Entry
Deprecated.
A holder for a cached value.
|
OldCache.EvictionPolicy
Deprecated.
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.InternalUnitCalculator
Deprecated.
The InternalUnitCalculator represents a pluggable UnitCalculator for
the non-pluggable built-in (internal) UnitCalculator implementation
provided by this cache implementation.
|
OldCache.UnitCalculator
Deprecated.
A unit calculator is an object that can calculate the cost of caching
an object.
|
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.
|
ReadWriteBackingMap
Backing Map implementation that provides a size-limited cache of a
persistent store and supports configurable write-behind and refresh-
ahead caching.
|
ReadWriteBackingMap.CacheStoreWrapper
A wrapper around the original CacheStore to allow operations to be
overridden and extended.
|
ReadWriteBackingMap.Entry
A queue entry that is scheduled to come out of the front of the
queue no earlier than some specific point in time.
|
ReadWriteBackingMap.EntrySet
A set of entries corresponding to this backing map.
|
ReadWriteBackingMap.InternalMapListener
A MapListener implementation that listens to the internal cache and
routes those events to anyone listening to this ReadWriteBackingMap.
|
ReadWriteBackingMap.KeySet
A set of entries backed by this backing map.
|
ReadWriteBackingMap.ReadLatch
A synchronization construct used to coordinate asynchronous loads by the
refresh-ahead thread with cache accesses by other threads.
|
ReadWriteBackingMap.ReadQueue
A queue of keys that should be read from the underlying
CacheStore.
|
ReadWriteBackingMap.ReadThread
A thread that removes keys from a
ReadWriteBackingMap.ReadQueue , reads the value
for the key from the underlying CacheStore, and caches the
value in the internal ReadWriteBackingMap cache. |
ReadWriteBackingMap.StoreWrapper
Abstract wrapper around a cache store to allow operations to be
overridden and extended.
|
ReadWriteBackingMap.ValuesCollection
A collection of values backed by this map.
|
ReadWriteBackingMap.WriteQueue
A queue that only releases entries after a configurable period of time.
|
ReadWriteBackingMap.WriteThread
This is the write-behind thread that pulls things from the write-behind
queue and writes them to the CacheStore that the backing map uses.
|
SerializationCache.EntryAttributes
A class that holds on to the expiry time and touch order for an entry.
|
SerializationMap
Map implementation that stores its contents in a BinaryStore.
|
SerializationPagedCache.FakeBinaryStore
A lite BinaryStore implementation used when the real underlying
BinaryStore gets destroyed.
|
SerializationPagedCache.PagedBinaryStore
A virtual BinaryStore implementation that aggregates a sequence (newest
to oldest) of periodic BinaryStore objects.
|
SerializationPagedCache.WrapperBinaryStore
A wrapper BinaryStore implementation that keeps track of its size.
|
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.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.
|
TypeAssertion
Defines a
NamedCache.Option for asserting the type
of keys and values used with a NamedCache . |
WrapperNamedCache
A simple implementation of NamedCache interface built as a
wrapper around any Map implementation.
|
Class and Description |
---|
BinaryEntryStore
BinaryEntryStore is analogous to the
CacheStore , but operates on
BinaryEntry objects. |
CacheLoader
A JCache CacheLoader.
|
CacheMap
A CacheMap is a Map that supports caching.
|
CacheStatistics
An interface for exposing Cache statistics.
|
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.
|
ReadWriteBackingMap
Backing Map implementation that provides a size-limited cache of a
persistent store and supports configurable write-behind and refresh-
ahead caching.
|
Class and Description |
---|
KeyAssociation
A KeyAssociation represents a key object that has a natural association
with another key object.
|
Class and Description |
---|
CacheEvent
An extension of the MapEvent which allows to differentiate between client
driven (natural) events and cache internal (synthetic) events.
|
CacheEvent.TransformationState
TransformationState describes how a CacheEvent has been or should be
transformed . |
CacheLoader
A JCache CacheLoader.
|
CacheMap
A CacheMap is a Map that supports caching.
|
CacheStatistics
An interface for exposing Cache statistics.
|
CacheStore
A JCache cache store.
|
ConfigurableCacheMap.Entry
A cache Entry carries information additional to the base Map Entry in
order to support eviction and expiry.
|
ConfigurableCacheMap.UnitCalculator
A unit calculator is an object that can calculate the cost of caching
an object.
|
KeyAssociation
A KeyAssociation represents a key object that has a natural association
with another key object.
|
OldCache.UnitCalculator
Deprecated.
A unit calculator is an object that can calculate the cost of caching
an object.
|
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.
|
Class and Description |
---|
KeyAssociation
A KeyAssociation represents a key object that has a natural association
with another key object.
|