Package | Description |
---|---|
com.tangosol.application |
Contains classes supporting the Coherence Container.
|
com.tangosol.coherence.commonj |
Contains Coherence-based WorkManager implementation classes.
|
com.tangosol.coherence.config.scheme |
Defines the Coherence configuration object model classes and interfaces for Caching and Service Schemes.
|
com.tangosol.coherence.dslquery.statement |
This package contains
StatementBuilder implementations and com.tangosol.coherence.dslquery.CohQLStatement implementations. |
com.tangosol.coherence.dslquery.statement.persistence | |
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.coherence.servlet |
Contains classes related to the HTTP Session Replication Module.
|
com.tangosol.coherence.servlet.api23 |
Contains classes related to the HTTP Session Replication Module that are specific to the Servlet 2.3 specification and higher.
|
com.tangosol.coherence.servlet.management |
Contains Coherence*Web MBean classes.
|
com.tangosol.io |
Contains classes providing cache persistence of serialized objects.
|
com.tangosol.io.bdb |
Contains Sleepycat Berkeley DB BinaryStore implementation classes.
|
com.tangosol.io.journal |
Contains classes related to the journaling services.
|
com.tangosol.io.nio |
Contains classes related to J2SE 1.4 NIO functionality.
|
com.tangosol.io.pof |
Contains classes related to POF serialization and deserialization.
|
com.tangosol.io.pof.reflect |
Contains classes related to POF stream navigation and manipulation.
|
com.tangosol.license | |
com.tangosol.net |
Contains basic cluster interfaces and factories.
|
com.tangosol.net.cache |
Contains classes providing various caching strategies.
|
com.tangosol.net.management |
Contains classes related to the Coherence Management Framework.
|
com.tangosol.net.partition |
Contains interfaces and classes related to partitioned services.
|
com.tangosol.net.proxy |
Contains interfaces and classes related to proxy services.
|
com.tangosol.net.security |
Contains classes related to the Coherence Security Framework.
|
com.tangosol.persistence |
Contains classes and helpers for implementing various types of persistence.
|
com.tangosol.run.jca |
Contains classes providing Java 2 Connector Architecture functionality.
|
com.tangosol.run.xml |
Contains classes providing basic XML related functionality.
|
com.tangosol.util |
Contains various generic utilities.
|
com.tangosol.util.aggregator |
Contains concrete
InvocableMap.EntryAggregator implementations. |
com.tangosol.util.comparator |
Contains concrete
Comparator implementations and related interfaces. |
com.tangosol.util.extractor |
Contains
ValueExtractor and ValueUpdater related classes. |
com.tangosol.util.filter |
Contains concrete
Filter implementations and related interfaces. |
com.tangosol.util.processor |
Contains concrete
InvocableMap.EntryProcessor implementations. |
com.tangosol.util.transformer |
Contains concrete
MapEventTransformer implementations. |
Modifier and Type | Class and Description |
---|---|
protected static class |
ContainerHelper.ContextAwareListener
Context aware delegating listener.
|
protected static class |
ContainerHelper.ContextAwarePrimingListener
Context aware delegating synchronous priming listener.
|
protected static class |
ContainerHelper.ContextAwareSyncListener
Context aware delegating synchronous listener.
|
Modifier and Type | Class and Description | ||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
class |
WorkManager
An implementation of commonj.work.WorkManager based on a joint BEA-IBM specification: "The Timer and Work Manager for Application Servers", which is a foundation of
|
||||||||||||||||||||||||
Modifier and Type | Class and Description | ||||||||||||||||||||||||
static class |
TransactionalScheme.Manager
The Manager class uses builders to create the required backing maps and provides client access to those maps.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractStatement
A base class for
Statement implementations. |
static class |
BackupStatementBuilder.BackupStatement
Implementation of the CohQL "BACKUP" command.
|
static class |
CreateCacheStatementBuilder.CreateCacheStatement
Implementation of the CohQL "CREATE CACHE" command.
|
static class |
CreateIndexStatementBuilder.CreateIndexStatement
Implementation of the CohQL "CREATE INDEX" command.
|
static class |
DeleteStatementBuilder.DeleteStatement
Implementation of the CohQL "DELETE" query.
|
static class |
DropCacheStatementBuilder.DropCacheStatement
Implementation of the CohQL "DROP CACHE" command.
|
static class |
DropIndexStatementBuilder.DropIndexStatement
Implementation of the CohQL "create index" command.
|
static class |
InsertStatementBuilder.InsertStatement
Implementation of the CohQL "INSERT" command.
|
static class |
QueryRecorderStatementBuilder.QueryRecorderStatement
Implementation of the CohQL "QueryRecorder" command.
|
static class |
RestoreStatementBuilder.RestoreStatement
Implementation of the CohQL "RESTORE" command.
|
static class |
SelectStatementBuilder.SelectStatement
Implementation of the CohQL "SELECT" command.
|
static class |
SourceStatementBuilder.SourceStatement
Implementation of the CohQL "source" command.
|
static class |
TruncateCacheStatementBuilder.TruncateCacheStatement
Implementation of the CohQL "TRUNCATE CACHE" command.
|
static class |
UpdateStatementBuilder.UpdateStatement
Implementation of the CohQL "UPDATE" command.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractSnapshotStatement
Abstract implementation of an
AbstractStatement providing functionality useful for generic snapshot statements. |
static class |
ArchiveSnapshotStatementBuilder.ArchiveSnapshotStatement
Implementation of the CohQL "ARCHIVE SNAPSHOT" command.
|
static class |
CreateSnapshotStatementBuilder.CreateSnapshotStatement
Implementation of the CohQL "CREATE SNAPSHOT" command.
|
static class |
ForceRecoveryStatementBuilder.ForceRecoveryStatement
Implementation of the CohQL "FORCE RECOVERY" command.
|
static class |
ListArchiverStatementBuilder.ListArchiverStatement
Implementation of the CohQL "LIST ARCHIVER" command.
|
static class |
ListServicesStatementBuilder.ListServicesStatement
Implementation of the CohQL "LIST SERVICES" command.
|
static class |
ListSnapshotsStatementBuilder.ListSnapshotsStatement
Implementation of the CohQL "LIST SNAPSHOTS" command.
|
static class |
RecoverSnapshotStatementBuilder.RecoverSnapshotStatement
Implementation of the CohQL "RECOVER SNAPSHOT" command.
|
static class |
RemoveSnapshotStatementBuilder.RemoveSnapshotStatement
Implementation of the CohQL "REMOVE [ARCHIVED] SNAPSHOT" command.
|
static class |
ResumeServiceStatementBuilder.ResumeServiceStatement
Implementation of the CohQL "RESUME SERVICE" command.
|
static class |
RetrieveSnapshotStatementBuilder.RetrieveSnapshotStatement
Implementation of the CohQL "RETRIEVE SNAPSHOT" command.
|
static class |
SuspendServiceStatementBuilder.SuspendServiceStatement
Implementation of the CohQL "SUSPEND SERVICE" command.
|
static class |
ValidateSnapshotStatementBuilder.ValidateSnapshotStatement
Implementation of the CohQL "VALIDATE [ARCHIVED] SNAPSHOT" command.
|
Modifier and Type | Class and Description |
---|---|
class |
LocalCacheAsynchronousMapListener<K,V>
MapListener for Coherence-based JCache adapter implementation to generate JCache
CoherenceCacheEntryEvent . |
class |
LocalCacheSynchronousMapListener<K,V>
Synchronous version of LocalCacheAsynchronousMapListener.
|
Modifier and Type | Class and Description |
---|---|
class |
PartitionedCacheAsynchronousMapListener<K,V>
MapListener for coherence cache to implement jcache map events.
|
class |
PartitionedCacheConfigurationMapListener
MapListener for meta-information about JCache
PartitionedCache instances. |
class |
PartitionedCacheSynchronousMapListener<K,V>
Synchronous version of PartitionedCacheAsynchronousMapListener.
|
class |
PartitionedCacheSyntheticDeleteMapListener<K,V>
MapListener for coherence cache to generate JCache ExpiryEvents.
|
static class |
PartitionedJCacheStatistics.CacheStatisticsExtractor
Get CacheStatistics from binEntry's context for JCache id.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractHttpSessionCollection
An abstract base class from which implementations of HttpSessionCollection can be more easily built.
|
class |
AbstractHttpSessionModel
An abstract base class from which implementations of HttpSessionModel can be more easily built.
|
class |
AttributeHolder
An immutable object to hold attribute values and related information.
|
class |
ExitAgent
This agent is used to request the other servers in the cluster to unlock the specified session ID.
|
class |
HttpRequestContext
Request context information for an HTTP Servlet request.
|
class |
LogThreadsHoldingLockAgent
An invocation service that logs the stacktraces of all threads holding a lock for a session.
|
class |
MonolithicHttpSessionCollection
An implementation of HttpSessionCollection that manages 'monolithic' session objects.
|
class |
MonolithicHttpSessionModel
This is an implementation of HttpSessionModel that manages its attribute state in a single ('monolithic') serializable unit, allowing session attributes to safely form graphs while avoiding duplication of objects, yet not being able to optimize attribute serialization and deserialization as a result.
|
class |
OptimizedHolder
An immutable object to hold attribute values and related information.
|
class |
RequestContext
Request context information for a standard Servlet request.
|
class |
SessionHelper
A collection of methods that support the implementation of Coherence web container components used to replace the corresponding implementations provided by the application server vendor.
|
class |
SessionHelper.SessionReaperDaemon
A daemon thread class that will clean up expired sessions.
|
class |
SplitHttpSessionCollection
An implementation of HttpSessionCollection that manages session objects as multiple units, splitting out larger session attributes into separately managed entries.
|
class |
SplitHttpSessionModel
This is an implementation of HttpSessionModel that manages most of its state in a single serializable unit, but splits out its large attributes -- if any -- into separately managed units.
|
class |
SplittableHolder
An immutable object to hold attribute values and related information.
|
class |
TraditionalHttpSessionCollection
An implementation of HttpSessionCollection that manages session objects as individual units that contain all of their own attributes, as if the session were a single serializable object, however with some optimizations for attribute serialization and deserialization.
|
class |
TraditionalHttpSessionModel
An implementation of HttpSessionModel that is managed as a single unit, but optimizes the management of individual attributes within a session for purposes of serialization and deserialization.
|
class |
WebPluginInstaller
This command line utility installs container-specific Coherence*Web classes into a web container installation so that Coherence*Web can tightly integrate with the target web container.
|
static class |
WebPluginInstaller.ApplyPatch
Abstract base class for all command line utilities that modify web container libraries to support extension.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultFactory
The Coherence session management Factory for the Servlet 2.3 specification.
|
class |
FilterConfigWrapper
An implementation of the FilterConfig interface that provides for a clustered ServletContext.
|
class |
FilterWrapper
An implementation of the Filter interface that provides for clustered ServletContext and HttpSession objects.
|
class |
HttpSessionContextImpl
Deprecated.
As of Java(tm) Servlet API 2.1 for security reasons, with no replacement. This interface will be removed in a future version of this API.
|
class |
HttpSessionImpl
This is the HttpSession implementation that supports clustering.
|
class |
ServletConfigWrapper
An implementation of the ServletConfig interface that provides for a clustered ServletContext.
|
class |
ServletContextAttributeListenerImpl
An implementation of the ServletContextAttributeListener interface that will listen to the application server events and translate them (wrapping the ServletContext) and routing them to the application listeners.
|
class |
ServletContextListenerImpl
An implementation of the ServletContextListener interface that will listen to application server events when the application is deployed with its own ServletContextListener(s) declared, so that the events can be forwarded to the application's listener(s).
|
class |
ServletContextWrapper.ServletContextMapListener
Inner class: A listener to listen to the clustered servlet context attributes and make those same changes to the local ServletContext.
|
class |
ServletWrapper
An implementation of the Servlet interface that provides a clustered ServletContext.
|
class |
SingleThreadModelServletWrapper
An extension to the clustered servlet wrapper for servlets that implement SingleThreadModel.
|
Modifier and Type | Class and Description |
---|---|
class |
HttpSessionManager
HttpSessionManagerMBean implementation class.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractBinaryStore
Abstract implementation of the BinaryStore interface.
|
class |
AbstractByteArrayReadBuffer
The AbstractByteArrayReadBuffer abstract class is intended to serve as a base class for the following: the pre-existing Binary class a new byte[] based class that does not attempt to add the immutability aspect provided by the Binary class a new ByteBuffer based class that will work with Java NIO This implementation is not intended to be thread safe.
|
class |
AbstractReadBuffer
Abstract base implementation of the ReadBuffer interface.
|
class |
AsyncBinaryStore
An AsyncBinaryStore is a BinaryStore wrapper that performs the "O" (output) portion of its I/O asynchronously on a daemon thread.
|
protected class |
AsyncBinaryStore.QueueDaemon
A daemon that processes queued writes.
|
class |
ByteArrayReadBuffer
A ReadBuffer on top of a byte array.
|
class |
DecoratedBinaryDeltaCompressor
A DeltaCompressor implementation that works with decorated binary values.
|
class |
DecorationOnlyDeltaCompressor
DecorationOnlyDeltaCompressor is a DeltaCompressor which optimizes for "decoration-only" updates.
|
class |
MultiBufferReadBuffer
The MultiBufferReadBuffer is a ReadBuffer implementation that presents a view across any number of underlying ReadBuffer objects, as if they were appended end-to-end into a single ReadBuffer.
|
class |
WrapperBufferOutput
This is an imitation BufferOutput implementation that provides the BufferOutput interface by delegating to an object that implements the DataOutput interface.
|
static class |
WrapperBufferOutput.VersionAwareBufferOutput
A BufferOutput implementation that in addition to delegating to the given DataOutput provides an API to check whether the recipients of the content of this BufferOutput run versions that supersede (greater or equal to) the specified version.
|
Modifier and Type | Class and Description |
---|---|
class |
BerkeleyDBBinaryStore
An implementation of the BinaryStore interface using Sleepycat Berkeley DB Java Edition.
|
class |
BerkeleyDBBinaryStoreManager
An implementation of the BinaryStoreManager interface using Sleepycat Berkeley DB Java Edition.
|
class |
DatabaseFactory
Factory for Berkeley DB Environments and Databases.
|
class |
DatabaseFactoryManager
A manager for Berkeley DB Database factories.
|
Modifier and Type | Class and Description |
---|---|
protected class |
AbstractJournalRM.CollectorDaemon
The CollectorDaemon evaluates the JournalFile objects to see which ones should be evacuated, it evacuates those that should be, and it deletes those that have been successfully evacuated.
|
protected class |
FlashJournalRM.PreparerDaemon
The PreparerDaemon takes the enqueued Binary values for the JournalFile objects, and lays them out in Buffer objects from the BufferPool, enqueuing them for the WriterDaemon to write.
|
protected class |
FlashJournalRM.WriterDaemon
The WriterDaemon takes the enqueued Buffer objects from the PreparerDaemon, and appends them to a JournalFile.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractBufferManager
Provides a basic implementation of ByteBufferManager.
|
class |
AbstractStoreManager
A base implementation of BinaryStoreManager interface that uses
BinaryMap objects built on a ByteBufferManager to provide BinaryStore objects. |
class |
BinaryMap.Block
A Block is the unit of storage within a Buffer.
|
static class |
BinaryMap.Entry
A map entry (key-value pair).
|
class |
ByteBufferReadBuffer
A ReadBuffer implementation on top of a Java NIO ByteBuffer.
|
class |
DirectBufferManager
Deprecated.
use
JournalBinaryStore instead |
class |
DirectStoreManager
Deprecated.
use
JournalBinaryStore instead |
class |
MappedBufferManager
Manages a ByteBuffer on a file.
|
class |
MappedStoreManager
An implementation of BinaryStoreManager interface that uses
BinaryMap objects built on the MappedBufferManager to provide BinaryStore objects. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractPofHandler
An abstract implementation of PofHandler that delegates to a PofHandler.
|
class |
DuplexingPofHandler
An implementation of PofHandler that passes each call onto two different PofHandler objects.
|
class |
ExternalizableLitePofSerializer
PofSerializer implementation that supports the serialization and deserialization of any class that implements ExternalizableLite to and from a POF stream. |
class |
ExternalizablePofSerializer
PofSerializer implementation that supports the serialization and deserialization of any class that implements Externalizable to and from a POF stream. |
class |
LoggingPofHandler
An implementation of PofHandler that logs all of the stream contents for debugging / testing purposes.
|
class |
PofBufferReader
PofReader implementation that reads POF-encoded data from a BufferInput . |
static class |
PofBufferReader.UserTypeReader
The UserTypeReader implementation is a contextually-aware PofReader whose purpose is to advance through the properties of a value of a specified user type.
|
class |
PofBufferWriter
PofWriter implementation that writes POF-encoded data to a BufferOutput . |
static class |
PofBufferWriter.UserTypeWriter
The UserTypeWriter implementation is a contextually-aware PofWriter whose purpose is to write the properties of a value of a specified user type.
|
class |
PofHelper
Collection of helper methods for POF streams.
|
class |
PofParser
A "push" parser (event-based parser) for ripping through a POF stream and delivering the contents as events to a PofHandler object.
|
class |
PofPrincipal
Generic Principal implementation that can be used to represent the identity of any remote entity.
|
class |
PortableObjectSerializer
PofSerializer implementation that supports the serialization and deserialization of any class that implements PortableObject to and from a POF stream. |
class |
RawDate
An immutable POF date value.
|
class |
RawDateTime
An immutable POF date-time value.
|
class |
RawDayTimeInterval
An immutable POF day-time interval value.
|
class |
RawTime
An immutable POF time value.
|
class |
RawTimeInterval
An immutable POF time interval value.
|
class |
RawYearMonthInterval
An immutable POF year-month interval value.
|
class |
SafeConfigurablePofContext.JavaPofSerializer
Serializer used for Serializable and ExternalizableLite objects.
|
class |
SafeConfigurablePofContext.SafePofSerializer
Serializer used for objects implementing the PortableObject interface.
|
class |
ValidatingPofHandler
An implementation of PofHandler that validates a POF stream.
|
class |
ValidatingPofHandler.Complex
A Complex object represents the current complex data structure in the POF stream.
|
class |
ValidatingPofHandler.ComplexMap
A ComplexMap object represents a map data structure (potentially with uniform keys or with uniform keys and values) in the POF stream.
|
class |
WritingPofHandler
An implementation of PofHandler that writes a POF stream to a WriteBuffer using a BufferOutput object.
|
static class |
WritingPofHandler.Complex
A Complex object represents the current complex data structure in the POF stream.
|
static class |
WritingPofHandler.ComplexMap
A ComplexMap object represents a map data structure (with uniform keys or with uniform keys and values) in the POF stream.
|
class |
XmlSerializablePofSerializer
PofSerializer implementation that supports the serialization and deserialization of any class that implements XmlSerializable to and from a POF stream. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractPofPath
Abstract base class for static, path-based implementations of
PofNavigator interface. |
class |
AbstractPofValue
An abstract base class that implements common functionality for all PofValue types.
|
class |
ComplexPofValue
An abstract base class for complex POF types, such as collections, arrays, maps, and user types.
|
class |
PofArray
PofArray is a
PofValue implementation for arrays. |
class |
PofCollection
PofCollection is
PofValue implementation for collections. |
class |
PofSparseArray
PofSparseArray is
PofValue implementation for sparse arrays. |
protected static class |
PofSparseArray.NilPofValue
NilPofValue represents a value that does not exist in the original POF stream.
|
class |
PofUniformArray
PofUniformArray is
PofValue implementation for uniform arrays. |
class |
PofUniformCollection
PofUniformCollection is
PofValue implementation for uniform collections. |
class |
PofUniformSparseArray
PofUniformSparseArray is
PofValue implementation for uniform sparse arrays. |
class |
PofUserType
PofUserType is
PofValue implementation for user types. |
class |
PofValueParser
Parses POF-encoded binary and returns an instance of a
PofValue wrapper for it. |
class |
SimplePofPath
A static
PofNavigator implementation which uses an array of integer indices to navigate the PofValue hierarchy. |
class |
SimplePofValue
SimplePofValue represents POF values which do not contain children (e.g.
|
Modifier and Type | Class and Description |
---|---|
class |
com.tangosol.license.CoherenceApplicationEdition
This class is a license class.
|
class |
com.tangosol.license.CoherenceDataGridEdition
This class is a license class.
|
class |
com.tangosol.license.LicensedObject
This class is a base class for classes that may be license-limited.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractBackingMapManager
Abstract base of the BackingMapManager implementations.
|
class |
AbstractInvocable
An abstract base for Invocable and PriorityTask implementations.
|
class |
AbstractPriorityTask
An abstract base for PriorityTask implementations.
|
class |
AbstractServiceLoadBalancer<S extends Service,T extends ServiceLoad>
An abstract base for ServiceLoadBalancer implementations.
|
class |
CacheFactory
Factory for the Coherence™ cache product.
|
class |
CompressionFilter
Deprecated.
As of Coherence 3.7
|
class |
ConfigurableQuorumPolicy
ConfigurableQuorumPolicy provides a Quorum-based
ActionPolicy for services based on the cluster-configuration. |
static class |
ConfigurableQuorumPolicy.ClusterQuorumPolicy
ClusterQuorumPolicy defines an action policy that is applicable to the cluster.
|
static class |
ConfigurableQuorumPolicy.MembershipQuorumPolicy
MembershipQuorumPolicy is a quorum policy that is stateless and based solely on service membership sizes.
|
static class |
ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy
PartitionedCacheQuorumPolicy defines a configurable quorum policy that is applicable to a DistributedCacheService.
|
static class |
ConfigurableQuorumPolicy.ProxyQuorumPolicy
ProxyQuorumPolicy defines a configurable quorum policy that is applicable to a proxy service.
|
class |
DefaultCacheServer
DefaultCacheServer is a simple command line facility and convenience API that starts all services that are declared as requiring an "autostart" in the configurable factory XML descriptor.
|
static class |
DefaultCacheServer.GarServer
GarServer provides the functionality of DefaultCacheServer under the context of a GAR file.
|
class |
DefaultConfigurableCacheFactory
Deprecated.
|
class |
DefaultConfigurableCacheFactory.Manager
Deprecated.
BackingMapManager implementation that uses the configuration XML to create the required backing maps and provides client access to those maps.
|
protected class |
DefaultConfigurableCacheFactory.PartitionedBackingMapManager
Deprecated.
BackingMapManager implementation used by PartitionAwareBackingMap(s) to lazily configure the enclosing PABM based on the configuration settings of the enclosed maps.
|
class |
ExtensibleConfigurableCacheFactory
ExtensibleConfigurableCacheFactory provides a facility to access caches declared in a "coherence-cache-config.xsd" compliant configuration file.
|
static class |
ExtensibleConfigurableCacheFactory.Manager
The Manager class uses builders to create the required backing maps and provides client access to those maps.
|
static class |
ExtensibleConfigurableCacheFactory.PartitionedBackingMapManager
The PartitionedBackingMapManager is used by PartitionAwareBackingMap(s) to lazily configure the enclosing PABM based on the configuration settings of the enclosed maps.
|
class |
GuardSupport
A concrete implementation of Guardian/Guardable interactions.
|
class |
LoadBalancer
A non-sticky HTTP load-balancer.
|
static class |
LoadBalancer.AddressPort
An AddressPort is an immutable combination of an IP address and a port number.
|
static class |
LoadBalancer.Queue
A Queue is used to effeciently queue up items for daemon threads to work on.
|
class |
LoadBalancer.RequestHandler
A RequestHandler is a daemon thread that processes a request from a queue.
|
class |
LoadBalancer.ResponseHandler
A ResponseHandler is a daemon thread that processes an outgoing response from a destination server.
|
static class |
LoadBalancer.SocketHandler
A SocketHandler is an abstract daemon thread.
|
class |
RefreshableAddressProvider
A RefreshableAddressProvider is an AddressProvider implementation that wraps another AddressProvider and refresh the address list of the provider asynchronously.
|
protected class |
RefreshableAddressProvider.RefreshThread |
class |
SimpleServiceLoadBalancer<S extends Service,T extends ServiceLoad>
A simple ServiceLoadBalancer implementation.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractBinaryEntryBundler
An abstract BinaryEntry-based bundler that serves as a base for BinaryEntryStore operation bundling.
|
protected class |
AbstractBinaryEntryBundler.Bundle |
class |
AbstractBundler
An abstract base for processors that implement bundling strategy.
|
protected class |
AbstractBundler.Bundle
Bundle represents a unit of optimized execution.
|
class |
AbstractCacheLoader<K,V>
An abstract base class for the JCache CacheLoader.
|
class |
AbstractCacheStore<K,V>
An abstract base class for the JCache CacheLoader.
|
class |
AbstractEntryBundler
An abstract entry-based bundler serves as a base for NamedCache.put() and CacheStore.store() operation bundling.
|
protected class |
AbstractEntryBundler.Bundle |
class |
AbstractEvictionPolicy
An abstract base class for custom cache eviction policies.
|
class |
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.
|
protected class |
AbstractKeyBundler.Bundle
Bundle represents a unit of optimized execution.
|
class |
AbstractSerializationCache
An abstract base class for serialization-based caches.
|
class |
BackingMapBinaryEntry
An implementation of the BinaryEntry interface that is based on specified binary key, binary value and BackingMapManagerContext.
|
class |
BinaryMemoryCalculator
A UnitCalculator implementation that weighs a cache entry based upon the amount of physical memory (in bytes) required to store the entry.
|
class |
BinaryStoreCacheStore<K,V>
A CacheStore that sits directly on top of a BinaryStore.
|
class |
BlindCompactSerializationCache
BlindCompactSerializationCache is a
CompactSerializationCache extension enforcing CompactSerializationCache to operate under a blind mode. |
class |
BundlingNamedCache
Bundling NamedCache implementation.
|
protected class |
BundlingNamedCache.GetBundler |
protected class |
BundlingNamedCache.PutBundler |
protected class |
BundlingNamedCache.RemoveBundler |
class |
CacheLoaderCacheStore<K,V>
A read-only CacheStore that wraps a CacheLoader.
|
static class |
CacheLoaderCacheStore.Iterable<K,V>
An extension to the CacheLoaderCacheStore that implements the IterableCacheLoader interface.
|
static class |
CacheStoreMap.ReadWriteMap
A Map implementation that delegates straight through to a CacheStore.
|
protected class |
CachingMap.DeactivationListener
DeactivationListener for the back NamedCache.
|
protected class |
CachingMap.FrontMapListener
MapListener for front map responsible for deregistering back map listeners upon front map eviction.
|
protected class |
CachingMap.PrimingListener
MapListener for back map responsible for keeping the front map coherent with the back map.
|
protected class |
CachingMap.SimpleListener
MapListener for back map responsible for keeping the front map coherent with the back map.
|
class |
CompactSerializationCache
CompactSerializationCache is an implementation of
ConfigurableCacheMap which is optimized for compact on-heap footprint. |
class |
ContinuousQueryCache<K,V_BACK,V_FRONT>
Create a materialized view of a NamedCache using the Coherence Continuous Query capability.
|
class |
ContinuousQueryCache.AddListener
A MapListener for adding items to the ContinuousQueryCache.
|
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.
|
class |
ContinuousQueryCache.RemoveListener
A MapListener for evicting items from the ContinuousQueryCache.
|
class |
LocalCache.Entry
A holder for a cached value.
|
protected class |
LocalCache.InternalListener
An internal MapListener that listens to this cache and reports changes to the CacheStore.
|
protected class |
LocalCache.KeyMask
A class that masks certain changes so that they are not reported back to the CacheStore.
|
class |
MapCacheStore<K,V>
A CacheStore that sits directly on top of a Map.
|
class |
OldCache.Entry
Deprecated.
A holder for a cached value.
|
class |
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).
|
protected class |
OverflowMap.BackMapListener
A listener for the back map.
|
protected class |
OverflowMap.FrontMapListener
A listener for the front map that moves evictions to the back map.
|
class |
ReadonlyNamedCache<K,V>
A simple extension of the WrapperNamedCache implementation that shields all content mutating operations such as put(), remove(), lock() etc.
|
class |
ReadWriteBackingMap.BinaryEntryStoreWrapper
A wrapper around the original BinaryEntryStore to allow operations to be overridden and extended.
|
static class |
ReadWriteBackingMap.CacheLoaderCacheStore
A CacheStore wrapped around a CacheLoader.
|
class |
ReadWriteBackingMap.CacheStoreWrapper
A wrapper around the original CacheStore to allow operations to be overridden and extended.
|
class |
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.
|
static class |
ReadWriteBackingMap.EvictingBackupMap
A Map implementation used for a backup map that evicts all data that has been successfully written.
|
protected class |
ReadWriteBackingMap.InternalMapListener
A MapListener implementation that listens to the internal cache and routes those events to anyone listening to this ReadWriteBackingMap.
|
class |
ReadWriteBackingMap.ReadQueue
A queue of keys that should be read from the underlying CacheStore.
|
class |
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. |
class |
ReadWriteBackingMap.StoreWrapper
Abstract wrapper around a cache store to allow operations to be overridden and extended.
|
class |
ReadWriteBackingMap.WriteQueue
A queue that only releases entries after a configurable period of time.
|
class |
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.
|
class |
SeppukuMapListener
A map listener that follows the "seppuku" pattern, invalidating the Map entries when MapEvents for another related ObservableMap are delivered.
|
class |
SerializationCache
A version of SerializationMap that implements an LRU policy.
|
protected class |
SerializationCache.EntryAttributes
A class that holds on to the expiry time and touch order for an entry.
|
class |
SerializationCache.EntrySet.Entry
A Cache Entry implementation.
|
class |
SerializationMap
Map implementation that stores its contents in a BinaryStore.
|
class |
SerializationPagedCache
A version of SerializationMap that implements an LRU policy using time-based paging of the cache.
|
class |
SerializationPagedCache.PagedBinaryStore
A virtual BinaryStore implementation that aggregates a sequence (newest to oldest) of periodic BinaryStore objects.
|
class |
SimpleCacheStatistics
Implementation of the CacheStatistics interface intended for use by a cache to maintain its statistics.
|
class |
SimpleMemoryCalculator
A UnitCalculator implementation that weighs a cache entry based upon the amount of physical memory (in bytes) required to store the entry.
|
class |
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).
|
protected class |
SimpleOverflowMap.FrontMapListener
A listener for the front map that moves evictions to the back map.
|
class |
SimpleSerializationMap
Map implementation that stores and accesses its contents through an underlying BinaryStore.
|
class |
VersionedBackingMap.CacheStoreWrapper
Deprecated.
A wrapper around the original CacheStore to allow operations to be overridden and extended.
|
protected class |
VersionedBackingMap.InternalMapListener
Deprecated.
A MapListener implementation that listens to the internal cache and routes those events to anyone listening to this VersionedBackingMap.
|
class |
VersionedNearCache.VersionCacheListener
Deprecated.
A map listener that listens to the VersionCache and invalidates local entries accordingly.
|
class |
WrapperNamedCache<K,V>
A simple implementation of NamedCache interface built as a wrapper around any Map implementation.
|
Modifier and Type | Class and Description |
---|---|
class |
MBeanConnector
Utility class to expose Coherence JMX MBeans via the Sun JMX reference implementation HtmlAdaptorServer or a JMX Remote
JMXConnectorServer . |
class |
MBeanHelper
Helper class providing various functionality related to aggregation of attributes and methods exposed by Coherence JMX framework MBeans.
|
class |
ObjectNameExcludeFilter
Filter used to prevent registering MBeans that match the specified pattern.
|
Modifier and Type | Class and Description |
---|---|
class |
BroadKeyPartitioningStrategy
The BroadKeyPartitioningStrategy is a strategy that could be used in cases when the standard key association-based strategy produces very uneven partition distribution - some partitions having significantly larger amount of data than others.
|
class |
DefaultKeyPartitioningStrategy
DefaultKeyPartitioningStrategy provides a simple strategy for assigning keys to partitions which is based on the hash code of keys in internal (serialized to Binary) form.
|
class |
ObservableSplittingBackingCache
The ObservableSplittingBackingCache is an implementation of the ConfigurableCacheMap interface that works as an observable backing map in a partitioned system.
|
protected static class |
ObservableSplittingBackingCache.CapacityAwareMap
A subclass of PartitionSplittingBackingMap which allows an injected instance of
ObservableSplittingBackingMap to be called immediately before inserting a value(s) in a partition map. |
class |
ObservableSplittingBackingCache.EntrySet.Entry
A Cache Entry implementation.
|
class |
ObservableSplittingBackingMap
An observable, cache-aware PartitionAwareBackingMap implementation.
|
class |
Ownership
Ownership is a light-weight data structure that contains a partition ownership information.
|
class |
PartitionSet
PartitionSet is a light-weight data structure that represents a set of partitions that are used in parallel processing.
|
class |
PartitionSplittingBackingMap
In a partitioned configuration, the PartitionSplittingBackingMap is a "map multi-plexer" that enables multiple backing maps to be used in place of a single backing map.
|
class |
PartitionSplittingBackingMap.MaskedPartitionMap
A read-only view into a subset of backing maps managed by the underlying PartitionSplittingBackingMap.
|
class |
VersionedOwnership
An extension of the partition Ownership object which also carries a change version.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultProxyServiceLoadBalancer
Default ProxyServiceLoadBalancer implementation.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultController
The default implementation of the AccessController interface.
|
class |
DefaultIdentityAsserter
The default implementation of the IdentityAsserter interface.
|
class |
PermissionInfo
PermissionInfo holds the information needed to validate and respond to a security related request.
|
class |
Security
The Security class is used to associate client's identity with an action that requires access to protected clustered resources.
|
class |
SimpleHandler
The SimpleHandler class is a CallbackHandler implementation based on a specified user name and password.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractPersistenceEnvironment
Abstract implementation of a ReadBuffer-based PersistentEnvironment.
|
class |
AbstractPersistenceManager<PS extends AbstractPersistenceManager.AbstractPersistentStore>
Abstract implementation of a ReadBuffer-based PersistentManager.
|
class |
AbstractPersistenceManager.AbstractPersistentStore
Abstract implementation of a ReadBuffer-based PersistentStore.
|
protected class |
AbstractPersistenceManager.AbstractPersistentStore.BatchTask
Runnable implementation that is used to perform and commit a sequence of mutating persistent store operations asynchronously.
|
protected class |
AbstractPersistenceManager.AbstractPersistentStore.BatchTask.EraseOperation
An erase() Operation.
|
protected class |
AbstractPersistenceManager.AbstractPersistentStore.BatchTask.Operation
Base class for Runnable implementations that encapsulate a persistent store operation.
|
protected class |
AbstractPersistenceManager.AbstractPersistentStore.BatchTask.StoreOperation
A store() Operation.
|
protected class |
AbstractPersistenceManager.AbstractPersistentStore.DeleteExtentTask
A Task implementation that deletes an extent from the associated store.
|
protected class |
AbstractPersistenceManager.AbstractPersistentStore.OpenTask
An OpenTask opens the store (parent of this inner class) with the provided store and notifies the Collector when complete.
|
class |
AbstractPersistenceManager.Task
Runnable extension that adds the ability to notify the task that it has been canceled.
|
static class |
GUIDHelper.GUIDResolver
Resolver used during a recovery to discover the newest available GUID for a given partition.
|
Modifier and Type | Class and Description |
---|---|
class |
CacheAdapter
CacheAdapter encapsulates the operations neccessary to communicate with Coherence™ resource adapter (coherence-tx.rar).
|
class |
SimpleValidator
Simple generic Validator implementation that uses hashCode values for the enlisted resources to resolve optimistic transaction conflicts.
|
Modifier and Type | Class and Description |
---|---|
class |
ArrayAdapter
An ArrayAdapter supports properties of Java array types (not including arrays of primitive types).
|
class |
CollectionAdapter
A CollectionAdapter supports properties whose types implement the java.util.Collection interface.
|
class |
DateFormatAdapter
A property adapter for formatting formatting and parsing dates in a locale-sensitive manner.
|
class |
DateTimeAdapter
A property adapter for the <xs:dateTime> format conforming to ISO 8601
|
class |
IterableAdapter
An IterableAdapter is the base class for any data type that must be iterated over to serialize/deserialize, such as arrays, collections and maps.
|
class |
MapAdapter
A MapAdapter supports properties whose types implement the java.util.Map interface.
|
class |
PrimitiveArrayAdapter
A PrimitiveArrayAdapter supports arrays of primitive types, such as "int", "char", etc.
|
static class |
PrimitiveArrayAdapter.BooleanArrayAdapter
A PropertyAdapter supporting boolean[].
|
static class |
PrimitiveArrayAdapter.ByteArrayAdapter
A PropertyAdapter supporting byte[].
|
static class |
PrimitiveArrayAdapter.CharArrayAdapter
A PropertyAdapter supporting char[].
|
static class |
PrimitiveArrayAdapter.DoubleArrayAdapter
A PropertyAdapter supporting double[].
|
static class |
PrimitiveArrayAdapter.FloatArrayAdapter
A PropertyAdapter supporting float[].
|
static class |
PrimitiveArrayAdapter.IntArrayAdapter
A PropertyAdapter supporting int[].
|
static class |
PrimitiveArrayAdapter.LongArrayAdapter
A PropertyAdapter supporting long[].
|
static class |
PrimitiveArrayAdapter.ShortArrayAdapter
A PropertyAdapter supporting short[].
|
class |
PropertyAdapter
The PropertyAdapter is the base class for handling the operations that can occur on any property.
|
class |
QNameAdapter
A property adapter for QName primitive datatype.
|
class |
RestrictedStringAdapter
A property adapter for a String based type that is known to have a converting factory method with the following signature:
public static <type> valueOf(String s) . |
class |
SaxParser
A simple XML parser.
|
class |
SerializableAdapter
A SerializableAdapter supports Java objects that implement the Serializable interface.
|
class |
SimpleAdapter
A SimpleAdapter supports Java intrinsic types and a common set of Java classes: java.lang.Boolean java.lang.Byte java.lang.Character java.lang.Short java.lang.Integer java.lang.Long java.lang.Float java.lang.Double java.lang.String java.math.BigDecimal java.math.BigInteger java.sql.Date java.sql.Time java.sql.Timestamp java.util.Date
|
static class |
SimpleAdapter.BigDecimalAdapter
A simple property adapter for BigDecimal.
|
static class |
SimpleAdapter.BigIntegerAdapter
A simple property adapter for BigInteger.
|
static class |
SimpleAdapter.BooleanAdapter
A simple property adapter for boolean.
|
static class |
SimpleAdapter.ByteAdapter
A simple property adapter for byte.
|
static class |
SimpleAdapter.CharAdapter
A simple property adapter for char.
|
static class |
SimpleAdapter.DateAdapter
A simple property adapter for Date.
|
static class |
SimpleAdapter.DoubleAdapter
A simple property adapter for double.
|
static class |
SimpleAdapter.FloatAdapter
A simple property adapter for float.
|
static class |
SimpleAdapter.IntAdapter
A simple property adapter for int.
|
static class |
SimpleAdapter.LongAdapter
A simple property adapter for long.
|
static class |
SimpleAdapter.OldDateAdapter
A simple property adapter for the Date class from the java/util package.
|
static class |
SimpleAdapter.ShortAdapter
A simple property adapter for short.
|
static class |
SimpleAdapter.StringAdapter
A simple property adapter for String.
|
static class |
SimpleAdapter.SystemTimeAdapter
A simple property adapter for Java long and java.lang.Long values that is string-formatted as a date/time, assuming that the long value is actualy a system time.
|
static class |
SimpleAdapter.TimeAdapter
A simple property adapter for Time.
|
static class |
SimpleAdapter.TimestampAdapter
A simple property adapter for Timestamp.
|
class |
SimpleDocument
A simple implementation of the XmlElement interface.
|
class |
SimpleElement
A simple implementation of the XmlElement interface.
|
class |
SimpleElement.AttributeMap.Entry
An implementation of Entry that supports keeping them in a list.
|
class |
SimpleParser
This class uses the XmlTokenizer to produce an XmlDocument from XML text.
|
class |
SimpleValue
A simple implementation of the XmlValue interface.
|
class |
XmlBean
This is a base class for building XmlSerializable value objects.
|
class |
XmlElementAdapter
An XmlElementAdapter supports properties of type XmlElement.
|
class |
XmlHelper
This abstract class contains XML manipulation methods.
|
class |
XmlSerializableAdapter
An XmlSerializableAdapter supports Java objects that implement the XmlSerializable interface.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractKeyBasedMap<K,V>
AbstractKeyBasedMap is a base class for Map implementations.
|
protected class |
AbstractKeyBasedMap.EntrySet.Entry
A Map Entry implementation that defers its value acquisition from the containing map (via
Map.get(Object) ) if the Entry is constructed with a null value. |
class |
AbstractKeySetBasedMap<K,V>
AbstractKeySetBasedMap is an extension to the AbstractKeyBasedMap that has a full awareness of the set of keys upon which the Map is based.
|
class |
AbstractMapListener
A base class that simplifies the implementation of a MapListener, particularly inner classes that only implement one or two of the three event methods.
|
class |
Binary
A thread-safe immutable binary object.
|
static class |
BinaryLongMap.SimpleMapImpl
A java.util.Map<Binary, Long> implementation.
|
class |
BitHelper
A collection of methods for bit-based operations.
|
class |
ChainedEnumerator
Provide an enumerator which enumerates the contents of multiple enumerators.
|
class |
ClassFilter
Filter which discards all objects that are not of a certain class.
|
class |
CompositeKey<P,S>
Key class that consists of a primary and secondary component.
|
class |
ConditionalIndex
ConditionalIndex is a
MapIndex implementation that uses an associated filter to evaluate whether or not an entry should be indexed. |
static class |
ConverterCollections.ConverterCacheListener
A converter MapListener that converts events of the underlying MapListener for the underlying NamedCache.
|
static class |
ConverterCollections.ConverterMapListener
A converter MapListener that converts events of the underlying MapListener for the underlying map.
|
class |
Daemon
A abstract Daemon thread handler.
|
class |
Dequeue
Represents a double-ended queue (dequeue) of objects.
|
class |
EnumerationIterator<E>
Provide a implementation of an Iterator based on data from an Enumeration.
|
class |
ExternalizableHelper
Helpers for the Serializable, Externalizable and the ExternalizableLite interface.
|
static class |
ExternalizableHelper.DecoratedMultiBufferReadBuffer
DecoratedMultiBufferReadBuffer is a MultiBufferWriteBuffer that represents a binary "decorated" value, and allows a more optimized
ExternalizableHelper.getUndecorated(ReadBuffer) operation. |
protected static class |
ExternalizableHelper.IntDecoratedObject
Integer decorated object.
|
static class |
ExternalizableHelper.SimpleXmlBeanClassCache
An implementation XmlBeanClassCache that uses a pre-defined list of XmlBean implementations.
|
class |
FilterEnumerator
Provide a generic implementation of an enumerator which can enumerate items based on an inclusion test.
|
class |
InvocableMapHelper
Helper methods for InvocableMap implementations and Filter related evaluation.
|
static class |
InvocableMapHelper.SimpleEntry<K,V>
Simple implementation of the InvocableMap.Entry interface.
|
class |
IteratorEnumerator
Provide a implementation of an enumerator based on data from an Iterator.
|
class |
KeyValueArrayMap
KeyValueArrayMap is a Map implementation backed by an array of keys, and an array of the associated values.
|
class |
Listeners
Provide a simple, efficient, and thread-safe implementation of a list of event listeners.
|
class |
MapListenerSupport
This class provides support for advanced MapListener functionality.
|
static class |
MapListenerSupport.WrapperListener<K,V>
A base class for various wrapper listener classes.
|
static class |
MapListenerSupport.WrapperPrimingListener
A wrapper class that turns the specified MapListener into a priming listener.
|
static class |
MapListenerSupport.WrapperSynchronousListener<K,V>
A wrapper class that turns the specified MapListener into a synchronous listener.
|
class |
MapTriggerListener
MapTriggerListener is a special purpose MapListener implementation that is used to register a
MapTrigger on a corresponding ObservableMap. |
class |
MultiplexingMapListener<K,V>
A base class that simplifies the implementation of a MapListener by multiplexing all events into a single listener method.
|
class |
NullFilter
Filter which discards null references.
|
static class |
NullImplementation.NullEntryProcessor
An implementation of an EntryProcessor that does nothing and returns Boolean.TRUE as a result of execution.
|
protected class |
ObservableHashMap.Entry<K,V>
A holder for a cached value.
|
class |
OpenHashMap<K,V>
An implementation of
Map that is optimized for memory footprint. |
protected class |
OpenHashMap.EntrySet.Entry
An Entry implementation that is augmented to allow an Entry instance to be re-used, which means that the same Entry instance can represent different map entries over time.
|
class |
PagedIterator
PagedIterator is an Iterator implementation based on a concept of a page Advancer - a pluggable component that knows how to supply a next page of objects to iterate through.
|
protected class |
RecyclingLinkedList.Node
A Node in the List.
|
class |
RestrictedCollections
A collection of Collection implementation classes that limit the data type.
|
static class |
RestrictedCollections.RestrictedCollection
A restricted Collection that requires its contents to be of a specified class.
|
static class |
RestrictedCollections.RestrictedEntrySet
A restricted Collection that requires its contents to be of a specified class.
|
protected class |
RestrictedCollections.RestrictedEntrySet.RestrictedEntry
A Map Entry that restricts the key and value types.
|
protected class |
RestrictedCollections.RestrictedEntrySet.RestrictedIterator
A Map Entry Iterator that restricts the key and value types.
|
static class |
RestrictedCollections.RestrictedList
A restricted List that requires its contents to be of a specified class.
|
static class |
RestrictedCollections.RestrictedListIterator
A restricted ListIterator that requires its contents to be of a specified class.
|
static class |
RestrictedCollections.RestrictedMap
A restricted Map that requires its keys and values to be of specified classes.
|
static class |
RestrictedCollections.RestrictedSet
A restricted Set that requires its contents to be of a specified class.
|
static class |
RestrictedCollections.RestrictedSortedMap
A restricted SortedMap that requires its keys and values to be of specified classes.
|
static class |
RestrictedCollections.RestrictedSortedSet
A restricted Set that requires its contents to be of a specified class.
|
protected static class |
SafeHashMap.Entry<K,V>
A map entry (key-value pair).
|
protected static class |
SafeLinkedList.Node
A Node in the List.
|
class |
SegmentedConcurrentMap
An implementation of SegmentedHashMap that also implements the ConcurrentMap interface.
|
class |
SegmentedConcurrentMap.LockableEntry
LockableEntry is an Entry that supports locking.
|
class |
SegmentedHashMap
An implementation of java.util.Map that is optimized for heavy concurrent use.
|
protected static class |
SegmentedHashMap.Entry
A map entry (key-value pair).
|
class |
SimpleEnumerator<E>
Provide a generic implementation of an array enumerator.
|
class |
SimpleMapEntry<K,V>
A map entry (key-value pair).
|
class |
SimpleMapIndex
SimpleMapIndex is a MapIndex implementation used to correlate property values extracted from resource map entries with corresponding keys using what is commonly known as an Inverted Index algorithm.
|
static class |
SimpleMapIndex.IndexCalculator
A stateful
calculator used to calculate the cost of a homogeneous index (holding all values of a single type). |
class |
SortedEnumerator
Sorts the contents of the passed enumerator then enumerates those contents.
|
class |
StringTable
Like a hash table, but built specifically for strings.
|
class |
TaskDaemon
A Daemon thread handler that asynchronously executes Runnable tasks, either at a scheduled time or "as soon as possible".
|
class |
TaskDaemon.PeriodicTask
A PeriodicTask is a task that automatically reschedules itself so that it executes on a periodic basis.
|
class |
ThreadGate
Use this class in cases that large numbers of threads can operate concurrently with an additional requirement that all threads be blocked for certain operations.
|
class |
ThreadLocalObject
This class provides an implementation of thread local storage.
|
class |
Tree
A thread-safe balanced binary search tree.
|
class |
UID
A UID is a 128-bit identifier that is almost guaranteed to be unique.
|
class |
UUID
A UUID is a 256-bit identifier that, if it is generated, is statistically guaranteed to be unique.
|
class |
WrapperConcurrentMap<K,V>
A simple implementation of ConcurrentMap interface built as a wrapper around any Map implementation.
|
protected static class |
WrapperConcurrentMap.Lock
A lock object.
|
class |
WrapperObservableMap<K,V>
A simple implementation of ObservableMap interface built as a wrapper around any Map implementation.
|
protected class |
WrapperObservableMap.InternalListener
An internal MapListener that listens to the wrapped map.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractAggregator<K,V,T,E,R>
Abstract base class implementation of
InvocableMap.EntryAggregator that supports streaming aggregation. |
class |
AbstractBigDecimalAggregator<T>
Abstract aggregator that processes
Number values extracted from a set of entries in a Map and returns a result in a form of a BigDecimal value. |
class |
AbstractComparableAggregator<T,R>
Abstract aggregator that processes values extracted from a set of entries in a Map, with knowledge of how to compare those values.
|
class |
AbstractDoubleAggregator<T>
Abstract aggregator that processes numeric values extracted from a set of entries in a Map.
|
class |
AbstractLongAggregator<T>
Abstract aggregator that processes numeric values extracted from a set of entries in a Map.
|
class |
BigDecimalAverage<T>
Calculates an average for values of any numberic type extracted from a set of entries in a Map in a form of a
BigDecimal value. |
class |
BigDecimalMax<T>
Calculates a maximum of numeric values extracted from a set of entries in a Map in a form of a
BigDecimal value. |
class |
BigDecimalMin<T>
Calculates a minimum of numeric values extracted from a set of entries in a Map in a form of a
BigDecimal value. |
class |
BigDecimalSum<T>
Calculates an sum for values of any numberic type extracted from a set of entries in a Map in a form of a
BigDecimal value. |
class |
ComparableMax<T,R>
Calculates a maximum among values extracted from a set of entries in a Map.
|
class |
ComparableMin<T,R>
Calculates a minimum among values extracted from a set of entries in a Map.
|
class |
CompositeAggregator<K,V>
CompositeAggregator provides an ability to execute a collection of aggregators against the same subset of the entries in an InvocableMap, resulting in a list of corresponding aggregation results.
|
static class |
CompositeAggregator.Parallel
Deprecated.
As of Coherence 12.2.1. Use CompositeAggregator instead.
|
class |
Count<K,V>
Calculates a number of values in an entry set.
|
class |
DistinctValues<K,V,T,E>
Return the set of unique values extracted from a set of entries in a Map.
|
class |
DoubleAverage<T>
Calculates an average for values of any numeric type extracted from a set of entries in a Map.
|
class |
DoubleMax<T>
Calculates a maximum of numeric values extracted from a set of entries in a Map.
|
class |
DoubleMin<T>
Calculates a minimum of numeric values extracted from a set of entries in a Map.
|
class |
DoubleSum<T>
Sums up numeric values extracted from a set of entries in a Map.
|
class |
GroupAggregator<K,V,T,E,R>
The GroupAggregator provides an ability to split a subset of entries in an InvocableMap into a collection of non-intersecting subsets and then aggregate them separately and independently.
|
static class |
GroupAggregator.Parallel<K,V,T,E,R>
Deprecated.
As of Coherence 12.2.1. Use GroupAggregator instead.
|
class |
LongMax<T>
Calculates a maximum of numeric values extracted from a set of entries in a Map.
|
class |
LongMin<T>
Calculates a minimum of numeric values extracted from a set of entries in a Map.
|
class |
LongSum<T>
Sums up numeric values extracted from a set of entries in a Map.
|
class |
PriorityAggregator<K,V,P,R>
PriorityAggregator is used to explicitly control the scheduling priority and timeouts for execution of EntryAggregator-based methods.
|
class |
ReducerAggregator<K,V,T,E>
The ReducerAggregator is used to implement functionality similar to
CacheMap.getAll(Collection) API. |
Modifier and Type | Class and Description |
---|---|
class |
ChainedComparator<T>
Composite comparator implementation based on a collection of comparators.
|
class |
EntryComparator
Comparator implementation used to compare map entries.
|
class |
InverseComparator<T>
Comparator that reverses the result of another comparator.
|
class |
SafeComparator<T>
Null-safe delegating comparator.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractCompositeExtractor<T,E>
Abstract super class for ValueExtractor implementations that are based on an underlying array of ValueExtractor objects.
|
class |
AbstractExtractor<T,E>
Abstract base for ValueExtractor implementations.
|
class |
AbstractUpdater<K,V,U>
Abstract base for ValueUpdater implementations.
|
class |
ChainedExtractor<T,E>
Composite ValueExtractor implementation based on an array of extractors.
|
class |
ComparisonValueExtractor<T,E extends Number>
A synthetic ValueExtractor that returns a result of comparison between two values extracted from the same target.
|
class |
CompositeUpdater
A ValueUpdater implementation based on an extractor-updater pair that could also be used as a ValueManipulator.
|
class |
ConditionalExtractor<T,E>
An IndexAwareExtractor implementation that is only used to create a
ConditionalIndex . |
class |
DeserializationAccelerator
DeserializationAccelerator is an
IndexAwareExtractor implementation that is used to create a ForwardOnlyMapIndex , which in turn is used for deserialization optimization. |
class |
EntryExtractor
The EntryExtractor is a base abstract class for special purpose custom ValueExtractor implementations.
|
class |
IdentityExtractor<T>
Trivial ValueExtractor implementation that does not actually extract anything from the passed value, but returns the value itself.
|
class |
KeyExtractor<T,E>
The KeyExtractor is a special purpose ValueExtractor implementation that serves as an indicator that a query should be run against the key objects rather than the values.
|
class |
MultiExtractor
Composite ValueExtractor implementation based on an array of extractors.
|
class |
PofExtractor<T,E>
POF-based ValueExtractor implementation.
|
class |
PofUpdater
POF-based ValueUpdater implementation.
|
class |
ReflectionExtractor<T,E>
Reflection-based ValueExtractor implementation.
|
class |
ReflectionUpdater
Reflection-based ValueUpdater implementation.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractQueryRecorderFilter<T>
Abstract base class implementation of
QueryRecorderFilter . |
class |
AllFilter
Filter which returns the logical "and" of a filter array.
|
class |
AlwaysFilter<T>
Filter which always evaluates to true.
|
class |
AndFilter
Filter which returns the logical "and" of two other filters.
|
class |
AnyFilter
Filter which returns the logical "or" of a filter array.
|
class |
ArrayFilter
Filter which is a logical operator of a filter array.
|
class |
BetweenFilter<T,E extends Comparable<? super E>>
Filter which compares the result of a method invocation with a value for "Between" condition.
|
class |
CacheEventFilter<T>
An extension of the
MapEventFilter which allows selection of client driven (natural) events, cache internal (synthetic) events, or both. |
class |
ComparisonFilter<T,E,C>
Filter which compares the result of a method invocation with a value.
|
class |
ContainsAllFilter<T,E>
Filter which tests a
Collection or Object array value returned from a method invocation for containment of all values in a Set. |
class |
ContainsAnyFilter<T,E>
Filter which tests a
Collection or Object array value returned from a method invocation for containment of any value in a Set. |
class |
ContainsFilter<T,E>
Filter which tests a
Collection or Object array value returned from a method invocation for containment of a given value. |
class |
EqualsFilter<T,E>
Filter which compares the result of a method invocation with a value for equality.
|
class |
ExtractorFilter<T,E>
Base Filter implementation for doing extractor-based processing.
|
class |
FilterTrigger
A generic Filter-based MapTrigger implementation.
|
class |
GreaterEqualsFilter<T,E extends Comparable<? super E>>
Filter which compares the result of a method invocation with a value for "Greater or Equal" condition.
|
class |
GreaterFilter<T,E extends Comparable<? super E>>
Filter which compares the result of a method invocation with a value for "Greater" condition.
|
class |
InFilter<T,E>
Filter which checks whether the result of a method invocation belongs to a predefined set of values.
|
class |
InKeySetFilter<T>
Filter that limits the underlying filter evaluation only to the specified set of keys.
|
class |
IsNotNullFilter<T,E>
Filter which tests the result of a method invocation for inequality to null.
|
class |
IsNullFilter<T,E>
Filter which compares the result of a method invocation with null.
|
class |
KeyAssociatedFilter<T>
Filter which limits the scope of another filter according to the key association information.
|
class |
KeyFilter<T>
EntryFilter which checks whether an entry key belongs to a set.
|
class |
LessEqualsFilter<T,E extends Comparable<? super E>>
Filter which compares the result of a method invocation with a value for "Less or Equals" condition.
|
class |
LessFilter<T,E extends Comparable<? super E>>
Filter which compares the result of a method invocation with a value for "Less" condition.
|
class |
LikeFilter<T,E>
Filter which compares the result of a method invocation with a value for pattern match.
|
class |
LimitFilter<T>
Filter which truncates the results of another filter.
|
class |
MapEventFilter<T>
Filter which evaluates the content of a MapEvent object according to the specified criteria.
|
class |
MapEventTransformerFilter<T>
MapEventTransformerFilter is a generic multiplexing wrapper that combines two implementations: a Filter (most commonly a
MapEventFilter ) and a MapEventTransformer and is used to register event listeners that allow to change the content of a MapEvent. |
class |
NeverFilter<T>
Filter which always evaluates to false.
|
class |
NotEqualsFilter<T,E>
Filter which compares the result of a method invocation with a value for inequality.
|
class |
NotFilter<T>
Filter which negates the results of another filter.
|
class |
OrFilter
Filter which returns the logical "or" of two other filters.
|
class |
PartitionedFilter<T>
Filter which limits the scope of another filter to those entries that have keys that belong to the specified partition set.
|
class |
PredicateFilter<T,E>
A
java.util.function.Predicate based ExtractorFilter . |
class |
PresentFilter<T>
Filter which returns true for
InvocableMap.Entry objects that currently exist in a Map. |
class |
PriorityFilter<T>
PriorityFilter is used to explicitly control the scheduling priority and timeouts for execution of filter-based methods.
|
class |
RegexFilter<T,E>
Filter which uses the regular expression pattern match defined by the
String.matches(String) contract. |
class |
WrapperQueryRecorderFilter<T>
QueryRecorderFilter wrapper class.
|
class |
XorFilter
Filter which returns the logical exclusive or ("xor") of two other filters.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractProcessor<K,V,R>
An AbstractProcessor is a partial EntryProcessor implementation that provides the default implementation of the
AbstractProcessor.processAll(java.util.Set<? extends com.tangosol.util.InvocableMap.Entry<K, V>>) method. |
class |
CompositeProcessor<K,V>
The CompositeProcessor represents a collection of entry processors that are invoked sequentially against the same Entry.
|
class |
ConditionalProcessor<K,V,T>
Conditional entry processor represents a processor that is invoked conditionally based on the result of an entry evaluation.
|
class |
ConditionalPut<K,V>
ConditionalPut is an EntryProcessor that performs an
Entry.setValue operation if the specified condition is satisfied. |
class |
ConditionalPutAll<K,V>
ConditionalPutAll is an EntryProcessor that performs a
Entry.setValue operation for multiple entries that satisfy the specified condition. |
class |
ConditionalRemove<K,V>
ConditionalRemove is an EntryProcessor that performs an
Entry.remove operation if the specified condition is satisfied. |
class |
ExtractorProcessor<K,V,T,E>
ExtractorProcessor is an EntryProcessor implementations that extracts a value from an object cached in an InvocableMap.
|
class |
NumberIncrementor<K,V,N extends Number>
The NumberIncrementor entry processor is used to increment a property value of a
Number type. |
class |
NumberMultiplier<K,V,N extends Number>
The NumberMultiplier entry processor is used to multiply a property value of a
Number type. |
class |
PreloadRequest<K,V>
PreloadRequest is a simple EntryProcessor that performs a
Entry.getValue call. |
class |
PriorityProcessor<K,V,T>
PriorityProcessor is used to explicitly control the scheduling priority and timeouts for execution of EntryProcessor-based methods.
|
class |
PropertyManipulator<V,R>
PropertyManipulator is a reflection based ValueManipulator implementation based on the JavaBean property name conventions.
|
class |
PropertyProcessor<K,V,R>
PropertyProcessor is a base class for EntryProcessor implementations that depend on a ValueManipulator.
|
class |
UpdaterProcessor<K,V,T>
UpdaterProcessor is an EntryProcessor implementations that updates an attribute of an object cached in an InvocableMap.
|
class |
VersionedPut<K,V extends Versionable>
VersionedPut is an EntryProcessor that assumes that entry values implement
Versionable interface and performs an Entry.setValue operation if and only if the version of the specified value matches to the version of the current value. |
class |
VersionedPutAll<K,V extends Versionable>
VersionedPutAll is an EntryProcessor that assumes that entry values implement
Versionable interface and performs an Entry.setValue operation only for entries whose versions match to versions of the corresponding current values. |
Modifier and Type | Class and Description |
---|---|
class |
ExtractorEventTransformer<K,V,E>
ExtractorEventTransformer is a special purpose
MapEventTransformer implementation that transforms emitted events, extracting one or more properties from either the OldValue or the NewValue. |
class |
SamplingEventTransformer<K,V>
A
MapEventTransformer implementation which will send at most one event per storage member per sampling interval, in order to throttle down the number of events received by the slow consumer. |
class |
SemiLiteEventTransformer<K,V>
SemiLiteEventTransformer is a special purpose MapEventTransformer implementation that removes an OldValue from the MapEvent object for the purpose of reducing the amount of data that has to be sent over the network to event consumers.
|