All Classes

Class	Description
AbstractAggregator<K,V,T,E,R>	Abstract base class implementation of InvocableMap.EntryAggregator that supports streaming aggregation.
AbstractAsynchronousAggregator<K,V,P,R>	Abstract base class for asynchronous entry aggregators.
AbstractAsynchronousProcessor<K,V,R,T>	Abstract base class for asynchronous entry processors.
AbstractAsyncRepository<ID,T>	Abstract base class for asynchronous Coherence repository implementations.
AbstractBackingMapManager	Abstract base of the BackingMapManager implementations.
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.
AbstractBinaryEntryBundler	An abstract BinaryEntry-based bundler that serves as a base for BinaryEntryStore operation bundling.
AbstractBinaryStore	Abstract implementation of the BinaryStore interface.
AbstractBufferManager	Provides a basic implementation of ByteBufferManager.
AbstractBundler	An abstract base for processors that implement bundling strategy.
AbstractBundler.Statistics	Statistics class contains the latest bundler statistics.
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
AbstractByteSequence	A simple base class for ByteSequence implementations.
AbstractByteSequence.AggregateByteSequence	A naive ByteSequence that glues two ByteSequence instances together.
AbstractByteSequence.PartialByteSequence	A naive ByteSequence that represents a portion of another ByteSequence.
AbstractCacheInterceptor	Abstract base class for caching CDI interceptors.
AbstractCacheLoader<K,V>	An abstract base class for the JCache CacheLoader.
AbstractCacheStore<K,V>	An abstract base class for the JCache CacheLoader.
AbstractCachingScheme<D extends ServiceDependencies>	An AbstractCachingScheme is a base implementation for an CachingScheme.
AbstractCertificateLoader	A base class for CertificateLoader implementations.
AbstractCoherenceBasedCache<K,V,C extends CoherenceBasedConfiguration<K,V>>	The base implementation of a CoherenceBasedCache.
AbstractCoherenceBasedCompleteConfiguration<K,V>	A base implementation of a CoherenceBasedCompleteConfiguration.
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.
AbstractCompositeExtractor<T,E>	Abstract super class for ValueExtractor implementations that are based on an underlying array of ValueExtractor objects.
AbstractCompositeScheme<T>	The AbstractCompositeScheme manages a scheme that is used to build a composite cache consisting of a front map and a back cache/map.
AbstractDoubleAggregator<T>	Abstract aggregator that processes numeric values extracted from a set of entries in a Map.
AbstractEmptyElementProcessor<T>	A ConditionalElementProcessor that provides defined behaviors for processing empty XmlElements.
AbstractEmptyElementProcessor.EmptyElementBehavior	The behavior of the ConditionalElementProcessor when it encounters an empty XmlElement.
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.
AbstractEvolvable	An abstract base class for implementing Evolvable objects.
AbstractEvolvableProcessor<K,V,R>	An Evolvable AbstractProcessor that is a partial EntryProcessor implementation that provides the default implementation of the AbstractEvolvableProcessor.processAll(java.util.Set<? extends com.tangosol.util.InvocableMap.Entry<K, V>>) method.
AbstractExtractor<T,E>	Abstract base for ValueExtractor implementations.
AbstractInvocable	An abstract base for Invocable and PriorityTask implementations.
AbstractJCacheStatistics	Shared implementation between implementations of JCacheStatistics.
AbstractJournalScheme<T>	The AbstractJournalScheme contains functionality common to all Journal schemes.
AbstractKeyBasedMap<K,V>	AbstractKeyBasedMap is a base class for Map implementations.
AbstractKeyBasedMap.DeferredCacheEvent<K,V>	A DeferredCacheEvent is a CacheEvent object that defers the loading of the old value.
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.
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.
AbstractKeyStoreLoader	A base class for KeyStoreLoader implementations.
AbstractLocalCachingScheme<T>	The AbstractLocalCachingScheme is provides common functionality for local caching schemes, including local-scheme, external-scheme, etc.
AbstractLongAggregator<T>	Abstract aggregator that processes numeric values extracted from a set of entries in a Map.
AbstractLongArray<V>	An implementation of portions of the LongArray interface.
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.
AbstractMarshaller<T>	Abstract base class for built-in marshallers.
AbstractNamespaceHandler	An AbstractNamespaceHandler provides a base implementation of a NamespaceHandler with support for implicit and explicit registration of ElementProcessors and AttributeProcessors for those xml attributes and elements occurring in the associated xml namespace.
AbstractNioManagerBuilder<T>	The AbstractNioManagerBuilder class is an abstract class used to build an NIO file manager or an NIO memory manager.
AbstractPartitionedIterator<T>	Abstract base class for partitioned iterators.
AbstractPersistenceEnvironment	Abstract implementation of a ReadBuffer-based PersistentEnvironment.
AbstractPersistenceEnvironment.DefaultFailureContinuation	Continuation implementation that accepts a Throwable and throws a PersistenceException.
AbstractPersistenceManager<PS extends AbstractPersistenceManager.AbstractPersistentStore>	Abstract implementation of a ReadBuffer-based PersistentManager.
AbstractPersistenceManager.BatchTasks	A collection of tasks to execute in a loop.
AbstractPersistenceTools	Abstract implementation of PersistenceTools which can be extended for either local or archived snapshot operations.
AbstractPersistenceTools.StatsVisitor	An implementation of a CachePersistenceHelper.Visitor to collect details statistics from the snapshot we are analysing.
AbstractPofHandler	An abstract implementation of PofHandler that delegates to a PofHandler.
AbstractPofPath	Abstract base class for static, path-based implementations of PofNavigator interface.
AbstractPofValue	An abstract base class that implements common functionality for all PofValue types.
AbstractPriorityTask	An abstract base for PriorityTask implementations.
AbstractPrivateKeyLoader	A base class for PrivateKeyLoader implementations.
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.
AbstractQueryEngine	Abstract base class for QueryEngine implementations.
AbstractQueryEngine.ParsedQuery	Immutable helper class that wraps both final query string and a map of parameter types, keyed by parameter name.
AbstractQueryPlusStatementBuilder	This is the base class for command builders that are specific to the QueryPlus tool rather than general CohQL statements.
AbstractQueryRecorderFilter<T>	Abstract base class implementation of QueryRecorderFilter.
AbstractReadBuffer	Abstract base implementation of the ReadBuffer interface.
AbstractRepository<ID,T>	Abstract base class for Coherence repository implementations.
AbstractRepositoryBase<ID,T,M>	Base functionality for all Coherence repository implementations.
AbstractRepositoryBase.Listener<T>	An interface that should be implemented by the clients interested in repository events.
AbstractRepositoryBase.Listener.Builder<T>	A builder for a simple, lambda-based AbstractRepositoryBase.Listener.
AbstractRepositoryBase.MapListenerAdapter<ID,T>	Adapter from AbstractRepositoryBase.Listener to MapListener that can be registered with the backing NamedMap.
AbstractSafeLongArray<V>	An abstract base class for thread-safe LongArrays which are protected by lock(s).
AbstractScheme	The AbstractScheme is the base implementation of a Scheme.
AbstractScript	AbstractScriptBase is the base class for script based processing.
AbstractSerializationCache	An abstract base class for serialization-based caches.
AbstractServiceLoadBalancer<S extends Service,T extends ServiceLoad>	An abstract base for ServiceLoadBalancer implementations.
AbstractServiceScheme<D extends ServiceDependencies>	The AbstractServiceScheme provides functionality common to all schemes that use services.
AbstractSnapshotArchiver	An abstract implementation of a SnapshotArchiver which must be extended to create a specific implementation.
AbstractSnapshotStatement	Abstract implementation of an AbstractStatement providing functionality useful for generic snapshot statements.
AbstractSparseArray<V>	A data structure resembling an array indexed by long values, stored as an AVL tree.
AbstractSparseArray.Node<V>	An AVL tree node.
AbstractSQLSnapshotOPToken	An abstract implementation of a snapshot operation which can be extended to support different persistence operations.
AbstractStableIterator	Deprecated. As of Coherence 12.1.2, replaced by AbstractStableIterator
AbstractStatement	A base class for Statement implementations.
AbstractStatementBuilder<T extends Statement>	A base class for StatementBuilder implementations.
AbstractStoreManager	A base implementation of BinaryStoreManager interface that uses BinaryMap objects built on a ByteBufferManager to provide BinaryStore objects.
AbstractStoreManagerBuilder<T>	The AbstractStoreManagerBuilder class builds an instance of a BinaryStoreManager.
AbstractUpdater<K,V,U>	Abstract base for ValueUpdater implementations.
AbstractWriteBuffer	The AbstractWriteBuffer is a partial implementation of the WriteBuffer interface intended to be used as a base class for easily creating concrete WriteBuffer implementations.
Accelerated	Repository implementations annotated with this class will keep deserialized entities in memory, in addition to a serialized binary form, of all entities in the repository.
AcceptorDependenciesProcessor	An ElementProcessor that will parse an <acceptor-config> and produce an AcceptorDependencies.
AccessController	The AccessController interface is used by the cluster services to verify whether or not a caller has sufficient rights to access protected clustered resources.
Action	An Action represents a controllable action or behavior that a Service might perform.
ActionPolicy	ActionPolicy defines which aspects of a Service's behavior are currently allowed.
ActionPolicyBuilder	The abstract ActionPolicyBuilder is a base class builder for building ActionPolicy's instances and defers cache configuration validation until the instance is realized.
ActionPolicyBuilder.ActionPolicyParameterizedBuilder	ActionPolicyBuilder wrapper for a ParameterizedBuilder.
ActionPolicyBuilder.NullImplementationBuilder	ActionPolicy Null Implementation
ActionPolicyBuilder.QuorumRule	Intermediate QuorumRule with enough information to report a ConfigurationException at instantiation time.
Activated	A qualifier annotation used for any ACTIVATED event.
Activated.Literal	An annotation literal for the Activated annotation.
Activating	A qualifier annotation used for any ACTIVATING event.
Activating.Literal	An annotation literal for the Activating annotation.
AdditionOperator	A BaseOperator implementation representing the addition (+) operator.
AddressProvider	The AddressProvider is a subclass interface of SocketAddressProvider which returns InetSocketAddress from AddressProvider.getNextAddress().
AddressProviderBuilder	AddressProviderBuilder interface
AddressProviderBuilderProcessor	An ElementProcessor that will parse and produce a ParameterizedBuilder<AddressProvider> based on an address-provider configuration element, that of which is defined as such (with support for foreign-namespaces)
AddressProviderFactory	A factory for AddressProvider objects.
AggregatorConfig	The AggregatorConfig class encapsulates information related to a Coherence REST EntryAggregator configuration.
AggregatorFactory<K,V,R>	A factory for aggregators.
AggregatorRegistry	A registry for AggregatorFactory instances.
Aggregators	Simple Aggregator DSL.
AllFilter	Filter which returns the logical "and" of a filter array.
AlwaysFilter	A FilterBinding annotation representing an AlwaysFilter.
AlwaysFilter<T>	Filter which always evaluates to true.
AlwaysFilter.Literal	An annotation literal for the AlwaysFilter annotation.
AndFilter	Filter which returns the logical "and" of two other filters.
AndOperator	An operator representing a logical AND (&&).
AnnotatedMapListener<K,V>	MapListener implementation that dispatches MapEvents to a CDI observer.
AnnotatedMapListener.FilterProducer	A producer of Filter instances.
AnnotatedMapListener.MapEventObserver<K,V>
AnnotatedMapListener.MapEventTransformerProducer	A producer of MapEventTransformer instances.
AnnotatedMapListenerManager	Registers discovered CDI observer-based MapListeners when the cache is created, and unregisters them when it's destroyed.
AnnotatedStandardEmitterMBean	AnnotatedStandardEmitterMBean is an extension of a StandardEmitterMBean that uses the Description and Notification annotations to describe the MBean and any attributes, operations and notifications it declares.
AnnotatedStandardEmitterMBean.SilentEmitter	A silent NotificationEmitter implementation for all NotificationEmitter methods except getNotificationInfo().
AnnotatedStandardMBean	AnnotatedStandardMBean is an extension of a StandardMBean that uses the Description annotation for describing the attributes, operations and the bean on the designated MBean interface.
AnnotationDrivenModel<S extends Enum<S>>	An AnnotationDrivenModel is a Model created through extracting information defined by Transitions annotation.
AnnotationInstance	A representation of an Annotation that can be used for equality tests where methods in the Annotation annotated with Nonbinding are ignored.
AnnotationLiteral<T extends Annotation>	Supports inline instantiation of annotation type instances.
AnyEvent	An AnyEvent is an event used when no specific event implementation fits and it is not worth making one.
AnyFilter	Filter which returns the logical "or" of a filter array.
AnyListener	An AnyEvent is an event used when no specific event implementation fits and it is not worth making one.
ArchiverHelper	Deprecated. this API is intended for internal purposes only and will be removed in a future version of Coherence
ArchiverHelper.DirectoryFileFilter	FileFilter implementation that only includes directories.
ArchiveSnapshotStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a ArchiveSnapshotStatementBuilder.ArchiveSnapshotStatement.
ArchiveSnapshotStatementBuilder.ArchiveSnapshotStatement	Implementation of the CohQL "ARCHIVE SNAPSHOT" command.
ArrayAdapter	An ArrayAdapter supports properties of Java array types (not including arrays of primitive types).
ArrayFilter	Filter which is a logical operator of a filter array.
ArrayFilter.WeightedFilter	A thin wrapper around a Filter allowing for sorting the filters according to their effectiveness.
Arrived	A qualifier annotation used for any ARRIVED event.
Arrived.Literal	An annotation literal for the Arrived annotation.
AssertionException	An AssertionException is thrown when an assertion fails.
Assertions	Class for providing assertion functionality.
Assigned	A qualifier annotation used for any ASSIGNED event.
Assigned.Literal	An annotation literal for the Assigned annotation.
Associated<T>	The Associated interface facilitates the creation of a very generic equivalence relation between different objects and allows to group them based on the equality of the "association key" object returned by the Associated.getAssociatedKey() method.
Associator	The Associator interface facilitates the creation of a very generic equivalence relation between different objects and allows to group them based on the equality of the "association key" object returned by the Associator.getAssociatedKey(java.lang.Object) method.
AsyncAtomicBoolean	A boolean value that may be updated atomically.
AsyncAtomicInteger	A int value that may be updated atomically.
AsyncAtomicLong	A long value that may be updated atomically.
AsyncAtomicMarkableReference<V>	An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.
AsyncAtomicReference<V>	An object reference that may be updated atomically.
AsyncAtomicStampedReference<V>	An AtomicStampedReference maintains an object reference along with an integer "stamp", that can be updated atomically.
AsyncBackupProcessor	An ElementProcessor for an <async-backup> Configuration.
AsyncBinaryStore	An AsyncBinaryStore is a BinaryStore wrapper that performs the "O" (output) portion of its I/O asynchronously on a daemon thread.
AsyncBinaryStoreManager	An AsyncBinaryStoreManager is a wrapper BinaryStoreManager that creates wrapper AsyncBinaryStore objects.
AsynchronousAgent<T>	Base class for asynchronous operations that provides a simple implementation of the Future interface.
AsynchronousAggregator<K,V,P,R>	A marker EntryAggregator wrapper class that allows for an asynchronous invocation of the underlying aggregator.
AsynchronousProcessor<K,V,R>	An EntryProcessor wrapper class that allows for an asynchronous invocation of the underlying processor.
AsyncLocalAtomicBoolean	Local implementation of AsyncAtomicBoolean interface, that simply wraps java.util.concurrent.atomic.AtomicBoolean instance and returns an already completed future from each method.
AsyncLocalAtomicInteger	Local implementation of AsyncAtomicInteger interface, that simply wraps java.util.concurrent.atomic.AtomicInteger instance and returns an already completed future from each method.
AsyncLocalAtomicLong	Local implementation of AsyncAtomicLong interface, that simply wraps java.util.concurrent.atomic.AtomicLong instance and returns an already completed future from each method.
AsyncLocalAtomicMarkableReference<V>	Local implementation of AsyncAtomicMarkableReference interface, that simply wraps java.util.concurrent.atomic.AtomicMarkableReference instance and returns an already completed future from each method.
AsyncLocalAtomicReference<V>	Local implementation of AsyncAtomicReference interface, that simply wraps java.util.concurrent.atomic.AtomicReference instance and returns an already completed future from each method.
AsyncLocalAtomicStampedReference<V>	Local implementation of AsyncAtomicStampedReference interface, that simply wraps java.util.concurrent.atomic.AtomicStampedReference instance and returns an already completed future from each method.
AsyncNamedCache<K,V>	Asynchronous NamedCache.
AsyncNamedMap<K,V>	Asynchronous NamedMap.
AsyncNamedMap.Complete	An AsyncNamedMap.Option to use to specify the Executor to use to complete the CompletableFuture returned from async methods.
AsyncNamedMap.Option	An immutable option for creating and configuring AsyncNamedMaps.
AsyncNamedMap.OrderBy	A configuration option which determines the ordering of async operations.
AsyncRemoteAtomicBoolean	The remote implementation of AsyncAtomicBoolean, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicInteger	The remote implementation of AsyncAtomicInteger, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicLong	The remote implementation of AsyncAtomicLong, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicMarkableReference<V>	The remote implementation of AsyncAtomicMarkableReference, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicReference<V>	The remote implementation of AsyncAtomicReference, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicStampedReference<V>	The remote implementation of AsyncAtomicStampedReference, backed by a Coherence NamedMap entry.
AsyncStoreManagerBuilder	The AsyncStoreManagerBuilder class builds and instance of an AsyncBinaryStoreManager.
AtomicBoolean	A boolean value that may be updated atomically.
AtomicBoolean.Serializer	POF serializer implementation.
AtomicInteger	An int value that may be updated atomically.
AtomicInteger.Serializer	POF serializer implementation.
AtomicLong	A long value that may be updated atomically.
AtomicLong.Serializer	POF serializer implementation.
AtomicMarkableReference<V>	An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.
AtomicMarkableReference.Serializer<V>	POF serializer implementation.
AtomicReference<V>	An object reference that may be updated atomically.
AtomicReference.Serializer<V>	POF serializer implementation.
Atomics	Factory methods for various atomic value implementations.
Atomics.SerializableAtomicMarkableReference<V>	Extension to AtomicMarkableReference to allow Java serialization.
Atomics.SerializableAtomicStampedReference<V>	Extension to AtomicStampedReference to allow Java serialization.
AtomicStampedReference<V>	An AtomicStampedReference maintains an object reference along with an integer "stamp", that can be updated atomically.
AtomicStampedReference.Serializer<V>	POF serializer implementation.
AtomicTerm	AtomicTerms is the class used to represent literal Terms such as String and Numbers.
AttributeProcessor<T>	An AttributeProcessor is responsible for processing XmlAttribute content to return a strongly-typed value.
AuditingAuthorizer	Simple StorageAccessAuthorizer implementation that logs the authorization requests and allows operations to proceed.
AuthorizedHostsProcessor	An ElementProcessor for <authorized-hosts> Configuration Elements.
Authorizer	This interface represents an environment-specific facility for authorizing callers to perform actions described by the corresponding permission objects.
BackingMapBinaryEntry	An implementation of the BinaryEntry interface that is based on specified binary key, binary value and BackingMapManagerContext.
BackingMapContext	The BackingMapContext provides an execution context to server side agents such as EntryProcessors and EntryAggregators.
BackingMapManager	A callback interface used by CacheService implementations.
BackingMapManagerBuilder	A BackingMapManagerBuilder realizes BackingMapManagers.
BackingMapManagerContext	The BackingMapManager context is used by the CacheService to pass information to the BackingMapManager during the service initialization.
BackingMapScheme	The BackingMapScheme class is responsible for building a fully configured instance of a backing map.
BackingMapSchemeProcessor	A BackingMapSchemeProcessor is responsible for processing a backing-map-scheme XmlElement to produce a BackingMapScheme.
Backlog	A qualifier annotation used for any BACKLOG event.
Backlog.Literal	An annotation literal for the Backlog annotation.
Backlog.Type	The backlog event type.
BackupMapConfig	The BackupMapConfig interface exposes the configuration needed to create an instance of a backup map, which is used by the distributed cache to store backup data.
BackupStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a BackupStatementBuilder.BackupStatement.
BackupStatementBuilder.BackupStatement	Implementation of the CohQL "BACKUP" command.
Base	Base class for providing standard functionality.
Base.LoggingWriter	Inner class for over-riding the destination of log(), out() and err() calls.
Base64InputStream	Reads binary data from a Reader using IETF RFC 2045 Base64 Content Transfer Encoding.
Base64OutputStream	Writes binary data into a Writer using IETF RFC 2045 Base64 Content Transfer Encoding.
BaseGrpcCacheScheme<S extends Service>	The BaseGrpcCacheScheme is responsible for building a remote gRPC cache service.
BaseGrpcScheme<T extends com.tangosol.internal.net.grpc.DefaultRemoteGrpcServiceDependencies,S extends Service>	The BaseGrpcScheme is responsible for building a remote gRPC service.
BaseGrpcServiceImpl	A base class for gRPC services.
BaseGrpcServiceImpl.DefaultDependencies	The default BaseGrpcServiceImpl.Dependencies implementation.
BaseGrpcServiceImpl.Dependencies	The dependencies to configure a BaseGrpcServiceImpl.
BaseOperator<F extends Filter>	A base class for CohQL Operator implementations.
BaseRemoteStream<T,S extends BaseStream<T,S>>	An extension of BaseStream that adds support for the RemotePipeline retrieval.
BaseToken	BaseToken is the abstract base class for all tokens processed by the low level BaseTokenScanner.
BaseTokenScanner	BaseTokenScanner gives clients a streaming api that returns a next BaseToken by processing either a java.lang.String or a java.io.Reader.
BaseTokenScannerException	BaseTokenScannerExpression is the RuntimeException thrown by the BaseTokenScanner when expectations are not met.
BaseTokenStream	Since BaseTokens can nest, BaseTokenStream creates for clients a utility interface that allows streaming (atEnd(), next()) over a CompoundBaseToken.
BdbStoreManagerBuilder	The BdbStoreManagerBuilder class builds an instance of a BerkeleyDBBinaryStoreManager.
BeanBuilder	Element processor for <cdi:bean> XML element.
BeanProcessor	Element processor for <cdi:bean/> XML element.
BerkeleyDBBinaryStore	An implementation of the BinaryStore interface using Sleepycat Berkeley DB Java Edition.
BerkeleyDBBinaryStoreManager	An implementation of the BinaryStoreManager interface using Sleepycat Berkeley DB Java Edition.
BetweenFilter<T,E extends Comparable<? super E>>	Filter which compares the result of a method invocation with a value for "Between" condition.
BetweenOperator	An operator representing the "between" conditional operator.
BetweenOPToken	BetweenOPToken is used to parse a SQl like between statment.
BigDecimalAverage<T>	Calculates an average for values of any numeric type extracted from a set of entries in a Map in a form of a BigDecimal value.
BigDecimalMax<T>	Calculates a maximum of numeric values extracted from a set of entries in a Map in a form of a BigDecimal value.
BigDecimalMin<T>	Calculates a minimum of numeric values extracted from a set of entries in a Map in a form of a BigDecimal value.
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.
Binary	A thread-safe immutable binary object.
BinaryDeltaCompressor	A DeltaCompressor implementation that works with opaque (binary) values.
BinaryElementCalculator	A NamedTopic.ElementCalculator that calculates size of an element based on the size of the serialized binary value.
BinaryEntry<K,V>	Map.Entry that internally stores both key and value in a Binary format and uses an underlying Serializer to convert it to and from an Object view.
BinaryEntryStore<K,V>	BinaryEntryStore is analogous to the CacheStore, but operates on BinaryEntry objects.
BinaryHelper	A helper class of methods to convert between Binary instances and proto-buffer byte values.
BinaryMap	Implements the Map interface to store Binary objects using Java's NIO buffers.
BinaryMap.Entry	A map entry (key-value pair).
BinaryMapStore	An implementation of BinaryStore backed by a BinaryMap.
BinaryMarshaller	A pass-through marshaller that simply converts HTTP entities into a Binary and vice versa.
BinaryMemoryCalculator	A UnitCalculator implementation that weighs a cache entry based upon the amount of physical memory (in bytes) required to store the entry.
BinaryStore	A simple mapping of CacheStore operations for Binary objects into a Java interface.
BinaryStore.KeySetAware	If a BinaryStore is aware of which keys that it stores, then it should implement this optional interface in order to allow that information to be efficiently communicated to an intelligent consumer of the BinaryStore interface.
BinaryStore.SizeAware	If a BinaryStore is aware of the number of keys that it stores, then it should implement this optional interface in order to allow that information to be efficiently communicated to an intelligent consumer of the BinaryStore interface.
BinaryStoreCacheStore<K,V>	A CacheStore that sits directly on top of a BinaryStore.
BinaryStoreManager	A manager that is capable of creating and destroying BinaryStore objects.
BinaryStoreManagerBuilder	A BinaryStoreManagerBuilder is responsible for realizing BinaryStoreManagers.
BinaryStoreManagerBuilderCustomization	A BinaryStoreManagerBuilderCustomization class is one that allows or potentially requires, a BinaryStoreManagerBuilder for the purposes of realizing a BinaryStoreManager.
BinaryWriteBuffer	a WriteBuffer implementation whose primary purpose is to be used to create Binary objects.
BindableGrpcProxyService	An interface implemented by bindable gRPC proxy services.
BitHelper	A collection of methods for bit-based operations.
Blocking	Blocking provides a set of helper methods related to blocking a thread.
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.
BufferTypeProcessor	An ElementProcessor for the <buffer-type> Cache Configuration element.
Builder<T>	A Builder provides a mechanism for realizing a specific class of object as required.
BuilderCustomization<T>	A class that implements BuilderCustomization is one that allows an alternate builder, as a ParameterizedBuilder, to be provided so that the said class may use it for realizing objects.
BuilderHelper	Provides a collection of helper methods for working with Builders.
BundleManager	The BundleManager class is responsible for configuring caches to use bundling.
BundleManager.BundleConfig	The BundleConfig class contains the configuration for a Bundle.
BundlingNamedCache	Bundling NamedCache implementation.
BundlingScheme	BundlingSchemes define how the bundling (batching) of operations will occur and the BundleManager used to configure said bundling.
ByteArrayReadBuffer	A ReadBuffer on top of a byte array.
ByteArrayWriteBuffer	ByteArrayWriteBuffer is an implementation of WriteBuffer on a byte array.
ByteArrayWriteBuffer.Allocator	Allocator is a WriteBufferPool implementation which allocates a new ByteArrayWriteBuffer on each request to the pool, and does not retain the returned buffer.
ByteBufferInputStream	An InputStream implementation on top of a Java NIO ByteBuffer.
ByteBufferManager	An interface for managing a ByteBuffer.
ByteBufferOutputStream	An OutputStream implementation on top of a Java NIO ByteBuffer.
ByteBufferReadBuffer	A ReadBuffer implementation on top of a Java NIO ByteBuffer.
ByteBufferWriteBuffer	A WriteBuffer implementation on top of a Java NIO ByteBuffer.
Bytes	Bytes is a specialized MemorySize whose default constructor assumes that the specified units (when a magnitude is not specified) are always bytes.
ByteSequence	Represents a sequence of bytes.
CacheAdd	Never get the value from cache, get it from method and cache the result.
CacheAdd.Literal	An annotation literal for the CacheAdd annotation.
CacheAddInterceptor	A CDI interceptor that always invokes target method and then caches invocation result before returning it.
CacheCollator	Implements a collator which caches its keys.
CacheConfig	A CacheConfig is the top-level container for Coherence Cache Configuration, that of which is used at runtime to establish caches and services.
CacheConfigNamespaceHandler	The CacheConfigNamespaceHandler is responsible for capturing and creating Coherence Cache Configurations when processing a Coherence Configuration file.
CacheConfigNamespaceHandler.Extension	A class that can add extensions to the CacheConfigNamespaceHandler.
CacheConfigOverrideProcessor	Implementation of OverrideProcessor that process cache configuration override file.
CacheDefaultsPreprocessor	A CacheDefaultsPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that introduces (via cloning) default xml content for xml elements where the said content is missing.
CacheEvent<K,V>	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.
CacheEventFilter<K,V>	An extension of the MapEventFilter which allows selection of client driven (natural) events, cache internal (synthetic) events, or both.
CacheFactory	Factory for the Coherence™ cache product.
CacheFactoryBuilder	CacheFactoryBuilder provides the means for building and managing configurable cache factories across class loaders in a pluggable fashion.
CacheGet	Get the value from cache if present, invoke the method and cache the result otherwise.
CacheGet.Literal	An annotation literal for the CacheGet annotation.
CacheGetInterceptor	A CDI interceptor that returns cached value if present; otherwise it returns and caches result of target method invocation.
CacheKey	Parameters annotated with this annotation are considered part of the key.
CacheLifecycleEvent	A CacheLifecycleEvent allows subscribers to capture events pertaining to the lifecycle of a cache.
CacheLifecycleEvent.Type	The emitted event types for a CacheLifecycleEvent.
CacheLifecycleEventDispatcher	A CacheLifecycleEventDispatcher raises CacheLifecycleEvents.
CacheLifecycleEvents	CacheLifecycleEvents is an annotation that should be applied to EventInterceptor implementations that want to receive CacheLifecycleEvents.
CacheLoader<K,V>	A JCache CacheLoader.
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.
CacheMap<K,V>	A CacheMap is a Map that supports caching.
CacheMapping	A CacheMapping captures configuration information for a pattern-match-based mapping from a proposed NamedCache name to a caching scheme.
CacheMappingProcessor	An CacheMappingProcessor is responsible for processing <cache-mapping> XmlElements to produce a CacheMapping.
CacheMappingRegistry	Deprecated. As Coherence 14.1.1, use ResourceMappingRegistry.
CacheName	A qualifier annotation used to indicate a specific cache name.
CacheName.Literal	An annotation literal for the CacheName annotation.
CachePersistenceHelper	Static helper methods used in the persistence of a partitioned cache.
CachePersistenceHelper.Visitor	The Visitor interface allows the "iteration" of the persisted contents (and metadata) of a cache service in the style of the Visitor Pattern.
CacheProvider	Deprecated.
CachePut	Put a value to cache AND call the method.
CachePut.Literal	An annotation literal for the CachePut annotation.
CachePutInterceptor	A CDI interceptor that stores parameter value in the Coherence cache.
CacheRemove	Remove the value from the cache and call the method.
CacheRemove.Literal	An annotation literal for the CacheRemove annotation.
CacheRemoveInterceptor	A CDI interceptor that removes value from the cache and invokes target method.
CacheRequestHolder<Req,Res>	A class that holds a gRPC request, an associated NamedCache and Binary converters.
CacheResource	RESTful wrapper around a Coherence NamedCache.
CacheService	A CacheService is a clustered service providing a collection of named Maps that hold resources shared among members of a cluster.
CacheService.CacheAction	CacheAction represents a type of action taken by a CacheService.
CacheServiceProxyProcessor	An ElementProcessor that will parse cache-service-proxy configuration element tp produce a DefaultCacheServiceProxyDependencies object.
CacheStatistics	An interface for exposing Cache statistics.
CacheStore<K,V>	A JCache cache store.
CacheStoreMap	A backing Map implementation that delegates all operations to a CacheStore.
CacheStoreMap.ReadWriteMap	A Map implementation that delegates straight through to a CacheStore.
CacheStoreScheme	The CacheStoreScheme class is responsible for building a fully configured instance of a CacheStore, CacheLoader or remote NamedCache.
CacheValue	Marks a parameter as the cache value.
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.
CachingScheme	The CachingScheme is a multi-builder for cache-based infrastructure.
CachingSchemeMappingProcessor	An CachingSchemeMappingProcessor is responsible for processing <caching-scheme-mapping> XmlElements to update the ResourceMappingRegistry with CacheMappings.
CachingSchemesProcessor	A CachingSchemesProcessor is an ElementProcessor for the <caching-schemes%gt; element of Coherence Cache Configuration files.
CaffeineCache	A ConfigurableCacheMap backed by Caffeine.
CaffeineScheme	The CaffeineScheme class is responsible for building a fully configured instance of a CaffeineCache.
CanonicallyNamed	CanonicallyNamed provides a way for objects to identify themselves by name.
CdiConfigSourceProvider	Bridges the gap between ServiceLoader and CDI, by registering itself as a service and using CDI to discover available CDI-managed ConfigSources.
CdiEventObserver<E extends Event>	An observer of events that wraps a CDI ProcessObserverMethod.
CdiInjector	An implementation of Injector that uses the CDI bean manager to inject dependencies.
CdiInterceptorMetadataResolver	An implementation of InterceptorMetadataResolver that knows how to extract interceptor metadata from a Weld proxy.
CdiMapEventObserver<K,V>	An implementation of a AnnotatedMapListener.MapEventObserver that wraps a CDI ObserverMethod that observes MapEvent.
CdiMapListenerManager	Registers discovered CDI observer-based MapListeners when the cache is created, and unregisters them when it's destroyed.
CdiMetricsRegistryAdapter	Bridges the gap between ServiceLoader and CDI, by registering itself as a service and delegating to all discovered CDI beans that implement MetricsRegistryAdapter interface.
CdiNamespaceHandler	Custom namespace handler for cdi namespace.
CertificateLoader	A class that can load an array of certificates.
ChainedCollection<E>	An unmodifiable Collection that provides access to many collections in the given order.
ChainedComparator<T>	Composite comparator implementation based on a collection of comparators.
ChainedEnumerator	Provide an enumerator which enumerates the contents of multiple enumerators.
ChainedExtractor	A ExtractorBinding annotation representing a ChainedExtractor.
ChainedExtractor<T,E>	Composite ValueExtractor implementation based on an array of extractors.
ChainedExtractor.Extractors	A holder for the repeatable ChainedExtractor annotation.
ChainedExtractor.Extractors.Literal	An annotation literal for the ChainedExtractor.Extractors annotation.
ChainedExtractor.Literal	An annotation literal for the ChainedExtractor annotation.
ChainedExtractorBuilder	An ExtractorBuilder implementation that delegates building ValueExtractors to a chain of ExtractorBuilders and returns the result from the first ExtractorBuilder to return a non-null value from its ChainedExtractorBuilder.realize(String, int, String) method.
ChainedFragmentExtractor<T,E>	A ValueExtractor that extracts a Fragment from a nested property of the target object.
ChainedMap	Chains two maps into one virtual map.
ChainedParameterResolver	A ChainedParameterResolver is a ParameterResolver that consults zero or more provided ParameterResolvers in the order in which they were defined or added to resolve a Parameter.
ChainedResourceResolver	A ChainedResourceResolver is a ResourceResolver that chains together one or more other ResourceResolvers, those of which will be queried (in the order in which they are added to the ChainedResourceResolver) when attempting to resolve a resource.
ChainedSet<E>	An unmodifiable Set that provides access to many sets in the given order.
ChangeRecord<K,V>	Provides a mechanism to represent and mutate a Cache Entry that was changed in a Federated Cache.
ChangeRecord.Entry<K,V>	Represents the key, value and name of the Participant from which the entry originated.
ChangeRecordUpdater<K,V>	ChangeRecordUpdater allows to update the given ChangeRecord while processing the FederatedChangeEvent.
CircularArrayList	Resizable-array implementation of the List interface.
Classes	This abstract class contains dynamic (reflect-based) class, method, and field manipulation methods.
ClassFilter	Filter which discards all objects that are not of a certain class.
ClassHelper	This abstract class contains dynamic (reflect-based) class, method, and field manipulation methods.
ClassLoaderAware	The ClassLoaderAware interface provides the ability to configure a ClassLoader to be used by the implementing object when loading classes or resources.
ClassScheme	The ClassScheme class is responsible for building custom CachingSchemes and custom CacheStoreSchemes.
Cloneable	This interface is meant to "fix" the usability issues related to the Cloneable method-less interface.
Cloner	A Cloner provides an external means for producing copies of objects as prescribed by the Object.clone() contract.
Cluster	The Cluster interface represents a collection of services that operate in a clustered network environment.
Cluster.MemberTimeoutAction	MemberTimeoutAction is taken by the cluster service to remove members from the cluster who have exceeded a network timeout (e.g. packet-timeout).
ClusterDependencies	The ClusterDependencies interface defines externally provided dependencies for a Cluster.
ClusterDependencies.ServiceProvider	A provider of nw service instances.
ClusteredCachingScheme	The ClusteredCachingScheme interface represents schemes that are used for clustered caches.
ClusterException	Deprecated. As of release 3.4, replaced by PortableException
ClusterPermission	This class represents access to a clustered resource such as a Service or NamedCache.
ClusterProducer	A CDI producer that produces instances of the singleton Coherence Cluster.
ClusterQuorumPolicyBuilder	Defer cache configuration validation of a ClusterQuorumPolicyBuilder until realized.
Codec	A Codec provides an interception point for any specific code that needs to be executed pre or post (de)serialization.
Codecs	Codecs is a container for accessing default Codec implementations.
Codecs.AbstractCodec	Abstract Codec implementations that encodes objects by simply delegating to PofWriter.writeObject(int, Object).
Codecs.ArrayCodec	Implementation of Codec that delegates to PofReader.readObjectArray(int, Object[]) and PofWriter.writeObjectArray(int, Object[]) to deserialize and serialize an object.
Codecs.CollectionCodec	Implementation of Codec that delegates to PofReader.readCollection(int, Collection) and PofWriter.writeCollection(int, Collection) to deserialize and serialize an object.
Codecs.DefaultCodec	Implementation of Codec that simply delegates to PofReader.readObject(int) and PofWriter.writeObject(int, Object) to deserialize and serialize an object.
Codecs.LongArrayCodec	Implementation of Codec that delegates to PofReader.readLongArray(int, LongArray) and PofWriter.writeLongArray(int, LongArray) to deserialize and serialize an object.
Codecs.MapCodec	Implementation of Codec that delegates to PofReader.readMap(int, Map) and PofWriter.writeMap(int, Map) to deserialize and serialize an object.
Coherence	A Coherence instance encapsulates and controls one or more Session instances.
Coherence.Builder	A builder to build Coherence instances.
Coherence.LifecycleListener	An interface implemented by listeners of CoherenceLifecycleEvents.
Coherence.Mode	An enum representing the different modes that a Coherence instance can run in.
CoherenceBasedCache<K,V>	An Coherence-based implementation of a Cache.
CoherenceBasedCacheManager	The Coherence-based implementation of a CacheManager.
CoherenceBasedCachingProvider	The Coherence-based implementation of a CachingProvider.
CoherenceBasedCompleteConfiguration<K,V>	An Coherence-based CompleteConfiguration that provides setter methods.
CoherenceBasedConfiguration<K,V>	A Configuration for a CoherenceBasedCache.
CoherenceCacheEntry<K,V>	A Cache.Entry implementation.
CoherenceCacheEntryEvent<K,V>	A minimal implementation of the CacheEntryEvent.
CoherenceCacheEntryEventFilteringIterable<K,V>	An adapter to provide Iterables over Cache Entries, those of which are filtered using a CacheEntryEventFilter.
CoherenceCacheEntryEventFilteringIterator<K,V>	An Iterators to allow filtering of CacheEntryEvents.
CoherenceCacheEntryListenerRegistration<K,V>	A runtime representation of a CacheEntryListener registration, including its CacheEntryListenerConfiguration.
CoherenceCacheEventEventDispatcher<K,V>	Collects and appropriately dispatches CacheEntryEvents to CacheEntryListeners.
CoherenceCacheMXBean<K,V>	The Coherence implementation of a CacheMXBean.
CoherenceConfigSource	An implementation of ConfigSource that reads configuration properties from a Coherence map.
CoherenceConfiguration	The immutable configuration for a Coherence instance.
CoherenceConfiguration.Builder	A builder to build a CoherenceConfiguration instance.
CoherenceConfiguration.SimpleConfig	A simple immutable implementation of CoherenceConfiguration.
CoherenceConverterAdapter<T>	An InternalConverter that uses two Coherence Converters as a means of performing conversions to and from internal representations.
CoherenceDefaultsConfigSource	A static ConfigSource implementation that overrides default Coherence configuration to: Use java.util.logging as a logging destination Use com.oracle.coherence as a logger name Changes default message format to (thread={thread}, member={member}, up={uptime}): {text}, in order to allow java.util.logging to control overall message formatting This ConfigSource has an ordinal of 0, so the default configuration values above will only be used if none of the higher priority configuration sources provides an override for a configuration property.
CoherenceDispatcher	A CoherenceDispatcher raises Events pertaining to operations on a Coherence instance: CoherenceLifecycleEvents
CoherenceEntryProcessorResult<T>	A Coherence-based EntryProcessorResult.
CoherenceExtension	A Coherence CDI Extension that is used on both cluster members and the clients.
CoherenceExtension.InterceptorProvider	A provider of NamedEventInterceptor instances.
CoherenceLifecycleEvent	A CoherenceLifecycleEvent allows subscribers to capture events pertaining to the lifecycle of a Coherence instance.
CoherenceLifecycleEvent.Type	The emitted event types for a CoherenceLifecycleEvent.
CoherenceLifecycleEvents	CoherenceLifecycleEvents is an annotation that should be applied to EventInterceptor implementations that want to receive CoherenceLifecycleEvents.
CoherenceProducer	A producer that creates the default Coherence bean.
CoherenceQueryLanguage	CoherenceQueryLanguage is a simple language for building Filters and doing simple queries that are similar in style to SQL.
CoherenceQueryLanguageEngine	Coherence QL-based implementation of QueryEngine.
CoherenceServerExtension	A Coherence CDI Extension that should only be used within the cluster members.
CoherenceSession	An implementation of a Session allowing applications to use the new operator to create a Session via the default SessionProvider.
CoherenceTagsConfigSource	Allows us to register Coherence-specific tags by augmenting the value returned by the MetricID.GLOBAL_TAGS_VARIABLE config property.
CohQLException	An exception thrown when errors occur building CohQL queries.
CollectionAdapter	A CollectionAdapter supports properties whose types implement the java.util.Collection interface.
CollectionHelper	Deprecated. As of Coherence 12.1.2
Collector<V>	A Collector is mechanism for receiving items.
ColonToken	Colon is used to make attributes in a list or bag.
CommandsStatementBuilder	A class that builds the QueryPlus "COMMANDS" command.
Committed	A qualifier annotation used for any COMMITTED event.
Committed.Literal	An annotation literal for the Committed annotation.
Committing	A qualifier annotation used for any COMMITTING event.
Committing.Literal	An annotation literal for the Committing annotation.
CommittingLocal	A qualifier annotation used for any COMMITTING_LOCAL event.
CommittingLocal.Literal	An annotation literal for the CommittingLocal annotation.
CommittingRemote	A qualifier annotation used for any COMMITTING_REMOTE event.
CommittingRemote.Literal	An annotation literal for the CommittingRemote annotation.
ComparableMax<T,R>	Calculates a maximum among values extracted from a set of entries in a Map.
ComparableMin<T,R>	Calculates a minimum among values extracted from a set of entries in a Map.
ComparatorBuilder	Comparator builder that provides a small set of builder methods to simplify creation of a chain of ExtractorComparators from given ValueExtractors.
ComparatorHelper	ComparatorHelper is a utility class that provides a factory method used to create a java.util.Comparator instance from a string expression.
ComparisonFilter<T,E,C>	Filter which compares the result of a method invocation with a value.
ComparisonOperator	A base class for comparison operators, which are operators that are used in conditional clauses such as equals, greater than, less than, etc.
ComparisonValueExtractor<T,E extends Number>	A synthetic ValueExtractor that returns a result of comparison between two values extracted from the same target.
ComplexPofValue	An abstract base class for complex POF types, such as collections, arrays, maps, and user types.
CompositeActionPolicy	CompositeActionPolicy represents the "intersection" of two policies.
CompositeAddressProvider	CompositeAddressProvider is a composite of one or more AddressProviders or addresses that also implements the Set interface.
CompositeAddressProvider.AddressIterator	An Iterator over the addresses in this AddressProvider.
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.
CompositeAggregator.Parallel	Deprecated. As of Coherence 12.2.1.
CompositeKey<P,S>	Key class that consists of a primary and secondary component.
CompositeProcessor<K,V>	The CompositeProcessor represents a collection of entry processors that are invoked sequentially against the same Entry.
CompositeSchemeProcessor<T extends AbstractCompositeScheme>	A CompositeSchemeProcessor is a CustomizableBuilderProcessor for schemes that consist of a front and back scheme.
CompositeSocketAddressProvider	CompositeSocketAddressProvider is a composite of one or more SocketAddressProviders.
CompositeUpdater	A ValueUpdater implementation based on an extractor-updater pair that could also be used as a ValueManipulator.
CompoundBaseToken	CompoundBaseToken is the abstract base class for all tokens processed by the low level BaseTokenScanner that are made up of two or more BaseTokens.
CompressionFilter	Deprecated. As of Coherence 3.7
CompressionFilter.DeflaterOutputShell	DeflaterOutputShell enforces the "end" call for the corresponding Deflater object.
CompressionFilter.InflaterInputShell	InflaterInputShell enforces the "end" call for the corresponding Inflater object.
ConcurrentMap<K,V>	Map with additional concurrency features.
ConcurrentNotifier	A Condition-like object, usable by multiple threads to both wait and signal.
ConcurrentNotifier.Link	A link in a stack of waiting threads.
ConditionalElementProcessor<T>	A ConditionalElementProcessor is an ElementProcessor that supports conditionally processing XmlElements.
ConditionalExtractor<T,E>	An IndexAwareExtractor implementation that is only used to create a ConditionalIndex.
ConditionalIndex	ConditionalIndex is a MapIndex implementation that uses an associated filter to evaluate whether or not an entry should be indexed.
ConditionalProcessor<K,V,T>	Conditional entry processor represents a processor that is invoked conditionally based on the result of an entry evaluation.
ConditionalPut<K,V>	ConditionalPut is an EntryProcessor that performs an Entry.setValue operation if the specified condition is satisfied.
ConditionalPutAll<K,V>	ConditionalPutAll is an EntryProcessor that performs a Entry.setValue operation for multiple entries that satisfy the specified condition.
ConditionalRemove<K,V>	ConditionalRemove is an EntryProcessor that performs an Entry.remove operation if the specified condition is satisfied.
Config	Config is a helper class for processing a Coherence configuration system properties.
ConfigPropertyChanged	An event that will be raised whenever any config property is added to, updated in, or removed from the CoherenceConfigSource.
ConfigPropertyResolver	An implementation of Coherence property resolvers that reads system properties and environment variables from MP Config.
ConfigurableAddressProvider	ConfigurableAddressProvider is an implementation of the AddressProvider interface based on a static list of addresses configured in an XML element that contains one or more items in the following format:
ConfigurableAddressProvider.AddressHolder	A stateful holder for an obtaining an InetSocketAddress object.
ConfigurableAddressProviderFactory	Deprecated.
ConfigurableCacheFactory	An interface for cache factory.
ConfigurableCacheFactorySuppliers	A factory of ConfigurableCacheFactory supplier functions that can return a ConfigurableCacheFactory for a given scope name.
ConfigurableCacheFactorySuppliers.DefaultCacheFactorySupplier	The default ConfigurableCacheFactory supplier.
ConfigurableCacheFactorySuppliers.FixedCacheFactorySupplier	A fixed ConfigurableCacheFactory supplier that only supplies the ConfigurableCacheFactory instances provided when it was constructed.
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.
ConfigurableLocalAddressProvider	ConfigurableLocalAddressProvider is an AddressProvider which is only capable of returning local addresses.
ConfigurablePofContext	This class implements the PofContext interface using information provided in a configuration file (or in a passed XML configuration) as well as classes annotated with PortableType.
ConfigurablePofContext.PofConfig	The information related to the configuration of a particular PofContext for a specific URI and ClassLoader.
ConfigurableQuorumPolicy	ConfigurableQuorumPolicy provides a Quorum-based ActionPolicy for services based on the cluster-configuration.
ConfigurableQuorumPolicy.ClusterQuorumPolicy	ClusterQuorumPolicy defines an action policy that is applicable to the cluster.
ConfigurableQuorumPolicy.MembershipQuorumPolicy	MembershipQuorumPolicy is a quorum policy that is stateless and based solely on service membership sizes.
ConfigurableQuorumPolicy.MembershipQuorumPolicy.QuorumRule	A quorum rule defines a set of allowable actions beyond the rule's threshold size.
ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy	PartitionedCacheQuorumPolicy defines a configurable quorum policy that is applicable to a DistributedCacheService.
ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy.ActionRule	Action Rules for ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy
ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy.Notification	Notification is a simple struct carrying the notification info.
ConfigurableQuorumPolicy.ProxyQuorumPolicy	ProxyQuorumPolicy defines a configurable quorum policy that is applicable to a proxy service.
ConfigurableSerializerFactory	Deprecated.
ConfigurableSnapshotArchiverFactory	A SnapshotArchiverFactory implementation that creates instances of a SnapshotArchiver class configured using an XmlElement.
ConfigurationException	A ConfigurationException captures information concerning an invalid configuration of Coherence.
ConfigurationProcessor	A ConfigurationProcessor is responsible for processing a configuration XmlElement to produce a CacheConfig object.
ConfigUri	A qualifier annotation used to indicate a configuration resource URI.
ConfigUri.Literal	An annotation literal for the ConfigUri annotation.
Connecting	A qualifier annotation used for any CONNECTING event.
Connecting.Literal	An annotation literal for the Connecting annotation.
Constants	Constants used by the Coherence JCache Adapter.
ContainerHelper	Helpers for supporting Coherence JCache in Container Environment.
ContainerHelper.JCacheLifecycleInterceptor	An EventInterceptor that initializes JCache for running within a container.
ContainerPassThroughResourceConfig	An extension of PassThroughResourceConfig that should be used for container deployments of Coherence REST when pass-through is required.
ContainerResourceConfig	An extension of DefaultResourceConfig that should be used for container deployments of Coherence REST.
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.
ContainsAllOperator	An operator representing the conditional "contains all" operation.
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.
ContainsAnyOperator	An operator representing the conditional "contains any" operation.
ContainsFilter<T,E>	Filter which tests a Collection or Object array value returned from a method invocation for containment of a given value.
ContainsOperator	An operator representing the conditional "contains" operation.
ContainsOPToken	ContainsOPToken is used to implement a contains operation that checks for membership in a list.
ContextJCacheStatistics	JCache Statistics implementation.
Continuation<R>	Continuation interface is used to implement asynchronous post-processing, the pattern that is also known as the "Continuation-passing style".
ContinuousQueryCache<K,V_BACK,V_FRONT>	Create a materialized view of a NamedCache using the Coherence Continuous Query capability.
ContinuousQueryCacheScheme	This scheme is internally used to provide the ParameterizedBuilder that constructs the view-filter for the ViewScheme.
Controllable	The Controllable interface represents a configurable daemon-like object, quite often referred to as a service, that usually operates on its own thread and has a controllable life cycle.
Converter<F,T>	Provide for "pluggable" object conversions.
Converter<F,T>	Provide for "pluggable" object conversions.
ConverterCollections	A collection of Collection implementation classes that use the Converter interface to convert the items stored in underlying collection objects.
ConverterCollections.AbstractConverterEntry<FK,TK,FV,TV>	An abstract Map Entry that lazily converts the key and value.
ConverterCollections.ConverterCacheEntry	A ConfigurableCacheMap.Entry that lazily converts the key and value.
ConverterCollections.ConverterCacheEvent<K,V>	A Converter CacheEvent views an underlying CacheEvent through a set of key and value Converters.
ConverterCollections.ConverterCacheListener<K,V>	A converter MapListener that converts events of the underlying MapListener for the underlying NamedCache.
ConverterCollections.ConverterCacheMap<FK,TK,FV,TV>	A Converter CacheMap views an underlying CacheMap through a set of key and value Converters.
ConverterCollections.ConverterCollection<F,T>	A Converter Collection views an underlying Collection through a Converter.
ConverterCollections.ConverterComparator<F,T>	A Comparator that Converts the elements before comparing them.
ConverterCollections.ConverterConcurrentMap<FK,TK,FV,TV>	A Converter ConcurrentMap views an underlying ConcurrentMap through a set of key and value Converters.
ConverterCollections.ConverterEntry<FK,TK,FV,TV>	A Map Entry that lazily converts the key and value.
ConverterCollections.ConverterEntrySet<FK,TK,FV,TV>	A Converter Entry Set views an underlying Entry Set through a set of key and value Converters.
ConverterCollections.ConverterEnumerator<F,T>	Provide an implementation of an enumerator which converts each of the items which it enumerates.
ConverterCollections.ConverterHolder<F,T>	A Holder that converts the element before returning them.
ConverterCollections.ConverterInvocableMap<FK,TK,FV,TV>	A Converter InvocableMap views an underlying InvocableMap through a set of key and value Converters.
ConverterCollections.ConverterList<F,T>	A Converter List views an underlying List through a Converter.
ConverterCollections.ConverterListIterator<F,T>	A Converter ListIterator views an underlying ListIterator through a Converter.
ConverterCollections.ConverterLongArray<F,T>	ConverterLongArray converts the value of the LongArray from its raw form (type F) to the desired from (type T).
ConverterCollections.ConverterMap<FK,TK,FV,TV>	A Converter Map views an underlying Map through a set of key and value Converters.
ConverterCollections.ConverterMapEvent<K,V>	A ConverterMapEvent views an underlying MapEvent through a set of key and value Converters.
ConverterCollections.ConverterMapListener<K,V>	A converter MapListener that converts events of the underlying MapListener for the underlying map.
ConverterCollections.ConverterNamedCache<FK,TK,FV,TV>	A Converter NamedCache views an underlying NamedCache through a set of key and value Converters.
ConverterCollections.ConverterObservableMap<FK,TK,FV,TV>	A Converter ObservableMap views an underlying ObservableMap through a set of key and value Converters.
ConverterCollections.ConverterQueryMap<FK,TK,FV,TV>	A Converter QueryMap views an underlying QueryMap through a set of key and value Converters.
ConverterCollections.ConverterSet<F,T>	A Converter Set views an underlying Set through a Converter.
ConverterCollections.ConverterSortedMap<FK,TK,FV,TV>	A Converter SortedMap views an underlying SortedMap through a set of key and value Converters.
ConverterCollections.ConverterSortedSet<F,T>	A Converter SortedSet views an underlying SortedSet through a Converter.
ConverterEnumerator	Deprecated. As of Coherence 12.1.2, replaced by ConverterCollections.ConverterEnumerator
CopyOnWriteLongArray<V>	A thread-safe variant of LongArray in which all mutating operations (e.g.
CopyOnWriteLongArray.UnmodifiableIterator<V>	Unmodifiable view of a LongArray.Iterator.
CopyOnWriteMap<K,V>	A thread-safe variant of Map in which all mutating operations (e.g.
Count	A qualifier annotation used when injecting Coherence resource to specify the latch count.
Count<K,V>	Calculates a number of values in an entry set.
Count.Literal	An annotation literal for the Count annotation.
CountDownLatch
CreateCacheStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a CreateCacheStatementBuilder.CreateCacheStatement.
CreateCacheStatementBuilder.CreateCacheStatement	Implementation of the CohQL "CREATE CACHE" command.
Created	A qualifier annotation used for any CREATED event.
Created.Literal	An annotation literal for the Created annotation.
CreateIndexStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a CreateIndexStatementBuilder.CreateIndexStatement.
CreateIndexStatementBuilder.CreateIndexStatement	Implementation of the CohQL "CREATE INDEX" command.
CreateSnapshotStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a CreateSnapshotStatementBuilder.CreateSnapshotStatement.
CreateSnapshotStatementBuilder.CreateSnapshotStatement	Implementation of the CohQL "CREATE SNAPSHOT" command.
CredentialsHelper	A helper class to resolve gRPC credentials.
CurlyToken	CurlyToken is used to process expressions between bracketing characters such as are between "{" and "}" which should result in a bag such as {1,3,4,5}.
CustomAddressProviderBuilder	This class builds an AddressProviderBuilder from a customized ParameterizedBuilder of AddressProvider.
CustomizableBinaryStoreManagerBuilderProcessor<T extends BinaryStoreManagerBuilderCustomization>	A CustomizableBinaryStoreManagerBuilderProcessor is a CustomizableBuilderProcessor that additionally processes the required definition of a BinaryStoreManagerBuilder for those classes supporting BinaryStoreManagerBuilderCustomization.
CustomizableBuilderProcessor<T>	A CustomizableBuilderProcessor is a multi-purpose ElementProcessor responsible for processing xml elements that produce objects supporting BuilderCustomization.
CustomScheme	A CustomScheme is an adapter for a ParameterizedBuilder that builds a Map.
CustomStoreManagerBuilder	The CustomStoreManagerBuilder class builds an instance of a custom BinaryStoreManager.
Daemon	A abstract Daemon thread handler.
DaemonPoolBuilder	A ParameterizedBuilder that builds a DaemonPool.
DaemonPoolExecutor	An Executor that uses a DaemonPool to execute tasks.
DaemonPoolExecutor.DaemonPoolManagement	Daemon pool metrics and management.
DaemonPoolProcessor	An ElementProcessor to process a daemon pool configuration.
DaemonThreadFactory	DaemonThreadFactory is a ThreadFactory which produces daemon threads.
DatabaseFactory	Factory for Berkeley DB Environments and Databases.
DatabaseFactory.EnvironmentHolder	Holder for Berkeley DB Environment and its Databases.
DatabaseFactory.EnvironmentHolder.DirectoryLock	Directory based lock.
DatabaseFactoryManager	A manager for Berkeley DB Database factories.
DatagramPacketOutputStream	Provides an OutputStream on top of a DatagramPacket.
DatagramSocketProvider	DatagramSocketProivder defines an interface for creating datagram and multicast sockets.
DateFormatAdapter	A property adapter for formatting formatting and parsing dates in a locale-sensitive manner.
DateMode	Enumeration that defines different ways for serialization of date/time values.
DateTimeAdapter	A property adapter for the <xs:dateTime> format conforming to ISO 8601
DebugDataOutputStream	This is an imitation DataOutputStream class that logs the output in a human-readable format for debugging purposes.
DecoratedBinaryDeltaCompressor	A DeltaCompressor implementation that works with decorated binary values.
DecorationOnlyDeltaCompressor	DecorationOnlyDeltaCompressor is a DeltaCompressor which optimizes for "decoration-only" updates.
DefaultAggregatorFactory	The default implementation of AggregatorFactory.
DefaultBuilderCustomization<T>	The DefaultBuilderCustomization class is the default implementation of BuilderCustomization.
DefaultCacheFactoryBuilder	DefaultCacheFactoryBuilder is the default implementation of CacheFactoryBuilder.
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.
DefaultConfigurableCacheFactory	Deprecated.
DefaultConfigurableCacheFactory.CacheInfo	CacheInfo is a placeholder for cache attributes retrieved during parsing the corresponding cache mapping element.
DefaultController	The default implementation of the AccessController interface.
DefaultGrpcAcceptorController	The default GrpcAcceptorController implementation.
DefaultIdentityAsserter	The default implementation of the IdentityAsserter interface.
DefaultIdentityTransformer	The default implementation of the IdentityTransformer interface, which simply returns the Subject that is passed to it.
DefaultKeyAssociator	A DefaultKeyAssociator provides key associations on behalf of keys that implement the KeyAssociation interface.
DefaultKeyConverter	Default implementation of KeyConverter for a given key 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.
DefaultProcessingContext	The default implementation of a ProcessingContext.
DefaultProcessorFactory	The default implementation of ProcessorFactory.
DefaultProxyServiceLoadBalancer	Default ProxyServiceLoadBalancer implementation.
DefaultResourceConfig	An extension of org.glassfish.jersey.server.ResourceConfig that registers the Coherence REST root resource and provider classes, in addition to user defined package names.
DefaultRootResource	Default root resource implementation.
DefaultsCreationPreprocessor	A DefaultsCreationPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that creates necessary defaults, like for <serializer>s, if they are missing from the <defaults> element.
DefaultSerializer	A Serializer implementation that uses the ExternalizableHelper implementation for serialization and deserialization of objects.
DefaultServletContextListener	A simple implementation of the ServletContextListener interface that calls CacheFactory.shutdown() during servlet context shutdown.
DefaultsProcessor	The DefaultsProcessor is responsible for processing the <defaults> XmlElement in a Coherence Cache Configuration file, registering each of the processed elements with the ResourceRegistry.
DefaultStatementResult	A default implementation of a StatementResult.
DefaultVersionedPartitions	Default implementation of VersionedPartitions,
DelegatingWriteBuffer	A DelegatingWriteBuffer is a WriteBuffer that writes through to an underlying (or "containing") WriteBuffer.
Deleted	A qualifier annotation used for any DELETED event.
Deleted.Literal	An annotation literal for the Deleted annotation.
DeleteStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a DeleteStatementBuilder.DeleteStatement.
DeleteStatementBuilder.DeleteStatement	Implementation of the CohQL "DELETE" query.
DeltaCompressor	The DeltaCompressor interface provides the capability of comparing two in-memory buffers containing an old and a new value, and producing a result (called a "delta") that can be applied to the old value to create the new value.
DeltaCompressorProcessor	An ElementProcessor for processing <compressor> configurations.
DeltaSet	Implements a set which is based on another set, which is assumed to be immutable.
Departed	A qualifier annotation used for any DEPARTED event.
Departed.Literal	An annotation literal for the Departed annotation.
Departing	A qualifier annotation used for any DEPARTING event.
Departing.Literal	An annotation literal for the Departing annotation.
Dequeue	Represents a double-ended queue (dequeue) of objects.
DescribableAddressProvider	An AddressProvider that additionally allows to retrieve a human readable description of underlying addresses without doing a DNS lookup.
Description	The Description annotation allows a description to be specified for a method on an MBean, and for an MBean interface itself.
DeserializationAccelerator	DeserializationAccelerator is an IndexAwareExtractor implementation that is used to create a ForwardOnlyMapIndex, which in turn is used for deserialization optimization.
Destroyed	A qualifier annotation used for any DESTROYED event.
Destroyed.Literal	An annotation literal for the Destroyed annotation.
DirectorySnapshotArchiver	An implementation of a SnapshotArchiver that uses a shared directory to store archived snapshots.
DirectQuery	Holder for direct query configuration.
Disconnected	A qualifier annotation used for any DISCONNECTED event.
Disconnected.Literal	An annotation literal for the Disconnected annotation.
Disposable	The Disposable interface is used for life-cycle management of resources.
Disposable	Deprecated. use Disposable instead
Disposing	A qualifier annotation used for any DISPOSING event.
Disposing.Literal	An annotation literal for the Disposing annotation.
DistinctValues<K,V,T,E>	Return the set of unique values extracted from a set of entries in a Map.
DistributedCacheService	A DistributedCacheService is a clustered cache service that partitions its data across cluster members that provide backing storage.
DistributedScheme	The DistributedScheme class builds a distributed cache.
DistributedScheme.BackupConfig	The DistributedScheme.BackupConfig class manages configuration for the partitioned cache backup map.
DistributionManager	A DistributionManager coordinates the distribution of partitions for a partitioned service.
DivisionOperator	An operator representing the conditional mathematical division operation.
DoAsAction<T>	A helper class to expose the Subject.doAs(javax.security.auth.Subject, java.security.PrivilegedAction<T>) call as a privileged action.
DocumentElementPreprocessor	A DocumentElementPreprocessor is a DocumentPreprocessor that is designed to operate with one or more DocumentElementPreprocessor.ElementPreprocessors.
DocumentElementPreprocessor.ElementPreprocessor	An DocumentElementPreprocessor.ElementPreprocessor provides a mechanism to examine and optionally mutate an XmlElement prior to it being processed by a ElementProcessor.
DocumentPreprocessor	A DocumentPreprocessor provides a mechanism to pre-process an XmlElement, representing part or all of an XmlDocument prior to the said XmlElement being processes using configured ElementProcessors.
DocumentProcessor	A DocumentProcessor is responsible for processing in an XmlDocument to produce a resulting configured resource.
DocumentProcessor.DefaultDependencies	The DocumentProcessor.DefaultDependencies is the default implementation of the DocumentProcessor DocumentProcessor.Dependencies interface.
DocumentProcessor.Dependencies	The DocumentProcessor.Dependencies of DocumentProcessors.
DoubleAverage<T>	Calculates an average for values of any numeric type extracted from a set of entries in a Map.
DoubleMax<T>	Calculates a maximum of numeric values extracted from a set of entries in a Map.
DoubleMin<T>	Calculates a minimum of numeric values extracted from a set of entries in a Map.
DoubleSum<T>	Sums up numeric values extracted from a set of entries in a Map.
DropCacheStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a DropCacheStatementBuilder.DropCacheStatement.
DropCacheStatementBuilder.DropCacheStatement	Implementation of the CohQL "DROP CACHE" command.
DropIndexStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a DropIndexStatementBuilder.DropIndexStatement.
DropIndexStatementBuilder.DropIndexStatement	Implementation of the CohQL "create index" command.
DuplexingPofHandler	An implementation of PofHandler that passes each call onto two different PofHandler objects.
ElementCalculatorBuilder	The ElementCalculatorBuilder class builds an NamedTopic.ElementCalculator.
ElementCalculatorProcessor	A ElementCalculatorProcessor is responsible for processing an element-calculator XmlElement to produce an ElementCalculatorBuilder.
ElementProcessor<T>	An ElementProcessor is responsible for processing XmlElement content to return a strongly-typed value.
ElementProcessorHelper	An ElementProcessorHelper provides a number of helper methods for ElementProcessors.
EmptyKeyStoreLoader	A KeyStoreLoader that loads an empty, non-password protected KeyStore.
EndOfStatementOPToken	An OPToken representing the end of a CohQL statement.
EndOPToken	An OPToken representing the end of a token stream.
EntityFactory<ID,T>	Provides a way to create entity instances with a known identity.
EntryAwareComparator<T>	EntryAwareComparator is an extension to the Comparator interface that allows the EntryComparator to know whether the underlying comparator expects to compare the corresponding Entries' keys or values.
EntryComparator	Comparator implementation used to compare map entries.
EntryEvent<K,V>	An EntryEvent captures information relating to actions performed on entries.
EntryEvent.Type	The EntryEvent types.
EntryEvents	EntryEventInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive EntryEvents.
EntryExtractor	The EntryExtractor is a base abstract class for special purpose custom ValueExtractor implementations.
EntryFilter<K,V>	EntryFilter provides an extension to Filter for those cases in which both a key and a value may be necessary to evaluate the conditional inclusion of a particular object.
EntryProcessorEvent	An EntryProcessorEvent captures information relating to the execution of InvocableMap.EntryProcessors.
EntryProcessorEvent.Type	The EntryProcessorEvent types.
EntryProcessorEvents	EntryProcessorEventInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive EntryProcessorEvents.
EntryResource	REST resource representing a single cache entry.
EntrySetMap	A trivial Map implementation that is based on a specified set of entries.
EntrySetResource	REST resource representing a set of cache entries.
EntryWriter	Provider responsible for marshalling map entries.
EnumerationIterator<E>	Provide a implementation of an Iterator based on data from an Enumeration.
EnumPofSerializer	PofSerializer implementation that can be used to serialize all enum values.
EnumProcessor<T extends Enum<?>>	A EnumProcessor is responsible for processing Coherence Enum values and return the corresponding Enum type.
EnvironmentVariableResolver	An abstraction that allows us to make environment variable resolution customizable.
EnvironmentVariableResolver.Default	Default EnvironmentVariableResolver implementation.
EqualsFilter<T,E>	Filter which compares the result of a method invocation with a value for equality.
EqualsOperator	An operator implementation representing the equality operator.
Error	A qualifier annotation used for any ERROR event.
Error.Literal	An annotation literal for the Error annotation.
ErrorsHelper	Error helper methods.
Event<T extends Enum<T>>	An Event object captures the necessary information required to adequately describe some activity that has occurred.
Event<T extends Enum<T>>	An event dispatched by a PartitionedCacheDispatcher.
Event<T extends Enum<T>>	A PartitionedServiceEvent captures information concerning an operation on a PartitionedService.
Event<S extends Enum<S>>	An Event captures the information that may trigger a Transition in a FiniteStateMachine from one state to another.
EventDispatcher	An EventDispatcher is responsible for dispatching Events to EventInterceptors for processing.
EventDispatcher.InterceptorRegistrationEvent<E extends Event<? extends Enum>>	An InterceptorRegistrationEvent allows EventInterceptors to observe other EventInterceptors being added or removed from an EventDispatcher instance.
EventDispatcher.InterceptorRegistrationEvent.Type	The InterceptorRegistrationEvent types.
EventDispatcherAwareInterceptor<E extends Event<?>>	EventDispatcherAwareInterceptor is an EventInterceptor implementation that takes responsibility for registering itself with the EventDispatcher.
EventDispatcherRegistry	An EventDispatcherRegistry manages the registration of EventDispatchers.
EventHelper	Helper class providing various functionality related to event handling.
EventInterceptor<E extends Event<? extends Enum>>	An EventInterceptor provides an implementation that is capable of intercepting and processing Events.
EventObserverSupport	Manages registration of CDI observers with InterceptorRegistry upon ConfigurableCacheFactory activation, and their subsequent un-registration on deactivation.
EventObserverSupport.CacheLifecycleEventHandler	Handler for CacheLifecycleEvents.
EventObserverSupport.CoherenceLifecycleEventHandler	Handler for CoherenceLifecycleEvents.
EventObserverSupport.EntryEventHandler<K,V>	Handler for EntryEvents.
EventObserverSupport.EntryProcessorEventHandler	Handler for EntryProcessorEvents.
EventObserverSupport.EventHandler<E extends Event<T>,T extends Enum<T>>	Abstract base class for all observer-based interceptors.
EventObserverSupport.EventObserver<E extends Event>	An observer of a specific event type.
EventObserverSupport.LifecycleEventHandler	Handler for LifecycleEvents.
EventObserverSupport.ServiceEventHandler<E extends Event<T>,T extends Enum<T>>	Abstract base class for all observer-based service interceptors.
EventObserverSupport.SessionLifecycleEventHandler	Handler for SessionLifecycleEvents.
EventObserverSupport.TransactionEventHandler	Handler for TransactionEvents.
EventObserverSupport.TransferEventHandler	Handler for TransactionEvents.
EventObserverSupport.UnsolicitedCommitEventHandler	Handler for UnsolicitedCommitEvents.
Events	Meta annotation that must be applied to all event interceptor annotations, in order to make them discoverable.
EvictionPolicyBuilder	The EvictionPolicyBuilder builds a ConfigurableCacheMap.EvictionPolicy.
EvictionPolicyProcessor	A EvictionPolicyProcessor is responsible for processing an eviction-policy XmlElement to produce an EvictionPolicyBuilder.
Evolvable	The Evolvable interface is implemented by classes that require forwards- and backwards-compatibility of their serialized form.
EvolvableHolder	Storage for evolvable classes.
EvolvableObject	Defines an interface that should be implemented by the classes that want to support evolution.
EvolvablePortableObject	Extension of the PortableObject interface that supports forwards- and backwards-compatibility of POF data streams.
Exceptions	Class for providing exception support.
Executed	A qualifier annotation used for any EXECUTED event.
Executed.Literal	An annotation literal for the Executed annotation.
Executing	A qualifier annotation used for any EXECUTING event.
Executing.Literal	An annotation literal for the Executing annotation.
ExecutionContext	Instances of this context are passed to Statements to allow commands to discern execution conditions, altering their behavior / result as needed.
ExecutionContext	Provides contextual information about a FiniteStateMachine, typically to aid in runtime decision making for actions (eg: TransitionActions, StateEntryActions and/or StateExitActions) and Events.
ExecutorMBean	ExecutorMBean provides a monitor interface for the Executor statistics.
ExecutorProcessor	An ElementProcessor that will parse and produce a Executor based on an ssl/executor configuration element.
Expression<T>	A Expression represents a calculation to be evaluated at runtime, during which, one or more Parameters may be required.
ExpressionParser	An ExpressionParser parses a String representation of some calculation to produce an Expression, that of which when evaluated will return an expected type of value.
ExtendedLanguageStatementBuilder	A class that builds the QueryPlus "EXTENDED LANGUAGE" command.
ExtendPreprocessor	An ExtendPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that will inject an "acceptor-config" XmlElement into a "proxy-scheme" XmlElement if one does not exist.
ExtensibleConfigurableCacheFactory	ExtensibleConfigurableCacheFactory provides a facility to access caches declared in a "coherence-cache-config.xsd" compliant configuration file.
ExtensibleConfigurableCacheFactory.DefaultDependencies	The ExtensibleConfigurableCacheFactory.DefaultDependencies is a simple implementation of the ExtensibleConfigurableCacheFactory ExtensibleConfigurableCacheFactory.Dependencies interface.
ExtensibleConfigurableCacheFactory.Dependencies	The ExtensibleConfigurableCacheFactory.Dependencies for the ExtensibleConfigurableCacheFactory.
ExtensibleConfigurableCacheFactory.DependenciesHelper	The ExtensibleConfigurableCacheFactory.DependenciesHelper provides helper method for constructing ExtensibleConfigurableCacheFactory.Dependencies implementations for ExtensibleConfigurableCacheFactorys.
ExtensibleConfigurableCacheFactory.Manager	The Manager class uses builders to create the required backing maps and provides client access to those maps.
ExtensibleConfigurableCacheFactory.PartitionedBackingMapManager	The PartitionedBackingMapManager is used by PartitionAwareBackingMap(s) to lazily configure the enclosing PABM based on the configuration settings of the enclosed maps.
ExternalizableHelper	Helpers for the Serializable, Externalizable and the ExternalizableLite interface.
ExternalizableHelper.DecoratedMultiBufferReadBuffer	DecoratedMultiBufferReadBuffer is a MultiBufferWriteBuffer that represents a binary "decorated" value, and allows a more optimized ExternalizableHelper.getUndecorated(ReadBuffer) operation.
ExternalizableHelper.DefaultObjectStreamFactory	Default ObjectStreamFactory implementation.
ExternalizableHelper.FormatAwareCompressor	A DeltaCompressor wrapper implementation that removes/replaces the serialization format byte (FMT_EXT) before/after delegating to the underlying compressor.
ExternalizableHelper.IntDecoratedObject	Integer decorated object.
ExternalizableHelper.Shielded	Marker interface.
ExternalizableHelper.ShieldedDataOutputStream	An OutputStream that implements DataOutput that delegates all operations other than flush and close to an underlying object that implements DataOutput.
ExternalizableHelper.ShieldedInputStream	An InputStream that delegates all operations other than close to an underlying InputStream.
ExternalizableHelper.ShieldedObjectOutputStream	An OutputStream that implements ObjectOutput that delegates all operations other than flush and close to an underlying object that implements ObjectOutput.
ExternalizableHelper.ShieldedOutputStream	An OutputStream that delegates all operations other than flush and close to an underlying OutputStream.
ExternalizableHelper.SimpleXmlBeanClassCache	An implementation XmlBeanClassCache that uses a pre-defined list of XmlBean implementations.
ExternalizableHelper.Stats	Serialization statistics for a given user type.
ExternalizableHelper.XmlBeanClassCache	An interface for caching class reference by integer ID values.
ExternalizableLite	Optimized serialization.
ExternalizableLitePofSerializer	PofSerializer implementation that supports the serialization and deserialization of any class that implements ExternalizableLite to and from a POF stream.
ExternalizablePofSerializer	PofSerializer implementation that supports the serialization and deserialization of any class that implements Externalizable to and from a POF stream.
ExternalScheme	The ExternalScheme class is responsible for building a fully configured instance of a ExternalCache.
ExtractorBinding	Specifies that an annotation type is a ValueExtractor binding type.
ExtractorBuilder	ExtractorBuilders provide a mechanism to construct a ValueExtractor for a provided cache name, target and property chain (ExtractorBuilder.realize(String, int, String)).
ExtractorComparator<T>	Comparator implementation that uses specified ValueExtractor to extract value(s) to be used for comparison.
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.
ExtractorFactory<A extends Annotation,T,E>	A factory that produces instances of ValueExtractor for a given Annotation.
ExtractorFilter<T,E>	Base Filter implementation for doing extractor-based processing.
ExtractorProcessor<K,V,T,E>	ExtractorProcessor is an EntryProcessor implementations that extracts a value from an object cached in an InvocableMap.
ExtractorProducer	A CDI bean that produces ValueExtractor instances using ExtractorFactory beans annotated with ExtractorBinding annotations.
ExtractorProducer.ChainedExtractorsSupplier	A {ExtractorFactory that produces MultiExtractor containing ValueExtractor instances produced from the annotations contained in a ChainedExtractor.Extractors annotation.
ExtractorProducer.ChainedExtractorSupplier	A {ExtractorFactory that produces chained ValueExtractor instances for an array of property or method names.
ExtractorProducer.PofExtractorsSupplier	A {ExtractorFactory that produces MultiExtractor containing ValueExtractor instances produced from the annotations contained in a PofExtractor.Extractors annotation.
ExtractorProducer.PofExtractorSupplier	A {ExtractorFactory that producesValueExtractor instances for a given POF index or property path.
ExtractorProducer.UniversalExtractorsSupplier	A {ExtractorFactory that produces MultiExtractor containing ValueExtractor instances produced from the annotations contained in a PropertyExtractor.Extractors annotation.
ExtractorProducer.UniversalExtractorSupplier	A {ExtractorFactory that producesValueExtractor instances for a given property or method name.
Extractors	Simple Extractor DSL.
Factory<T>	The Factory interface provides a means of producing objects of a given type.
FactoryBasedAddressProviderBuilder	This class builds an AddressProviderBuilder from a AddressProviderFactory.
FailoverAccessPolicy	FailoverAccessPolicy is used to moderate the client request load during a failover event in order to allow cache servers adequate opportunity to re-establish partition backups.
FederatedChangeEvents	EntryEventInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive FederatedChangeEvents.
FederatedConnectionEvents	EntryEventInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive FederatedConnectionEvents.
FederatedPartitionEvents	EntryEventInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive FederatedPartitionEvents.
FederationEventHandlers	Federation event handlers that allow CDI observers to handle any federation event.
FileHelper	A Collection of helper methods for files.
Filter<T>	Provide for "pluggable" conditional behavior.
FilterBinding	Specifies that an annotation type is a Filter binding type.
FilterBuilder	FilterBuilder is a visitor class that converts a given Abstract Syntax Tree into a Filter.
FilterBuildingException	FilterBuildingException is the RuntimeException thrown by the QueryHelper when building a Filter.
FilterEnumerator	Provide a generic implementation of an enumerator which can enumerate items based on an inclusion test.
FilterFactory<A extends Annotation,T>	A factory that produces instances of Filter for a given Annotation.
FilterProducer	A CDI bean that produces Filter instances using FilterFactory beans annotated with FilterBinding annotations.
FilterProducer.AlwaysFilterSupplier	A FilterFactory that produces AlwaysFilter instances.
FilterProducer.WhereFilterSupplier	A FilterFactory that produces Filter instances from a CohQL where clause.
Filters	Simple Filter DSL.
FilterTrigger	A generic Filter-based MapTrigger implementation.
FiniteStateMachine<S extends Enum<S>>	A FiniteStateMachine implements a general purpose finite-state-machine.
FiniteStateMachineListener<S extends Enum<S>>	A FiniteStateMachineListener listens for state related events on a FiniteStateMachine.
FixedElementCalculator	A fixed implementation of a NamedTopic.ElementCalculator that gives all elements a size of 1.
FlashJournalScheme	The FlashJournalScheme is used to create an instance of a Flash Journal map.
FlowControl	Communication facilities that provide an asynchronous (non-blocking) way of submitting data exchange requests commonly implement mechanisms of modulating the control flow for underlying data transfer units (e.g. messages or packets).
ForceRecoveryStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a ForceRecoveryStatementBuilder.ForceRecoveryStatement.
ForceRecoveryStatementBuilder.ForceRecoveryStatement	Implementation of the CohQL "FORCE RECOVERY" command.
FormattedMapStatementResult	An implementation of a StatementResult which assumes the result is a Map with value being a Object or Object[].
Formatting	Class for providing formatting functionality for various types.
ForwardOnlyMapIndex	ForwardOnlyMapIndex is a MapIndex implementation that unlike the SimpleMapIndex maintains only a forward index and not the inverse index.
Fragment<T>	An object that represents a fragment of another object.
FragmentExtractor<T>	A ValueExtractor that is used to extract a Fragment from an object.
FunctionBuilders	This class contains a number of ParameterizedBuilder implementations for the standard built-in CohQL functions.
Gate<R>	A thin extension of Gate.
GlobalSocketProviderProcessor	An ElementProcessor that will parse a <global-socket-provider> and produce the global SocketProviderBuilder.
GreaterEqualsFilter<T,E extends Comparable<? super E>>	Filter which compares the result of a method invocation with a value for "Greater or Equal" condition.
GreaterEqualsOperator	A class representing the conditional greater than or equal to operator.
GreaterFilter<T,E extends Comparable<? super E>>	Filter which compares the result of a method invocation with a value for "Greater" condition.
GreaterOperator	A class representing the greater than operator.
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.
GroupAggregator.Parallel<K,V,T,E,R>	Deprecated. As of Coherence 12.2.1.
GrpcConnectionMetrics	A holder for gRPC connection metrics.
GrpcConnectionMetrics.ConnectionMetricsMBean	A MBean to track gRPC connections.
GrpcMetricsInterceptor	A ServerInterceptor that enables capturing of gRPC metrics.
GrpcProxyMetrics	The gRPC Proxy metrics MBean implementation.
GrpcProxyMetricsMBean	The gRPC Proxy metrics MBean.
GrpcProxyService	An interface implemented by gRPC proxy services.
GrpcServerBuilderProvider	Deprecated. the gRPC proxy server is configured and built as a normal proxy service configured with a gRPC acceptor in the system cache configuration file
GrpcServerConfiguration	A class that can configure gRPC server builders prior to them being used to start the servers.
GrpcServerController	A controller class that starts and stops the default gRPC server by responding to DefaultCacheServer lifecycle events.
GrpcServerController.Listener	A listener that will start the gRPC server base on Coherence or DefaultCacheServer lifecycle events.
GrpcServiceDependencies	The dependencies for a gRPC bindable service.
GrpcServiceDependencies.DefaultDependencies	The default GrpcServiceDependencies implementation.
Guardable	A Guardable is a logical execution unit whose lifetime may be guarded by a Guardian.
Guardian	A Guardian is responsible for monitoring the registered Guardable objects.
Guardian.GuardContext	A GuardContext represents the lifecycle status of a Guardable.
GuardSupport	A concrete implementation of Guardian/Guardable interactions.
GUIDHelper	Static helper methods to encode and decode the attributes related to the storage of a persistent form of a partition.
GUIDHelper.GUIDResolver	Resolver used during a recovery to discover the newest available GUID for a given partition.
HashEncoded	HashEncoded interface represents an ability to retrieve an encoded hash value; most commonly used to calculate a partition id.
Hasher<V>	A Hasher provides an external means for producing hash codes and comparing objects for equality.
HashHelper	This abstract class contains helper functions for calculating hash code values for any group of java intrinsics.
HashHelper	This abstract class contains helper functions for calculating hash code values for any group of java intrinsics.
HealthCheck	A class that can return its health status
HealthCheckClient	A simple executable class that will perform a health check query against a specific URL.
HealthProcessor
HealthProcessor.XMLHealthCheckDependencies
Helper	Helper methods for the Coherence JCache implementation.
HelpStatementBuilder	A StatementBuilder that builds the QueryPlus "HELP" command.
Holder<V>	A Holder is a reference like object, i.e. it simply holds another object.
HttpAcceptorDependenciesProcessor	An ElementProcessor to produce a HttpAcceptorDependencies from a <http-acceptor%gt; configuration.
Identifiable	An interface for access to a key of a value object
IdentifierBaseToken	IdentifierBaseToken is a token that represents an identifier
IdentifierOPToken	IdentifierOPToken is used to implement identifiers.
IdentityAsserter	IdentityAsserter validates a token in order to establish a user's identity.
IdentityExtractor<T>	Trivial ValueExtractor implementation that does not actually extract anything from the passed value, but returns the value itself.
IdentityHasher<V>	IdentityHasher provides a Hasher implementation based upon an object's identity hashCode and reference equality.
IdentityHolder<V>	A Holder implementation which additionally provides an equals/hashCode implementation based on the held object's identity.
IdentityTransformer	IdentityTransformer transforms a Subject to a token that asserts identity.
ILikeOperator	A class representing the case-insensitive "ilike" operator.
ImmutableArrayList	Implementation of the Collection Framework interface "List" in a read- only fashion on top of an array data structure.
ImmutableMultiList	Implementation of the List interface in a read-only fashion based on a collection of arrays.
IndentingWriter	An IndentingWriter is used to indent line-based output to an underlying Writer.
IndexAwareExtractor<T,E>	IndexAwareExtractor is an extension to the ValueExtractor interface that supports the creation and destruction of an index.
IndexAwareFilter<K,V>	IndexAwareFilter is an extension to the EntryFilter interface that allows a filter to use a Map index to fully or partially evaluate itself.
Indexed	An annotation that should be applied to accessor methods for the properties that need to be indexed.
InetAddressHelper	Helper class that encapsulates common InetAddress functionality.
InetAddressHelper.RoutableFilter	The RoutableFilter evaluates to true for any InetAddress which is externally routable.
InetAddressHelper.SubnetMaskFilter	SubnetMaskFilter evaluates to true for any address with matches the pattern for the masked bits
InetAddressRangeFilterBuilder	InetAddressRangeFilterBuilder defers evaluating configuration parameters until Filter is instantiated.
InetAddressSerializer	POF serializer for java.net.InetAddress.
InetSocketAddressSerializer	POF serializer for java.net.InetSocketAddress.
InFilter<T,E>	Filter which checks whether the result of a method invocation belongs to a predefined set of values.
InfixOPToken	InfixOPToken is used to implement infix operators.
InfixRightOPToken	InfixRightOPToken is used to implement infix operators that like to bind to the right which is typical of exponentiation rules.
InflatableCollection	A Collection implementation which optimizes memory consumption for collections that often contain just a single value.
InflatableCollection.InflatedCollection	A marker interface which is used to identify internally inflated Collections.
InflatableList	A List specialization of InflatableCollection.
InflatableSet	A Set specialization of InflatableCollection.
InitiatorDependenciesProcessor	An ElementProcessor that will parse an <initator-config> and produce an InitiatorDependencies.
InitParamProcessor	An InitParamProcessor is responsible for processing <init-param> XmlElements to produce Parameters.
InitParamProcessor.CacheRefExpression	An Expression implementation that represents the use of a {cache-ref} macro in a Configuration File.
InitParamProcessor.CollectionRefExpression	An Expression implementation that represents the use of a {collection-ref} macro in a Configuration File.
InitParamProcessor.DataStructureRefExpression<E>	An Expression implementation that represents the use of a {cache-ref} macro in a Cache Configuration File.
InitParamProcessor.ResourceRefExpression	An Expression implementation that represents the use of a {resource} macro in a configuration File.
InitParamProcessor.SchemeRefExpression	An Expression implementation that represents the use of a {scheme-ref} macro in a Cache Configuration File.
InitParamsProcessor	An InitParamsProcessor is responsible for processing <init-params> XmlElements to produce ResolvableParameterLists.
Injectable	Denotes that a Java Bean setter method may be injected with a value.
InjectionBinder	A binder for REST API dependencies.
InKeySetFilter<T>	Filter that limits the underlying filter evaluation only to the specified set of keys.
InOperator	A class representing the "in"operator.
InputStreaming	This is the interface represented by the Java InputStream class.
InputStreamPasswordProvider	A base class for PasswordProvider implementations that read the contents of an InputStream to obtain a password.
Inserted	A qualifier annotation used for any INSERTED event.
Inserted.Literal	An annotation literal for the Inserted annotation.
Inserting	A qualifier annotation used for any INSERTING event.
Inserting.Literal	An annotation literal for the Inserting annotation.
InsertStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a InsertStatementBuilder.InsertStatement.
InsertStatementBuilder.InsertStatement	Implementation of the CohQL "INSERT" command.
InstanceBuilder<T>	An InstanceBuilder is a ParameterizedBuilder implementation that additionally supports injection based on Coherence <instance%gt; or <class-scheme> configurations.
InstanceProcessor	An InstanceProcessor is responsible for processing <instance> XmlElements to produce ParameterizedBuilders.
Instruction	A marker interface for Instructions to FiniteStateMachines.
Instruction.ProcessEvent<S extends Enum<S>>	An Instruction for a FiniteStateMachine to process an Event.
Instruction.TransitionTo<S extends Enum<S>>	An Instruction for a FiniteStateMachine to Instruction.TransitionTo another state.
Interceptor	Interceptor is an annotation that can be applied to EventInterceptor implementations.
Interceptor.Order	This enum provides an indication of whether the EventInterceptor should request to be first in the chain of EventInterceptors, hence have a HIGH priority.
InterceptorMetadataResolver	Supports custom resolution of interceptor class in cases when the interceptor may be proxied, such as when using CDI.
InterceptorProcessor	A ElementProcessor for the <interceptor> element.
InterceptorRegistry	An InterceptorRegistry manages the registration of EventInterceptors and facilitates the introduction of EventInterceptors to EventDispatchers.
InterceptorsProcessor	A ElementProcessor for the <interceptors> element.
InternalCacheSchemeProcessor	A InternalCacheSchemeProcessor is responsible for processing an internal-cache-scheme XmlElements to produce a MapBuilder.
InternalConverter<T>	Converts values of a specified type to and from an internal representation.
InvalidConfigServiceLoadBalancerBuilder	InvalidConfigServiceLoadBalancerBuilder defers reporting configuration exception until realized.
InverseComparator<T>	InverseComparator is a wrapper comparator which simply inverses the comparison result.
InverseComparator<T>	Comparator that reverses the result of another comparator.
Invocable	The Invocable object is a cluster-portable object that can be invoked on any set of remote members and each can optionally register a return value for the invocation.
InvocableInOrder	The InvocableInOrder interface allows to control the ordering in which the results of Invocable tasks are returned back to the caller by the Invocation service with a thread pool.
InvocableMap<K,V>	An InvocableMap is a Map against which both entry-targeted processing and aggregating operations can be invoked.
InvocableMap.Entry<K,V>	An InvocableMap.Entry contains additional information and exposes additional operations that the basic Map.Entry does not.
InvocableMap.EntryAggregator<K,V,R>	An EntryAggregator represents processing that can be directed to occur against some subset of the entries in an InvocableMap, resulting in a aggregated result.
InvocableMap.EntryProcessor<K,V,R>	An invocable agent that operates against the Entry objects within a Map.
InvocableMap.ParallelAwareAggregator<K,V,P,R>	Deprecated. This interface was deprecated in Coherence 12.2.1 and might be removed in a future release.
InvocableMap.ParallelAwareAggregator.PartialResultAggregator<P>	Deprecated. This interface was deprecated in Coherence 12.2.1 and might be removed in a future release.
InvocableMap.StreamingAggregator<K,V,P,R>	A StreamingAggregator is an extension of InvocableMap.EntryAggregator that processes entries in a streaming fashion and provides better control over execution characteristics.
InvocableMapHelper	Helper methods for InvocableMap implementations and Filter related evaluation.
InvocableMapHelper.IndexAdapter	MapListener implementation that routes the map events into the corresponding MapIndex calls.
InvocableMapHelper.RoutingBinaryEntry	BinaryEntry wrapper that routes the getValue()/getBinaryValue() calls onto getOriginalValue()/getOriginalBinaryValue().
InvocableMapHelper.RoutingMapTriggerEntry	MapTrigger.Entry wrapper that routes the getValue() call onto getOriginalValue().
InvocableMapHelper.SimpleEntry<K,V>	Simple implementation of the InvocableMap.Entry interface.
InvocationObserver	The InvocationObserver is an object that asynchronously receives notification of results from the execution of Invocable objects.
InvocationScheme	The InvocationScheme class builds an Invocation service.
InvocationService	The InvocationService is a Service for delivering executable objects to cluster members for distributed invocation.
InvocationServiceProxyProcessor	An ElementProcessor that will parse invocation-service-proxy configuration element tp produce a DefaultInvocationServiceProxyDependencies object.
IsNotNullFilter<T,E>	Filter which tests the result of a method invocation for inequality to null.
IsNullFilter<T,E>	Filter which compares the result of a method invocation with null.
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.
IterableCacheLoader<K,V>	A JCache CacheLoader that can iterate its underlying contents.
IteratorEnumerator	Provide a implementation of an enumerator based on data from an Iterator.
JAASIdentityAsserter	JAAS-based implementation of IdentityAsserter.
JacksonJsonMarshaller<T>	Jackson-based marshaller that marshals object to/from JSON.
JacksonMapperProvider	Provider responsible for converting Java object to/from JSON/XML.
JaxbXmlMarshaller<T>	JAXB-based marshaller that marshals object to/from XML.
JCacheContext	Coherence JCache Context on each storage member node for JCache Cache.
JCacheEntryMetaInf	Represents the JCache metadata for a key and value pair stored in a Cache.
JCacheExtendNamespace	A NamespaceHandler to enable and enhance Coherence-based configurations to be used with the Coherence-based JCache Extend implementation
JCacheIdentifier	An internal class to represent the unique identity of a JCache cache.
JCacheNamespace	A NamespaceHandler to enable and enhance Coherence-based configurations to be used with the Coherence-based JCache implementation
JCacheStatistics	Interface for JCache Statistics.
JmxmpServer	An implementation of a Coherence MBeanServerFinder that creates a JMXConnectorServer server that uses JMXMP as its transport rather than RMI.
JsonCollectionWriter	Provider responsible for converting Java collections to a JSON formatted stream.
JsonJacksonMarshaller<T>	Deprecated. As of 12.2.1.0.0, replaced by JacksonJsonMarshaller
JsonMap	A simple wrapper around LiteMap that preserves the order of elements and adds support for POF serialization without fidelity loss in order to support JSON pass-through.
JsonMap.Serializer	POF serializer for JsonMap.
KeyAssociatedFilter<T>	Filter which limits the scope of another filter according to the key association information.
KeyAssociation<T>	A KeyAssociation represents a key object that has a natural association with another key object.
KeyAssociator	A KeyAssociator provides key associations on behalf of a set of keys.
KeyConverter	An interface that must be implemented by key converters.
KeyConverterAdapter	Marshaller that marshalls objects using a cache's key converter.
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.
KeyFilter<T>	EntryFilter which checks whether an entry key belongs to a set.
KeyPartitioningStrategy	A KeyPartitioningStrategy is a pluggable strategy for assigning keys to specific partitions.
KeyPartitioningStrategy.PartitionAwareKey	PartitionAwareKey is a well-known interface that should be respected by KeyPartitioningStrategy implementations.
KeyStoreLoader	A class that can create a KeyStore.
KeystoreProcessor	An ElementProcessor that will parse and produce a DefaultKeystoreDependencies based on a key-store configuration element.
KeyValueArrayMap	KeyValueArrayMap is a Map implementation backed by an array of keys, and an array of the associated values.
KeywordOPToken	KeywordOPToken acts like a PunctuationOPToken when used in a led role and a Identifier when used as a nud.
Latches	Factory methods for various distributed countdown latch implementations.
LeafBaseToken	LeafBaseToken is the abstract base class for all tokes processed by the low level BaseTokenScanner that are considered leaves.
LeaseGranularityProcessor	An ElementProcessor for Coherence <lease-granularity> configuration
LessEqualsFilter<T,E extends Comparable<? super E>>	Filter which compares the result of a method invocation with a value for "Less or Equals" condition.
LessEqualsOperator	A class representing the logical less than or equal to operator.
LessFilter<T,E extends Comparable<? super E>>	Filter which compares the result of a method invocation with a value for "Less" condition.
LessOperator	A class representing the logical less than or equal to operator.
LifecycleAwareEvent<S extends Enum<S>>	A LifecycleAwareEvent is a specialized Event that receives callbacks during the processing of the Event by a FiniteStateMachine.
LifecycleEvent	A LifecycleEvent encapsulates a lifecycle action that has occurred on a ConfigurableCacheFactory.
LifecycleEvent.Type	The LifecycleEvent types.
LifecycleEvents	LifecycleEventInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive LifecycleEvents.
LikeFilter<T,E>	Filter which compares the result of a method invocation with a value for pattern match.
LikeOperator	A class representing the "like" operator.
LikeOPToken	LikeOPToken is used to parse a SQL like statement.
LimitFilter<T>	Filter which truncates the results of another filter.
ListArchiverStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a ListArchiverStatementBuilder.ListArchiverStatement.
ListArchiverStatementBuilder.ListArchiverStatement	Implementation of the CohQL "LIST ARCHIVER" command.
ListBasedAddressProviderBuilder	This class builds an AddressProviderBuilder from a list of address and port.
Listeners	Provide a simple, efficient, and thread-safe implementation of a list of event listeners.
ListMap<K,V>	As of Coherence 3.2, the ListMap simply extends Java's own LinkedHashMap, which became available in JDK 1.4.
ListOpToken	ListOPToken is used to process expressions between bracketing characters such as are between "[" and "]" which should result in a list (e.g
ListServicesStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a ListServicesStatementBuilder.ListServicesStatement.
ListServicesStatementBuilder.ListServicesStatement	Implementation of the CohQL "LIST SERVICES" command.
ListSnapshotsStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a ListSnapshotsStatementBuilder.ListSnapshotsStatement.
ListSnapshotsStatementBuilder.ListSnapshotsStatement	Implementation of the CohQL "LIST SNAPSHOTS" command.
Lite	A qualifier annotation that can be applied to MapListener CDI observers to register them as lite listeners.
Lite.Literal	An annotation literal for the Lite annotation.
LiteMap<K,V>	An implementation of java.util.Map that is optimal (in terms of both size and speed) for very small sets of data but still works excellently with large sets of data.
LiteralBaseToken	LiteralBaseToken is the BaseToken that represents literals such as String, Integer, Long, Float, and Double.
LiteralExpression<T>	A LiteralExpression is a literal (aka: constant) Expression.
LiteralOPToken	LiteralOpToken is used to implement literals.
LiteSet<E>	An implementation of java.util.Set that is optimal (in terms of both size and speed) for very small sets of data but still works excellently with large sets of data.
LoadBalancer	A non-sticky HTTP load-balancer.
LoadBalancer.AddressPort	An AddressPort is an immutable combination of an IP address and a port number.
LoadBalancer.Queue	A Queue is used to effeciently queue up items for daemon threads to work on.
LoadBalancer.SocketHandler	A SocketHandler is an abstract daemon thread.
LocalAddressProcessor	An ElementProcessor that parses a <local-address> to produce an InetSocketAddress.
LocalAddressProviderBuilder	This class builds an AddressProviderBuilder from a local address.
LocalAtomicBoolean	Local implementation of AtomicBoolean interface, that simply wraps java.util.concurrent.atomic.AtomicBoolean instance.
LocalAtomicInteger	Local implementation of AtomicInteger interface, that simply wraps java.util.concurrent.atomic.AtomicInteger instance.
LocalAtomicLong	Local implementation of AtomicLong interface, that simply wraps java.util.concurrent.atomic.AtomicLong instance.
LocalAtomicMarkableReference<V>	Local implementation of AtomicMarkableReference interface, that simply wraps java.util.concurrent.atomic.AtomicMarkableReference instance.
LocalAtomicReference<V>	Local implementation of AtomicReference interface, that simply wraps java.util.concurrent.atomic.AtomicReference instance.
LocalAtomicStampedReference<V>	Local implementation of AtomicStampedReference interface, that simply wraps java.util.concurrent.atomic.AtomicStampedReference instance.
LocalCache<K,V>	An in-process local cache implementation of a Cache based on a Coherence <local-cache>.
LocalCache	A LocalCache implementation that supports the JCache API, CacheLoader and CacheStore objects.
LocalCache.EntryIterator<K,V>	JCache Entry iterator
LocalCacheAsynchronousMapListener<K,V>	MapListener for Coherence-based JCache adapter implementation to generate JCache CoherenceCacheEntryEvent.
LocalCacheAsynchronousMapListener.NonSyntheticEntryFilter	Server side filter to filter out both coherence and jcache synthetic events.
LocalCacheConfiguration<K,V>	A Configuration for a Cache based on a Coherence <local-scheme>, or more specifically an in-process NamedCache.
LocalCacheSynchronousMapListener<K,V>	Synchronous version of LocalCacheAsynchronousMapListener.
LocalCacheValue	Represents the internal Cache Entry Value with in an LocalCache.
LocalCacheValue.JCacheSyntheticKind	Synthetic Update
LocalCountDownLatch	Local implementation of CountDownLatch interface, that simply wraps java.util.concurrent.CountDownLatch instance.
LocalPermission	This class is for local (non-clustered) permissions.
LocalScheme	The LocalScheme class is responsible for building a fully configured instance of a LocalCache.
LocalSemaphore	Local implementation of Semaphore interface, that simply wraps java.util.concurrent.Semaphore instance.
Lockable	The Lockable interface is used for managing exclusive access to thread-safe classes.
Lockable.Unlockable	The Unlockable interface is used for releasing the exclusive access to this Lockable.
LockOwner	The identity of a lock owner, represented by the UID of the member, and the ID of a thread holding or attempting to acquire the lock.
Locks	Factory methods for various local and remote lock implementations.
Logger	Logging API.
LoggingPofHandler	An implementation of PofHandler that logs all of the stream contents for debugging / testing purposes.
LongArray<V>	An interface, similar in its methods to List, and similar in its purpose to a Java array, designed for sparse storage and indexed by long values.
LongArray.Iterator<V>	An Iterator that adds a "current element" concept, similar to the Map.Entry interface.
LongMax<T>	Calculates a maximum of numeric values extracted from a set of entries in a Map.
LongMin<T>	Calculates a minimum of numeric values extracted from a set of entries in a Map.
LongSum<T>	Sums up numeric values extracted from a set of entries in a Map.
Lost	A qualifier annotation used for any LOST event.
Lost.Literal	An annotation literal for the Lost annotation.
MapAdapter	A MapAdapter supports properties whose types implement the java.util.Map interface.
MapBuilder	The MapBuilder interface is used by a builder to create an instance of a Map that is a local to a Java process.
MapBuilder.Dependencies	The commonly required MapBuilder.Dependencies for realizing a Map with a MapBuilder.
MapCacheStore<K,V>	A CacheStore that sits directly on top of a Map.
MapEntryIteratorToCacheEntryIteratorAdapter<K,V>	An adapter that converts an Iterator over Map entries into an Iterator over Cache entries.
MapEvent<K,V>	An event which indicates that the content of a map has changed: an entry has been added an entry has been removed an entry has been changed A MapEvent object is sent as an argument to the MapListener interface methods.
MapEventFilter<K,V>	Filter which evaluates the content of a MapEvent object according to the specified criteria.
MapEventOutput<K,V>	MapListener implementation that converts Coherence MapEvents into Jersey Server Sent Events (SSE).
MapEventTransformer<K,V,U>	MapEventTransformer interface is used to allow an event consumer to change the content of a MapEvent destined for the corresponding MapListener.
MapEventTransformerBinding	Specifies that an annotation type is a MapEventTransformer binding type.
MapEventTransformerFactory<A extends Annotation,K,V,U>	A factory that produces instances of MapEventTransformer for a given Annotation.
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.
MapEventTransformerProducer	A CDI bean that produces MapEventTransformer instances using MapEventTransformerFactory beans annotated with MapEventTransformerBinding annotations.
MapIndex<K,V,E>	MapIndex is used to correlate values stored in an indexed Map (or attributes of those values) to the corresponding keys in the indexed Map.
MapJsonBodyHandler	A class that can serialize and deserialize Maps to and from json.
MapListener<K,V>	The listener interface for receiving MapEvents.
MapListenerProcessor	A MapListenerProcessor is responsible for processing a listener XmlElements to produce a ParameterizedBuilder for a MapListener.
MapListenerProxy	A class to encapsulate bidirectional streaming of map events for a single cache.
MapListenerProxy.DeactivationListener	NamedCacheDeactivationListener that will communicate cache truncation and destruction events over the proxy.
MapListenerProxy.FilterInfo	A holder for filter information.
MapListenerProxy.KeyConverter	Converter for cache key instances.
MapListenerProxy.WrapperPrimingListener	MapListenerSupport.PrimingListener that delegates calls to the wrapped MapListener.
MapListenerSupport	This class provides support for advanced MapListener functionality.
MapListenerSupport.FilterEvent	An extension of the CacheEvent which may carry no values (old or new), but instead holds on an array of Filter objects being the "cause" of the event.
MapListenerSupport.PrimingListener<K,V>	A tag interface indicating that this listener is registered as a synchronous listener for lite events (carrying only a key) and generates a "priming" event when registered.
MapListenerSupport.SynchronousListener<K,V>	A tag interface indicating that tagged MapListener implementation has to receive the MapEvent notifications in a synchronous manner.
MapListenerSupport.WrapperListener<K,V>	A base class for various wrapper listener classes.
MapListenerSupport.WrapperPrimingListener	A wrapper class that turns the specified MapListener into a priming listener.
MapListenerSupport.WrapperSynchronousListener<K,V>	A wrapper class that turns the specified MapListener into a synchronous listener.
MapName	A qualifier annotation used to indicate a specific map name.
MapName.Literal	An annotation literal for the MapName annotation.
MapNotFoundException	An exception to indicate that a required map does not exist.
MappedBufferManager	Manages a ByteBuffer on a file.
MappedStoreManager	An implementation of BinaryStoreManager interface that uses BinaryMap objects built on the MappedBufferManager to provide BinaryStore objects.
MapSet	An ExternalizableLite implementation of java.util.Set that uses an underlying Map object to store its data in, just as the Java HashSet implementation uses an underlying HashMap for its element storage.
MapTrigger<K,V>	MapTrigger represents a functional agent that allows to validate, reject or modify mutating operations against an underlying map.
MapTrigger.Entry<K,V>	A MapTrigger Entry represents a pending change to an Entry that is about to committed to the underlying Map.
MapTriggerListener	MapTriggerListener is a special purpose MapListener implementation that is used to register a MapTrigger on a corresponding ObservableMap.
MapViewBuilder<K,V>	The ViewBuilder provides a means to MapViewBuilder.build() a map view using a fluent pattern / style.
Marshaller<T>	An interface that must be implemented by REST marshallers.
MarshallerRegistry	Registry for marshaller instances.
MBeanAccessor	MBeanAccessor provides a means to access JMX MBeans via the Coherence Management Server (a single MBeanServer with an aggregated view of MBeans for the entire cluster).
MBeanAccessor.GetAttributes	The Remote.Function for the MBeanServerConnection.getAttributes method.
MBeanAccessor.Invoke	The Remote.Function for the MBeanServerConnection.invoke method.
MBeanAccessor.QueryBuilder	The Query Builder for generating Coherence MBean queries.
MBeanAccessor.QueryBuilder.ParsedQuery	A ParsedQuery represents the result of a call to MBeanAccessor.QueryBuilder.build().
MBeanAccessor.SetAttributes	The Remote.Function for the MBeanServerConnection.setAttributes method.
MBeanConnector	Utility class to expose Coherence JMX MBeans via the Sun JMX reference implementation HtmlAdaptorServer or a JMX Remote JMXConnectorServer.
MBeanHelper	Helper class providing various functionality related to aggregation of attributes and methods exposed by Coherence JMX framework MBeans.
MBeanHelper.QueryExpFilter	Helper class to expose a Filter object as a QueryExp.
MBeanReference	MBeanReference holds all necessary information to uniquely identify an MBean.
MBeanServerFinder	MBeanServerFinder represents a facility that allows a pluggable run-time selection of an MBeanServer to be used by the Coherence JMX framework.
MBeanServerProxy	MBeanServerProxy allows any cluster node that runs the Management service to obtain and set attributes or invoke methods on registered MBeans.
MBeanServerRegistrationUtility	A convenience class for registering CacheStatisticsMBeans with an MBeanServer.
MBeanServerRegistrationUtility.ObjectNameType	The type of registered Object
Megabytes	Megabytes is a specialized MemorySize whose default constructor assumes that the specified units (when a they are not specified) are measured in megabytes.
Member	The Member interface represents a cluster member.
MemberEvent	An event which indicates that membership has changed: a Member has joined a Member is leaving a Member has left A MemberEvent object is sent as an argument to the MemberListener interface methods.
MemberIdentity	The MemberIdentity interface represents the identity of a cluster member.
MemberIdentityProvider	A provider of values for a member's identity.
MemberListener	The listener interface for receiving MemberEvents.
MemberListenerProcessor	An ElementProcessor to process a <member-listener> to produce a List containing a single MemberListener.
MemorySizeProcessor	A MemorySizeProcessor is responsible for processing Coherence memory sizes and returning them in bytes.
MessageDeliveryModeProcessor	An ElementProcessor for JMS <message-delivery-mode> configurations.
MethodInvocationProcessor<K,V,R>	An entry processor that invokes specified method on a value of a cache entry and optionally updates the entry with a modified value.
MetricsLabels	The MetricsLabels descriptor annotation adds a metrics.labels field and its value to the descriptor for a method on an MBean.
MetricsScope	The MetricsScope descriptor annotation adds a metrics.scope field and its value to the descriptor for an MBean.
MetricsTag	The MetricsTag descriptor annotation adds a metrics.tag field and its value to the descriptor for a method on an MBean.
MetricsValue	The MetricsValue descriptor annotation adds a metrics.value field and its value to the descriptor for a method on an MBean.
Millis	Millis is a specialized Duration whose default constructor assumes that the specified units of time (when the unit magnitude is not specified) are milliseconds.
MillisProcessor	A MillisProcessor is responsible for processing Coherence time values and returning them in milliseconds.
MirroringAssignmentStrategy	A PartitionAssignmentStrategy used by a service to attempt to co-locate the primary ownership of partitions on the same members as another service.
Model<S extends Enum<S>>	A Model represents the definition of a FiniteStateMachine, the set of known states, Transitions between said states and StateEntryActions / StateExitActions to be performed when said states are changed.
MpMetricsRegistryAdapter	An implementation of MetricsRegistryAdapter registers Coherence metrics with Helidon's vendor or application registry.
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.
MultiBufferWriteBuffer	The MultiBufferWriteBuffer is used to present a single WriteBuffer that collects together a sequence of underlying WriteBuffer objects, and which grows by allocating additional WriteBuffer objects as necessary.
MultiBufferWriteBuffer.WriteBufferPool	A WriteBufferPool is used to dynamically allocate WriteBuffer objects as the MultiBufferWriteBuffer requires them.
MultiByteArrayInputStream	Reads binary data from a series of byte arrays.
MultiByteArrayOutputStream	An OutputStream that accumulates the written data to a series of byte arrays that do not exceed a specified size.
MultiExtractor	Composite ValueExtractor implementation based on an array of extractors.
MultiplexingMapListener<K,V>	A base class that simplifies the implementation of a MapListener by multiplexing all events into a single listener method.
MultiplexingSerializer	A Serializer implementation that multiplexes serialization/deserialization requests across multiple Serializer implementations.
MultiplexingSerializer.SerializationHeader	Simple wrapper class to hold decorated info added by the serialization process.
MultiplicationOperator	An operator representing the mathematical multiplication operation.
MutableLong	A Long like class which supports mutation.
MvelExtractor	MVEL-based ValueExtractor implementation.
MvelHelper	Enable Mvel to be optional by only accessing module via reflection with implementation provided on classpath.
MvelManipulator	MVEL-based ValueManipulator implementation.
MvelUpdater	MVEL-based ValueUpdater implementation.
Name	A qualifier annotation used when injecting Coherence resource to indicate a specific resource name.
Name.Literal	An annotation literal for the Name annotation.
NamedCache<K,V>	A Map-based data-structure that manages entries across one or more processes.
NamedCacheBuilder	A NamedCacheBuilder realizes NamedCaches.
NamedCacheProducer	A CDI producer for NamedCache, AsyncNamedCache and ContinuousQueryCache instances.
NamedCacheService	A NamedCache service.
NamedCacheService.DefaultDependencies	The default NamedCacheService.Dependencies implementation.
NamedCacheService.Dependencies	The dependencies to configure a NamedCacheServiceImpl.
NamedCacheServiceGrpcImpl	A plain gRPC implementation of NamedCache service.
NamedCacheServiceImpl	A gRPC NamedCache service.
NamedCollection	NamedCollection defines a common base interface for various named collection types.
NamedCollection.Option	The Option interface defines the root interface of all NamedCollection Options.
NamedCollectionBuilder<C extends NamedCollection>	A NamedCollectionBuilder realizes NamedCollections.
NamedEventInterceptor<E extends Event<?>>	A wrapper for EventInterceptors allowing additional metadata to be associated with the interceptor without augmenting the interceptor contract.
NamedEventInterceptorBuilder	An NamedEventInterceptorBuilder facilitates the construction of a NamedEventInterceptor, which wraps an EventInterceptor.
NamedMap<K,V>	A Map-based data-structure that manages entries across one or more processes.
NamedMap.Option	An immutable option for requesting and configuring NamedMaps.
NamedQuery	Holder for configured named query data.
NamedQueryResource	REST resource representing a set of filtered cache entries.
NamedResourceBuilder<T>	A ParameterizedBuilder that resolves a named resource from the cluster's ResourceRegistry.
NamedSerializerFactory	A factory that produces Serializer instances for a given name.
NamedTopic<V>	NamedTopic represents a topic entity for publish/subscribe messaging.
NamedTopic.ElementCalculator	A unit calculator is an object that can calculate the cost of storing an element in a topic.
NamedTopicProducer	A CDI producer for NamedTopic, Publisher and Subscriber instances.
NamedTopicScheme	The TopicScheme class is responsible for building a fully configured instance of a NamedTopic.
NameService	A NameService is a service that accepts connections from external clients (e.g.
NameService.LookupCallback	An object which implements NameService.LookupCallback can be registered with a NameService via NameService.addLookupCallback(com.tangosol.net.NameService.LookupCallback) to perform a lookup on names that were not found in the NameService's directory.
NameService.RequestContext	An object which implements NameService.RequestContext stores information about the NameService request.
NameService.Resolvable	During the lookup call, if the retrieved object is NameService.Resolvable, then the result of the resolve call is returned.
NamespaceHandler	A NamespaceHandler is responsible for defining the DocumentPreprocessor, ElementProcessors and AttributeProcessors required for processing xml content belonging to a specific xml namespace used in an xml document.
NaturalAssociator	NaturalAssociator provides an Associator implementation for objects that implement the Associated interface.
NaturalCloner	A Cloner that clones Cloneable objects.
NaturalComparator<T extends Comparable<T>>	NaturalComparator is a comparator which simply delegates to a Comparable object's compare implementation.
NaturalHasher<V>	NaturalHasher provides a Hasher implementation based upon an object's internal hashCode and equals implementation.
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.
NearScheme	The NearScheme is used to realize (create) an instance of a NearCache.
NestedBaseTokens	NestedBaseTokens is a token that holds a sequence of tokens as well as the two bracketing characters.
NestingOPToken	NestingOPToken is an abstract classused to implement parsing situation where some nesting is implied.
NeverFilter<T>	Filter which always evaluates to false.
NioFileManagerBuilder	The NioFileManagerBuilder class builds an instance of a MappedStoreManager.
NodeTerm	NodeTerm is the class used to represent trees of Terms that can have children.
NonBlocking	NonBlocking allows a thread to mark itself as non-blocking and should be exempt from things such as flow-control pauses using a try-with-resource pattern.
NonBlockingEntryStore<K,V>	NonBlockingEntryStore provides a means to integrate Coherence with an underlying data source that offers a non-blocking API.
NonBlockingFiniteStateMachine<S extends Enum<S>>	An NonBlockingFiniteStateMachine is a specialized FiniteStateMachine implementation that performs transitions asynchronously to the threads that request state changes.
NonBlockingFiniteStateMachine.CoalescedEvent<S extends Enum<S>>	A NonBlockingFiniteStateMachine.CoalescedEvent is a LifecycleAwareEvent that coalesces other (wrapped) Events with the same discriminator so that only one Event actually executes.
NonBlockingFiniteStateMachine.CoalescedEvent.Discriminator	A NonBlockingFiniteStateMachine.CoalescedEvent.Discriminator is an object that is used to uniquely differentiate events to be coalesced, scoped by a NonBlockingFiniteStateMachine.
NonBlockingFiniteStateMachine.CoalescedEvent.Process	The NonBlockingFiniteStateMachine.CoalescedEvent to process.
NonBlockingFiniteStateMachine.DefaultTaskDependencies	Implementation of Dependencies for Task
NonBlockingFiniteStateMachine.DelayedTransitionTo<S extends Enum<S>>	A NonBlockingFiniteStateMachine.DelayedTransitionTo is a specialized Instruction for NonBlockingFiniteStateMachines that enables a StateEntryAction to request a delayed transition to another state, unlike a Instruction.TransitionTo Instruction which occurs immediately.
NonBlockingFiniteStateMachine.ProcessEventLater<S extends Enum<S>>	A specialized Instruction for NonBlockingFiniteStateMachines that enables a StateEntryAction to request an Event to be processed at some point in the future.
NonBlockingFiniteStateMachine.SubsequentEvent<S extends Enum<S>>	A NonBlockingFiniteStateMachine.SubsequentEvent is an Event that ensures that another (wrapped) Event to occur if an only if the FiniteStateMachine is at a certain transition count.
NonBlockingFiniteStateMachine.TaskDependencies	Dependencies for Task.
NonBlockingInvocable	NonBlockingInvocable is an Invocable that can be executed asynchronously.
NonBlockingTcpDatagramSocket	TCP based non-blocking datagram socket implementation.
NonBlockingTcpDatagramSocket.Impl	A specialization of TcpDatagramSocket.Impl which provides non-blocking functionality, see NonBlockingTcpDatagramSocket.Impl.send(DatagramPacket).
NonSyntheticEntryFilter<T>	Server side filter to filter out both coherence and jcache synthetic events.
NoOpElementProcessor	An ElementProcessor that does nothing.
NotEqualsFilter<T,E>	Filter which compares the result of a method invocation with a value for inequality.
NotEqualsOperator	A class representing the not equals operator.
NotFilter<T>	Filter which negates the results of another filter.
Notification	The Notification annotation provides a means for an MBean interface to describe the notification it emits.
NotificationManager	A NotificationManager is responsible for JMX notification delivery from a managed node to a set of subscribing managing nodes.
Notifier	A Condition-like object, used to block thread(s) for a notification.
NotOPToken	NotOPToken is used to implement not operators.
NullFilter	Filter which discards null references.
NullImplementation	A collection of classes that do nothing.
NullImplementation.NullActionPolicy	An implementation of an ActionPolicy that allows all actions.
NullImplementation.NullAddressProvider	Null implementation of AddressProvider.
NullImplementation.NullBackingMapManagerContext	An implementation of BackingMapManagerContext that does nothing.
NullImplementation.NullCacheStore	An implementation of an CacheStore that does nothing.
NullImplementation.NullCollector<V>	A Collector implementation that does nothing.
NullImplementation.NullContinuation<R>	A Continuation that does nothing.
NullImplementation.NullConverter	A Converter that does nothing.
NullImplementation.NullDeltaCompressor	An implementation of a DeltaCompressor that does nothing and always returns the new stream.
NullImplementation.NullEntryProcessor	An implementation of an EntryProcessor that does nothing and returns Boolean.TRUE as a result of execution.
NullImplementation.NullEnumerator	An empty enumerator.
NullImplementation.NullLongArray<V>	An immutable empty LongArray
NullImplementation.NullMap	A Map that contains nothing and does nothing.
NullImplementation.NullMemberIdentityProvider	An implementation of a MemberIdentityProvider that returns null for all its methods.
NullImplementation.NullObservableMap	An immutable ObservableMap which contains nothing.
NullImplementation.NullOutputStream	An OutputStream that does basically nothing.
NullImplementation.NullPartitionAssignmentStrategy	An implementation of PartitionAssignmentStrategy that does nothing.
NullImplementation.NullPersistenceEnvironment<R>	A PersistenceEnvironment that does nothing.
NullImplementation.NullPersistenceManager<R>	A PersistenceManager that does nothing.
NullImplementation.NullPersistentStore<R>	A PersistentStore that does as little as possible.
NullImplementation.NullPofContext	An implementation of PofContext that does nothing.
NullImplementation.NullPofHandler	An implementation of PofHandler that does nothing.
NullImplementation.NullReader	A reader that does basically nothing.
NullImplementation.NullResourceRegistry	A ResourceRegistry implementation that does nothing.
NullImplementation.NullSet	An immutable set which contains nothing.
NullImplementation.NullValueExtractor	A ValueExtractor that always results in the passed-in value.
NullImplementation.NullWriter	A writer that does basically nothing.
NullParameterResolver	A NullParameterResolver is a ParameterResolver that always resolves named Parameters to null.
NumberIncrementor<K,V,N extends Number>	The NumberIncrementor entry processor is used to increment a property value of a Number type.
NumberIncrementorFactory	ProcessorFactory that can be used to create a NumberIncrementor.
NumberMultiplier<K,V,N extends Number>	The NumberMultiplier entry processor is used to multiply a property value of a Number type.
NumberMultiplierFactory	ProcessorFactory that can be used to create a NumberMultiplier.
ObjectNameExcludeFilter	Filter used to prevent registering MBeans that match the specified pattern.
Objects	Class for providing comparison functionality.
ObjectStreamFactory	Provides the means to create ObjectInput and ObjectOutput streams based on primitive data streams in a layered, pluggable fashion.
ObjectWriter	Provider responsible for marshalling Java objects.
ObservableCachingScheme	An ObservableCachingScheme is a CachingScheme that supports defining and adding MapListeners to realized Maps and NamedCaches.
ObservableHashMap<K,V>	An ObservableMap implementation that extends the SafeHashMap.
ObservableMap<K,V>	ObservableMap interface represents an object with a model being a Map that allows for pluggable notifications for occurring changes.
ObservableSplittingBackingCache	The ObservableSplittingBackingCache is an implementation of the ConfigurableCacheMap interface that works as an observable backing map in a partitioned system.
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.
ObservableSplittingBackingMap	An observable, cache-aware PartitionAwareBackingMap implementation.
OldCache	Deprecated. As of Coherence 3.1, use LocalCache instead
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.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.
OldCache.UnitCalculator	A unit calculator is an object that can calculate the cost of caching an object.
OpenHashMap<K,V>	An implementation of Map that is optimized for memory footprint.
OpenHashSet<E>	An implementation of Set that is optimized for memory footprint.
OpenMBeanHelper	A set of utility method for dealing with OpenMBean APIs because they stupidly have constructors that throw exceptions.
OperationalConfigNamespaceHandler	The OperationalConfigNamespaceHandler is responsible for capturing and creating the Coherence operational configuration when processing a Coherence operational configuration file.
OperationalConfigNamespaceHandler.Extension	Implementations of OperationalConfigNamespaceHandler.Extension are able to modify the OperationalConfigNamespaceHandler before it is used.
OperationalContext	OperationalContext is an interface for providing Oracle Coherence operational configuration.
OperationalDefaultsPreprocessor	A OperationalDefaultsPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that introduces (via cloning) default xml content for xml elements where the said content is missing.
OperationBundlingProcessor	A OperationBundlingProcessor is responsible for processing an operation-bundling XmlElement to produce an BundleManager.
OperatorBaseToken	OperatorBaseToken is a token that represents a known operator.
OPException	OPExpression is the RuntimeException thrown by the OPParser and OPScanner when problems are detected.
OPParser	OPParser is the parser class for the Top Down Operator Presidence Parsing framework.
OPScanner	OPScanner gives clients a streaming api that returns a next OPToken by processing a java.lang.String using a TokenTable to convert lower level BaseTokens into the high functionality OPTokens.
OptimisticScheme	The OptimisticScheme class builds an optimistic cache.
OptionalDoubleSerializer	POF serializer for java.util.OptionalDouble.
OptionalIntSerializer	POF serializer for java.util.OptionalInt.
OptionalLongSerializer	POF serializer for java.util.OptionalLong.
OptionalSerializer	POF serializer for java.util.Optional.
OPToken	OPToken is the root class for the Top Down Operator Precedence Parsing framework's tokens.
OrFilter	Filter which returns the logical "or" of two other filters.
OrOperator	A class representing the logical OR operator.
OutputStreaming	This is the interface represented by the Java OutputStream 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).
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.
OverflowScheme	The OverflowScheme is used to create an instance of an OverflowMap or a SimpleOverflowMap.
OverrideProcessor	A OverrideProcessor is responsible for processing override config elements and merging the elements with the Document root elements.
Ownership	Ownership is a light-weight data structure that contains a partition ownership information.
PackedDataInputStream	This is an imitation DataInputStream class that reads from streams that were produced by a corresponding PackedDataOutputStream.
PackedDataOutputStream	This is an imitation DataOutputStream class that packs its data tighter using variable-length integers and supports UTF longer than 64KB.
PagedExternalScheme	The PagedExternalScheme class is responsible for building a fully configured instance of a PagedExternalCache.
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.
PagedIterator.Advancer	Advancer is a pluggable component that knows how to load a new page (Collection) of objects to be used by the enclosing PagedIterator.
PagedQueryHelper	A helper class for cache key set and entry set paged queries.
PagedTopicScheme	A PagedTopicScheme is responsible for building a topic.
PagedTopicSchemeProcessor	An ElementProcessor that parses a <paged-topic-scheme> element; produces a PagedTopicScheme.
PagedTopicService	A TopicService which provides globally ordered topics.
PagedTopicStorageScheme	A scheme that builds the inner scheme of the backing map scheme of a topic.
Parameter	A Parameter represents an optionally named and optionally explicitly typed Expression.
ParameterizedBuilder<T>	A ParameterizedBuilder is an implementation of the classic Builder Pattern that utilizes a ParameterResolver to resolve any required runtime Parameters necessary for realizing an object.
ParameterizedBuilder.ReflectionSupport	Deprecated.
ParameterizedBuilderHelper	The ParameterizedBuilderHelper defines helper methods for ParameterizedBuilder implementations.
ParameterizedBuilderRegistry	A registry of strongly typed and possibly named ParameterizedBuilders.
ParameterizedBuilderRegistry.Registration<T>	Defines a single ParameterizedBuilder registration with a ParameterizedBuilderRegistry.
ParameterList	An ParameterList is a strictly ordered and Iterable collection of Parameters.
ParameterMacroExpression<T>	A ParameterMacroExpression is an Expression representing the use of a Coherence Parameter Macro, typically occurring with in a Coherence Cache Configuration file.
ParameterMacroExpressionParser	A ParameterMacroExpressionParser is an ExpressionParser for Coherence Parameter Macros.
ParameterResolver	A ParameterResolver provides a mechanism resolve and lookup named Parameters.
ParamTypeProcessor	A ParamTypeProcessor is responsible for processing <param-type> XmlElements to produce a fully qualified class name.
ParenOPToken	ParenOPToken is used to process expressions that are between "(" and ")".
PartialObject	Base class for dynamically generated partial classes.
PartialObject.PartialClassLoader	Class loader implementation that is used to define and load partial classes.
ParticipantName	A qualifier annotation used to indicate a specific participant name.
ParticipantName.Literal	An annotation literal for the ParticipantName annotation.
PartitionAssignmentStrategy	A PartitionAssignmentStrategy is a pluggable strategy used by a PartitionedService to manage partition distribution.
PartitionAssignmentStrategyBuilder	The PartitionAssignmentStrategyBuilder builds a PartitionAssignmentStrategy.
PartitionAssignmentStrategyProcessor	An ElementProcessor to process a <partition-assignment-strategy> to produce a PartitionAssignmentStrategy.
PartitionAwareBackingMap	In a partitioned configuration, backing maps that implement the PartitionAwareBackingMap interface are able to react to the partition life-cycle (a partition showing up on a node, or moving away from a node) and manage data more efficiently as a result.
PartitionedCache<K,V>	JCache of Key, Value pairs implemented over distributed cache.
PartitionedCache.EntryIterator<K,V>	JCache Entry iterator
PartitionedCacheAsynchronousMapListener<K,V>	MapListener for coherence cache to implement jcache map events.
PartitionedCacheAsynchronousMapListener.NonSyntheticEntryFilter	NonSyntheticEntryFilter
PartitionedCacheBinaryEntryStore<K,V>	Generic Coherence BinaryEntryStore for Coherence JCache Adapter.
PartitionedCacheConfiguration<K,V>	A Configuration for a Cache based on a Coherence <distributed-scheme> or more specifically a partitioned (aka: distributed) NamedCache.
PartitionedCacheConfigurationMapListener	MapListener for meta-information about JCache PartitionedCache instances.
PartitionedCacheDispatcher	A PartitionedCacheDispatcher raises the following server-side Events pertaining to backing-map operations: CacheLifecycleEvents EntryEvents EntryProcessorEvents
PartitionedCacheQuorumPolicyBuilder	Defer cache configuration validation of an ActionPolicy until realized.
PartitionedCacheSynchronousMapListener<K,V>	Synchronous version of PartitionedCacheAsynchronousMapListener.
PartitionedCacheSyntheticDeleteMapListener<K,V>	MapListener for coherence cache to generate JCache ExpiryEvents.
PartitionedCacheSyntheticDeleteMapListener.JCacheExpiryEntryFilter<T>	Server side filter for JCache ExpiryCacheEvents.
PartitionedFilter<T>	Filter which limits the scope of another filter to those entries that have keys that belong to the specified partition set.
PartitionedIterator<T>	An Iterator that iterates over keys in a partition-by-partition or member-by-member manner.
PartitionedJCacheStatistics	compute cache statistics across all storage-enabled data members.
PartitionedJCacheStatistics.CacheStatisticsExtractor	Get CacheStatistics from binEntry's context for JCache id.
PartitionedJCacheStatistics.PartitionedCacheStatisticsAggregator	Collect JCache CacheStatistics from all storage-enabled members.
PartitionedJCacheStatistics.PartitionedCacheStatisticsClear	Clear JCache CacheStatistics from all storage-enabled members.
PartitionedQuorumPolicyProcessor	An ElementProcessor that will parse a <partitioned-quorum-policy-scheme> and produce a suitable ActionPolicy
PartitionedService	A PartitionedService is aware of a mapping of keys to partitions and of partitions to cluster members.
PartitionedService.PartitionedAction	PartitionedAction represents a type of action taken by a PartitionedService.
PartitionedService.PartitionRecoveryAction	A PartitionedAction representing the recovery of orphaned partitions from the persistent storage, or the assignment of empty partitions if the persistent storage is unavailable or lost.
PartitionedServiceDispatcher	A PartitionedServiceDispatcher dispatches Events from a PartitionedService.
PartitionEvent	The PartitionEvent carries information about an event related to one or more partitions.
PartitionListener	The listener interface for receiving PartitionEvents.
PartitionListenerProcessor	An ElementProcessor to process a <partition-listener> to produce a List containing a single PartitionListener.
PartitionSet	PartitionSet is a light-weight data structure that represents a set of partitions that are used in parallel processing.
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.
PartitionSplittingBackingMap.MapArray	The MapArray is a data structure that provides a mapping between partition IDs and backing maps.
PartitionStatistics	PartitionStatistics encapsulates the statistics gathered for a given partition in a PartitionedService.
PassThroughCache<K,V>	A Cache that delegates (ie: passed-through) requests directly onto an existing Coherence NamedCache.
PassThroughCacheConfiguration<K,V>	A Configuration for a Cache based on an existing Coherence NamedCache.
PassThroughCacheEntryEvent<K,V>	An implementation of a CacheEntryEvent based on an underlying Coherence MapEvent.
PassThroughFilterAdapter<K,V>	An Coherence Filter that delegates MapEvents onto a CacheEntryEventFilter.
PassThroughListenerRegistration<K,V>	Captures the Coherence-based MapListener and MapEventFilter instances used for a CacheEntryListenerConfiguration
PassThroughMapListenerAdapter<K,V>	An internal MapListener implementation that delegates MapEvents onto a CacheEntryListener.
PassThroughResourceConfig	An alternate ResourceConfig implementation that supports pass-through access to all the caches defined by the cache configuration.
PassThroughRootResource	An alternate ResourceConfig implementation that supports pass-through access to all the caches defined by the cache configuration.
PasswordProvider	PasswordProvider allows Coherence users to plug in their own mechanism to determine the appropriate password.
PasswordProviderBuilderProcessor	An ElementProcessor for <password-provider> elements defined by a Coherence Operational Configuration file.
PasswordProviderBuilderProcessor.DefaultPasswordProvider	This class is to wrap the existing password into the password-provider approach.
PasswordProvidersProcessor	A PasswordProvidersProcessor is responsible for processing <password-providers> XmlElement of Coherence Operational Configuration files
PasswordURLProcessor	The PasswordURLProcessor is responsible for processing the <password-url> XmlElement in a Coherence configuration file.
PathOPToken	PathOPToken is used to implement dereferencing paths where you have a sequence of identifiers or function calls seperated by a path separator.
PeekOPToken	A PeekOPToken is a token that contains other OPToken instances.
PermissionInfo	PermissionInfo holds the information needed to validate and respond to a security related request.
PermitAcquirer	The identity of a acquirer, represented by the UUID of the member, and the ID of a thread holding or attempting to acquire permit.
Permits	A qualifier annotation used when injecting Coherence resource to specify the permits count.
Permits.Literal	An annotation literal for the Permits annotation.
PersistenceEnvironmentInfo	Interface that exposes management attributes for a PersistenceEnvironment.
PersistenceEnvironmentParamBuilder	Build a PersistenceEnvironment.
PersistenceEnvironmentParamBuilder.PersistenceEnvironmentInfo	A PersistenceEnvironmentInfo implementation that exposes the active, snapshot and trash directories, in addition to the persistence mode.
PersistenceEnvironmentsProcessor	An ElementProcessor for the <persistence-environments%gt; element of Coherence Operational Configuration files.
PersistenceEnvironmentsProcessor.PersistenceEnvironmentProcessor	An ElementProcessor for children elements of <persistence-environments%gt; element of Coherence Operational Configuration files.
PersistenceManagerMBean	Standard MBean interface that exposes management attributes and operations relating to a PartitionedService configured with on-demand or active persistence.
PersistenceProcessor	An ElementProcessor that will parse a <persistence> element to produce a PersistenceDependencies instance.
Ping	Ping is a simple utility for testing if a machine is reachable.
PofAnnotationSerializer<T>	A PofAnnotationSerializer provides annotation based de/serialization.
PofArray	PofArray is a PofValue implementation for arrays.
PofBufferReader	PofReader implementation that reads POF-encoded data from a BufferInput.
PofBufferReader.IdentityHolder
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.
PofBufferWriter	PofWriter implementation that writes POF-encoded data to a BufferOutput.
PofBufferWriter.ReferenceLibrary	A "library" of object references and their corresponding identities in the POF stream.
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.
PofCollection	PofCollection is PofValue implementation for collections.
PofConfigProvider	A provider of POF configuration URIs to load into a ConfigurablePofContext.
PofConstants	The constants related to POF streams.
PofContext	The PofContext interface represents a set of user types that can be serialized to and deserialized from a POF stream.
PofDeltaCompressor	A DeltaCompressor implementation that works with Portable Object Format (POF) values.
PofDeltaCompressor.ChangeTracker	When determining a delta between two POF buffers, the ChangeTracker keeps track of whether the current location within the two POF streams is part of a differing portion or part of an identical portion.
PofExtractor	A ExtractorBinding annotation representing a PofExtractor.
PofExtractor<T,E>	POF-based ValueExtractor implementation.
PofExtractor.Extractors	A holder for the repeatable PofExtractor annotation.
PofExtractor.Extractors.Literal	An annotation literal for the PofExtractor.Extractors annotation.
PofExtractor.Literal	An annotation literal for the PofExtractor annotation.
PofHandler	This interface defines the handler for an event-driven approach to parsing (or assembling) a POF stream.
PofHelper	Collection of helper methods for POF streams.
PofHelper.ReadableEntrySetMap	Map implementation backed by a List of Map.Entry objects.
PofHelper.WriteableEntrySetMap	Immutable Map implementation backed by a Set of Map.Entry objects.
PofInputStream	An ObjectInput implementation suitable for reading Externalizable and ExternalizableLite objects from a POF stream, although without support for schema evolution and other advanced POF features.
PofNavigationException	PofNavigationException indicates a failure to navigate a PofValue hierarchy.
PofNavigator	The PofNavigator interface represents an algorithm for navigating a PofValue hierarchy in order to locate a contained PofValue for extraction, modification or removal purposes.
PofOutputStream	An ObjectOutput implementation suitable for writing Externalizable and ExternalizableLite objects to a POF stream, although without support for schema evolution and other advanced POF features.
PofParser	A "push" parser (event-based parser) for ripping through a POF stream and delivering the contents as events to a PofHandler object.
PofPrincipal	Generic Principal implementation that can be used to represent the identity of any remote entity.
PofReader	The PofReader interface provides the capability of reading a set of non-primitive Java types ("user types") from a POF stream as an ordered sequence of indexed properties.
PofReflectionHelper	Collection of helper methods for POF reflection.
PofReflectionHelper.NavigatorAndType
PofSerializer<T>	The PofSerializer interface provides the capability of reading and writing a Java object from and to a POF stream.
PofSerializerPreprocessor	A PofSerializerPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that replaces any occurrence of <serializer>pof</serializer> with a ConfigurablePofContext configuration, passing in the provided POF configuration URI in the initialization parameters.
PofSparseArray	PofSparseArray is PofValue implementation for sparse arrays.
PofSparseArray.NilPofValue	NilPofValue represents a value that does not exist in the original POF stream.
PofUniformArray	PofUniformArray is PofValue implementation for uniform arrays.
PofUniformCollection	PofUniformCollection is PofValue implementation for uniform collections.
PofUniformSparseArray	PofUniformSparseArray is PofValue implementation for uniform sparse arrays.
PofUpdater	POF-based ValueUpdater implementation.
PofUserType	PofUserType is PofValue implementation for user types.
PofValue	PofValue represents the POF data structure in a POF stream, or any sub-structure or value thereof.
PofValueParser	Parses POF-encoded binary and returns an instance of a PofValue wrapper for it.
PofWriter	The PofWriter interface provides the capability of writing a set of non-primitive Java types ("user types") to a POF stream as an ordered sequence of indexed properties.
Pollable<E>	The Pollable interface describes a component which supports element removal.
Portable	Deprecated. Since Coherence 14.1.2.
PortableException	A PortableException is an exception that allows information about a remote exception or error to be serialized and deserialized to/from a POF stream.
PortableObject	The PortableObject interface is implemented by Java classes that can self- serialize and deserialize their state to and from a POF data stream.
PortableObjectSerializer	PofSerializer implementation that supports the serialization and deserialization of any class that implements PortableObject to and from a POF stream.
PortableProperty	Deprecated. Since Coherence 14.1.2.
PortableTypeSerializer<T>	A PofSerializer implementation that serializes classes that implement PortableObject interface (and optionally EvolvableObject interface).
Position	An opaque representation of the position of an element within a channel of a topic.
Predicate<T>	Predicate represents a boolean test of an object.
PredicateFilter<T,E>	A java.util.function.Predicate based ExtractorFilter.
PrefixOPToken	PrefixOPToken is used to implement prefix operators.
PreloadRequest<K,V>	PreloadRequest is a simple EntryProcessor that performs a Entry.getValue call.
PresentFilter<T>	Filter which returns true for InvocableMap.Entry objects that currently exist in a Map.
PrimitiveArrayAdapter	A PrimitiveArrayAdapter supports arrays of primitive types, such as "int", "char", etc.
PrimitiveArrayAdapter.BooleanArrayAdapter	A PropertyAdapter supporting boolean[].
PrimitiveArrayAdapter.ByteArrayAdapter	A PropertyAdapter supporting byte[].
PrimitiveArrayAdapter.CharArrayAdapter	A PropertyAdapter supporting char[].
PrimitiveArrayAdapter.DoubleArrayAdapter	A PropertyAdapter supporting double[].
PrimitiveArrayAdapter.FloatArrayAdapter	A PropertyAdapter supporting float[].
PrimitiveArrayAdapter.IntArrayAdapter	A PropertyAdapter supporting int[].
PrimitiveArrayAdapter.LongArrayAdapter	A PropertyAdapter supporting long[].
PrimitiveArrayAdapter.ShortArrayAdapter	A PropertyAdapter supporting short[].
PrimitiveSparseArray	A data structure resembling a long array indexed by long values.
PrimitiveSparseArray.PrimitiveNode	Node mapping long key to Object value.
PrincipalPofSerializer	PofSerializer implementation that can serialize and deserialize a Principal to/from a POF stream.
PriorityAggregator<K,V,P,R>	PriorityAggregator is used to explicitly control the scheduling priority and timeouts for execution of EntryAggregator-based methods.
PriorityComparator<T>	A Comparator that orders values that are annotated with the Priority annotation.
PriorityFilter<T>	PriorityFilter is used to explicitly control the scheduling priority and timeouts for execution of filter-based methods.
PriorityProcessor<K,V,T>	PriorityProcessor is used to explicitly control the scheduling priority and timeouts for execution of EntryProcessor-based methods.
PriorityTask	The PriorityTask interface allows to control the ordering in which a service schedules tasks for execution using a thread pool and limit their execution times to a specified duration.
PrivateKeyLoader	A class that can create a PrivateKey.
ProcessingContext	A ProcessingContext provides contextual information concerning the processing of content in an xml document.
Processor	A qualifier annotation used to indicate processor class when observing EntryProcessorEvents.
Processor.Literal	An annotation literal for the Processor annotation.
ProcessorConfig	The ProcessorConfig class encapsulates information related to a Coherence REST EntryProcessor configuration.
ProcessorFactory<K,V,R>	A factory for processors.
ProcessorRegistry	A registry for ProcessorFactory instances.
Processors	Simple InvocableMap.EntryProcessor DSL.
PropertiesParameterResolver	A PropertiesParameterResolver is a ParameterResolver that is based on a Properties instance.
PropertyAdapter	The PropertyAdapter is the base class for handling the operations that can occur on any property.
PropertyExtractor	A ExtractorBinding annotation representing a UniversalExtractor.
PropertyExtractor.Extractors	A holder for the repeatable PropertyExtractor annotation.
PropertyExtractor.Extractors.Literal	An annotation literal for the PropertyExtractor.Extractors annotation.
PropertyExtractor.Literal	An annotation literal for the PropertyExtractor annotation.
PropertyManipulator<V,R>	PropertyManipulator is a reflection based ValueManipulator implementation based on the JavaBean property name conventions.
PropertyProcessor<K,V,R>	PropertyProcessor is a base class for EntryProcessor implementations that depend on a ValueManipulator.
PropertySet<T>	Represents a set of named properties and allows the extraction of those properties from a target object.
PropertySpec	Specification for a single property.
ProviderProcessor	An ElementProcessor that will parse and produce a ProviderBuilder based on a provider configuration element.
Proxyable<T>	An interface that should be implemented by the classes that are able to create a client-side proxy for itself.
ProxyQuorumPolicyBuilder	Defer cache configuration validation of a ProxyQuorumPolicy until realized.
ProxyQuorumPolicyProcessor	An ElementProcessor that will parse a <proxy-quorum-policy-scheme> and produce a suitable ActionPolicy
ProxyScheme	The ProxyScheme class builds a Proxy scheme.
ProxyService	A ProxyService is a clustered service that accepts connections from external clients (e.g.
ProxyService.ProxyAction	ProxyAction represents a type of action taken by a ProxyService.
ProxyServiceLoad	A ProxyServiceLoad encapsulates information about the current utilization of a ProxyService.
ProxyServiceLoadBalancer	A ProxyServiceLoadBalancer is a pluggable strategy for controlling the client load across individual members of a clustered ProxyService.
ProxyServiceLoadBalancerBuilder	ProxyServiceLoadBalancerBuilder defers evaluating configuration parameters until ServiceLoadBalancer is instantiated.
Publisher<V>	Publisher provides a means to publish values to the NamedTopic.
Publisher.FailOnFull	The FailOnFull option indicates that the CompletableFuture returned from the Publisher.publish(V) operation should complete exceptionally upon identifying that the topic is or has become full.
Publisher.OnFailure	This option controls how a Publisher handles a failure of an individual Publisher.publish(V) call.
Publisher.Option<V>	A marker interface to indicate that a class is a valid Publisher.Option for a Publisher.
Publisher.Orderable	Orderable represents a value published by Publisher that has a natural ordering.
Publisher.OrderBy<V>	The OrderBy option specifies the ordering of async operations with respect to one another.
Publisher.OrderById<V>	Publisher.OrderBy option ensures ordering of sent values across all threads which share the same orderId.
Publisher.OrderByNone<V>	Publisher.OrderBy option enforces no specific ordering between sent values allowing for the greatest level of parallelism.
Publisher.OrderByRoundRobin<V>	Publisher.OrderBy option which computes the unit-of-order such that each message is sent to the next channel in a round-robin order.
Publisher.OrderByThread<V>	Publisher.OrderBy option which ensures that a sequence of sent values issued by a single thread will complete in order.
Publisher.OrderByValue<V>	Publisher.OrderBy option which computes the unit-of-order based on applying constructor's orderIdFunction parameter on sent value.
Publisher.Status	The status for a successfully published element.
PunctuationBaseToken	PunctuationBaseToken is a token that represents a known punctuation.
PunctuationOPToken	PunctuationOPToken is used in situations where you need a place holder to test for something like a ",".
QNameAdapter	A property adapter for QName primitive datatype.
QualifiedName	A QualifiedName is a useful class to separately capture the xml namespace prefix and local name of xml elements and attributes as a single object (instead of having to parse them out of Strings all the time).
Query	Defines an interface that Query implementations must support.
QueryConfig	Holder for query configuration.
QueryContext	The QueryContext provides an execution context to server-side agents during query execution.
QueryEngine	The QueryEngine interface provides a pluggable mechanism for producing queries that can be executed against a NamedCache.
QueryEngineConfig	Holder for QueryEngine configuration.
QueryEngineRegistry	A registry for QueryEngine instances.
QueryException	Query execution specific exception.
QueryHelper	QueryHelper is a utility class that provides a set of factory methods used for building instances of Filter or ValueExtractor.
QueryMap<K,V>	Map with additional query features.
QueryMap.Entry<K,V>	A QueryMap Entry exposes additional index-related operation that the basic Map Entry does not.
QueryMapComparator<T>	This interface is used by Comparator implementations that can use value extraction optimization exposed by the QueryMap.Entry interface.
QueryPlus	QueryPlus implements a simple command line processor for a sql like language.
QueryPlus.DefaultDependencies	A default implementation of QueryPlus.Dependencies.
QueryPlus.Dependencies	The Dependencies for QueryPlus.
QueryPlus.DependenciesHelper	The DependenciesHelper provides helper method for constructing QueryPlus.Dependencies implementations for QueryPlus.
QueryRecord	The QueryRecord object carries information regarding the estimated or actual execution cost for a query operation.
QueryRecord.PartialResult	A QueryRecord.PartialResult is a partial query record that contains recorded costs for a query operation.
QueryRecord.PartialResult.ExplainStep	A QueryRecord.ExplainStep is a QueryRecord.PartialResult.RecordableStep that provides the ability to record the estimated cost of evaluating a filter as part of a query operation.
QueryRecord.PartialResult.IndexLookupRecord	An IndexLookupRecord holds the recorded information about an index lookup performed during filter evaluation as part of a query record.
QueryRecord.PartialResult.RecordableStep	A QueryRecord.RecordableStep is a step that provides the ability to record the cost of evaluating a filter as part of a query operation.
QueryRecord.PartialResult.Step	A QueryRecord.Step carries the recorded cost of evaluating a filter as part of a query operation.
QueryRecord.PartialResult.TraceStep	A QueryRecord.TraceStep is a QueryRecord.PartialResult.RecordableStep that provides the ability to record the information associated with the actual cost of evaluating a filter as part of a query operation.
QueryRecorder<K,V>	This aggregator is used to produce a QueryRecord object that contains an estimated or actual cost of the query execution for a given filter.
QueryRecorder.RecordType	RecordType enum specifies whether the QueryRecorder should be used to produce a QueryRecord object that contains an estimated or an actual cost of the query execution.
QueryRecorderFilter<T>	QueryRecorderFilter is an extension of EntryFilter that allows the projected or actual costs of query execution to be recorded.
QueryRecorderStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a QueryRecorderStatementBuilder.QueryRecorderStatement.
QueryRecorderStatementBuilder.QueryRecorderStatement	Implementation of the CohQL "QueryRecorder" command.
RamJournalScheme	The RamJournalScheme is used to create an instance of a Ram Journal map.
Randoms	Class for providing random functionality.
RawDate	An immutable POF date value.
RawDateTime	An immutable POF date-time value.
RawDayTimeInterval	An immutable POF day-time interval value.
RawQuad	An immutable POF 128-bit float.
RawTime	An immutable POF time value.
RawTimeInterval	An immutable POF time interval value.
RawYearMonthInterval	An immutable POF year-month interval value.
ReadBuffer	The ReadBuffer interface represents an in-memory block of binary data, such as that represented by a byte[], a Binary object, or an NIO buffer.
ReadBuffer.BufferInput	The BufferInput interface represents a DataInputStream on top of a ReadBuffer.
ReadHeavyLongArray<V>	A thread-safe LongArray implementation for read heavy workloads but which is also efficient with frequent and/or bursty writes.
ReadLocatorBuilder	The ReadLocatorBuilder class builds a BiFunction that given the current ownership of a partition and service will return a member to target reads against.
ReadLocatorProcessor	A ReadLocatorProcessor is responsible for processing the read-locator xml to produce a ReadLocatorBuilder.
ReadonlyNamedCache<K,V>	A simple extension of the WrapperNamedCache implementation that shields all content mutating operations such as put(), remove(), lock() etc.
Reads	Class for providing read functionality.
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.
ReadWriteBackingMapScheme	The RemoteCacheScheme is responsible for creating a fully configured ReadWriteBackingMap.
ReadWriteSplittingBackingMap	A PartitionAwareBackingMap extension to the ReadWriteBackingMap.
Recovered	A qualifier annotation used for any RECOVERED event.
Recovered.Literal	An annotation literal for the Recovered annotation.
RecoverSnapshotStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a RecoverSnapshotStatementBuilder.RecoverSnapshotStatement.
RecoverSnapshotStatementBuilder.RecoverSnapshotStatement	Implementation of the CohQL "RECOVER SNAPSHOT" command.
RecyclingLinkedList	Extends SafeLinkedList and adds recycling of Node objects.
ReducerAggregator<K,V,T,E>	The ReducerAggregator is used to implement functionality similar to CacheMap.getAll(Collection) API.
ReferenceInternalConverter<T>	An InternalConverter that simply returns a reference to the provided value.
ReflectionExtractor<T,E>	Reflection-based ValueExtractor implementation.
ReflectionExtractorBuilder	An ExtractorBuilder implementation that will build instances of ReflectionExtractors.
ReflectionHelper	A collection of utilities to assist in using Reflection to create objects.
ReflectionUpdater	Reflection-based ValueUpdater implementation.
RefreshableAddressProvider	A RefreshableAddressProvider is an AddressProvider implementation that wraps another AddressProvider and refresh the address list of the provider asynchronously.
RefreshableSslContext	A refreshable SslContext.
RefreshPolicy	Implemented by classes that wish to control whether an SSLContext is updated when its scheduled update check runs.
RegExCacheMapping	An extension of CacheMapping that can use a regular expression to match with a given cache name.
RegexFilter<T,E>	Filter which uses the regular expression pattern match defined by the Pattern.matches(String, CharSequence) contract.
RegistrationBehavior	A RegistrationBehavior is used by numerous registries for the purpose of specifying the required behavior when registering an artifact.
Registry	The Coherence cluster management gateway is an abstraction of the basic JMX registration APIs that is specific to managing Coherence clustered resources.
Releasable	A resource that is activated and then at a later time be released.
Remote	A qualifier annotation used when injecting Coherence resource to indicate that a resource is remote.
Remote	Helper interfaces and methods that enable capture of standard JDK functional interfaces as serializable lambdas.
Remote.BiConsumer<T,U>	Represents an operation that accepts two input arguments and returns no result.
Remote.BiFunction<T,U,R>	Represents a function that accepts two arguments and produces a result.
Remote.BinaryOperator<T>	Represents an operation upon two operands of the same type, producing a result of the same type as the operands.
Remote.BiPredicate<T,U>	Represents a predicate (boolean-valued function) of two arguments.
Remote.BooleanSupplier	Represents a supplier of boolean-valued results.
Remote.Callable<V>	A task that returns a result and may throw an exception.
Remote.Comparator<T>	A comparison function, which imposes a total ordering on some collection of objects.
Remote.Consumer<T>	Represents an operation that accepts a single input argument and returns no result.
Remote.DoubleBinaryOperator	Represents an operation upon two double-valued operands and producing a double-valued result.
Remote.DoubleConsumer	Represents an operation that accepts a single double-valued argument and returns no result.
Remote.DoubleFunction<R>	Represents a function that accepts a double-valued argument and produces a result.
Remote.DoublePredicate	Represents a predicate (boolean-valued function) of one double-valued argument.
Remote.DoubleSupplier	Represents a supplier of double-valued results.
Remote.DoubleToIntFunction	Represents a function that accepts a double-valued argument and produces an int-valued result.
Remote.DoubleToLongFunction	Represents a function that accepts a double-valued argument and produces a long-valued result.
Remote.DoubleUnaryOperator	Represents an operation on a single double-valued operand that produces a double-valued result.
Remote.Function<T,R>	Represents a function that accepts one argument and produces a result.
Remote.IntBinaryOperator	Represents an operation upon two int-valued operands and producing an int-valued result.
Remote.IntConsumer	Represents an operation that accepts a single int-valued argument and returns no result.
Remote.IntFunction<R>	Represents a function that accepts an int-valued argument and produces a result.
Remote.IntPredicate	Represents a predicate (boolean-valued function) of one int-valued argument.
Remote.IntSupplier	Represents a supplier of int-valued results.
Remote.IntToDoubleFunction	Represents a function that accepts an int-valued argument and produces a double-valued result.
Remote.IntToLongFunction	Represents a function that accepts an int-valued argument and produces a long-valued result.
Remote.IntUnaryOperator	Represents an operation on a single int-valued operand that produces an int-valued result.
Remote.Literal	An annotation literal for the Remote annotation.
Remote.LongBinaryOperator	Represents an operation upon two long-valued operands and producing a long-valued result.
Remote.LongConsumer	Represents an operation that accepts a single long-valued argument and returns no result.
Remote.LongFunction<R>	Represents a function that accepts a long-valued argument and produces a result.
Remote.LongPredicate	Represents a predicate (boolean-valued function) of one long-valued argument.
Remote.LongSupplier	Represents a supplier of long-valued results.
Remote.LongToDoubleFunction	Represents a function that accepts a long-valued argument and produces a double-valued result.
Remote.LongToIntFunction	Represents a function that accepts a long-valued argument and produces an int-valued result.
Remote.LongUnaryOperator	Represents an operation on a single long-valued operand that produces a long-valued result.
Remote.ObjDoubleConsumer<T>	Represents an operation that accepts an object-valued and a double-valued argument, and returns no result.
Remote.ObjIntConsumer<T>	Represents an operation that accepts an object-valued and a int-valued argument, and returns no result.
Remote.ObjLongConsumer<T>	Represents an operation that accepts an object-valued and a long-valued argument, and returns no result.
Remote.Predicate<T>	Represents a predicate (boolean-valued function) of one argument.
Remote.Runnable	The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread.
Remote.Supplier<T>	Represents a supplier of results.
Remote.ToBigDecimalFunction<T>	Represents a function that produces a BigDecimal-valued result.
Remote.ToComparableFunction<T,R extends Comparable<? super R>>	Represents a function that produces a Comparable-valued result.
Remote.ToDoubleBiFunction<T,U>	Represents a function that accepts two arguments and produces a double-valued result.
Remote.ToDoubleFunction<T>	Represents a function that produces a double-valued result.
Remote.ToIntBiFunction<T,U>	Represents a function that accepts two arguments and produces an int-valued result.
Remote.ToIntFunction<T>	Represents a function that produces an int-valued result.
Remote.ToLongBiFunction<T,U>	Represents a function that accepts two arguments and produces a long-valued result.
Remote.ToLongFunction<T>	Represents a function that produces a long-valued result.
Remote.UnaryOperator<T>	Represents an operation on a single operand that produces a result of the same type as its operand.
RemoteAtomicBoolean	The remote implementation of AtomicBoolean, backed by a Coherence NamedMap entry.
RemoteAtomicInteger	The remote implementation of AtomicInteger, backed by a Coherence NamedMap entry.
RemoteAtomicLong	The remote implementation of AtomicLong, backed by a Coherence NamedMap entry.
RemoteAtomicMarkableReference<V>	The remote implementation of AtomicMarkableReference, backed by a Coherence NamedMap entry.
RemoteAtomicReference<V>	The remote implementation of AtomicReference, backed by a Coherence NamedMap entry.
RemoteAtomicStampedReference<V>	The remote implementation of AtomicStampedReference, backed by a Coherence NamedMap entry.
RemoteCache<K,V>	A remote partitioned-cache implementation of a Cache based on a Coherence <partitioned-cache>.
RemoteCacheConfiguration<K,V>	A Configuration for a Cache based on a Coherence <remote-scheme>, or more specifically a NamedCache.
RemoteCacheScheme	The RemoteCacheScheme is responsible for building a remote cache.
RemoteCollector<T,A,R>	An extension of Collector that adds serialization support.
RemoteCollectors	Static factory for various RemoteCollectors that can be executed in parallel in a distributed environment.
RemoteCountDownLatch	A distributed count down latch with the same basic behavior and semantics as the Java CountDownLatch class, but uses the NamedCache to support for synchronization aid that allows one or more threads across multiple cluster members to wait until a set of operations being performed in other threads/members completes.
RemoteDoubleStream	A sequence of primitive double-valued elements supporting sequential and parallel aggregate operations.
RemoteExecutor	A RemoteExecutor allows submitting and/or scheduling runnables and callables for execution within a Coherence cluster.
RemoteIntStream	A sequence of primitive int-valued elements supporting sequential and parallel aggregate operations.
RemoteInvocationScheme	The RemoteInvocationScheme class builds a remote invocation service.
RemoteLock	A reentrant mutual exclusion distributed Lock with the same basic behavior and semantics as the implicit monitor lock accessed using synchronized methods and statements, and the ReentrantLock class, but with support for access synchronization across multiple cluster members.
RemoteLongStream	A sequence of primitive long-valued elements supporting sequential and parallel aggregate operations.
RemoteMember	A RemoteMember is a special Member implementation that carries the remote IP/port information of a member that isn't in the cluster.
RemotePipeline<S_OUT>	A serializable pipeline of intermediate stream operations.
RemoteReadWriteLock	An implementation of ReadWriteLock supporting similar semantics to ReentrantReadWriteLock, but with support for access synchronization across multiple cluster members.
RemoteReadWriteLock.ReadLock	The lock returned by method RemoteReadWriteLock.readLock().
RemoteReadWriteLock.WriteLock	The lock returned by method RemoteReadWriteLock.writeLock().
RemoteSemaphore	A distributed counting semaphore.
RemoteStream<T>	This interface is an extension of java.util.stream.Stream that captures lambdas used as method arguments as serializable lambdas.
Removed	A qualifier annotation used for any REMOVED event.
Removed.Literal	An annotation literal for the Removed annotation.
RemoveSnapshotStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a RemoveSnapshotStatementBuilder.RemoveSnapshotStatement.
RemoveSnapshotStatementBuilder.RemoveSnapshotStatement	Implementation of the CohQL "REMOVE [ARCHIVED] SNAPSHOT" command.
Removing	A qualifier annotation used for any REMOVING event.
Removing.Literal	An annotation literal for the Removing annotation.
Render	Provides Render capabilities for FiniteStateMachines, in particular their Models.
ReplicatedScheme	The ReplicatedScheme class builds replicated cache.
Replicating	A qualifier annotation used for any REPLICATING event.
Replicating.Literal	An annotation literal for the Replicating annotation.
RequestHolder<Req,Res>	A class that holds a gRPC request and Binary converters.
RequestHolder.DownConverter	A Converter that converts from a Binary serialized in one format to a Binary key serialized in a different format.
RequestHolder.ErrorHandlingConverter<F,T>
RequestHolder.UpConverter	A Converter that converts from a Binary serialized in one format to a Binary serialized in a different format.
RequestIncompleteException	Signals that a request execution in a distributed environment failed to complete successfully.
RequestPolicyException	Signals that a request was not allowed to complete due to the related service action being disallowed by the corresponding ActionPolicy.
Requests	A factory to simplify creating proto-buffer requests.
RequestTimeoutException	Signals that a request execution in a distributed environment did not complete in a pre-determined amount of time.
ResolvableParameterList	A ResolvableParameterList is a ParameterList implementation that additionally supports name-based Parameter resolution as defined by the ParameterResolver interface.
Resolving	Marker interface for Resolving*Stream implementations.
ResolvingObjectInputStream	Provides an ObjectInputStream that uses a caller provided ClassLoader to resolve classes during objects deserialization.
ResolvingObjectOutputStream	A marker implementation to mirror the ResolvingObjectInputStream implementation.
ResourceBuilderProcessor<T>	An ElementProcessor for <resource> elements defined by a Coherence Operational Configuration file.
ResourceConfig	The ResourceConfig class encapsulates information related to a Coherence REST resource.
ResourceMapping	A base class for mapping elements.
ResourceMappingRegistry	A SchemeMappingRegistry provides a mechanism manage a collection of ResourceMappings, together with the ability to search the registry for said ResourceMappings, possibly using wild-cards.
ResourceRegistry	A ResourceRegistry is a registry and owner of strongly typed and explicitly named resources.
ResourceRegistry.ResourceLifecycleObserver<R>	The ResourceRegistry.ResourceLifecycleObserver interface defines lifecycle handlers for resources registered with a ResourceRegistry.
ResourceResolver	A ResourceResolver provides a mechanism to lookup and resolve optionally named, strongly typed resources.
ResourceResolverHelper	Provides helpful methods for working with ResourceResolvers.
Resources	Implement simple basis for package (and other) resources.
ResourcesProcessor	An ElementProcessor for the <resources%gt; element of Coherence Operational Configuration files.
ResponseHandlers	Helper methods to handle gRPC async responses.
RestConfig	The RestConfig class encapsulates information related to Coherence REST configuration.
RestHelper	A collection of utility methods used by Coherence REST.
RestoreStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a RestoreStatementBuilder.RestoreStatement.
RestoreStatementBuilder.RestoreStatement	Implementation of the CohQL "RESTORE" command.
RestrictedCollections	A collection of Collection implementation classes that limit the data type.
RestrictedCollections.RestrictedCollection	A restricted Collection that requires its contents to be of a specified class.
RestrictedCollections.RestrictedEntrySet	A restricted Collection that requires its contents to be of a specified class.
RestrictedCollections.RestrictedList	A restricted List that requires its contents to be of a specified class.
RestrictedCollections.RestrictedListIterator	A restricted ListIterator that requires its contents to be of a specified class.
RestrictedCollections.RestrictedMap	A restricted Map that requires its keys and values to be of specified classes.
RestrictedCollections.RestrictedSet	A restricted Set that requires its contents to be of a specified class.
RestrictedCollections.RestrictedSortedMap	A restricted SortedMap that requires its keys and values to be of specified classes.
RestrictedCollections.RestrictedSortedSet	A restricted Set that requires its contents to be of a specified 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).
ResumeServiceStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a ResumeServiceStatementBuilder.ResumeServiceStatement.
ResumeServiceStatementBuilder.ResumeServiceStatement	Implementation of the CohQL "RESUME SERVICE" command.
RetrieveSnapshotStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a RetrieveSnapshotStatementBuilder.RetrieveSnapshotStatement.
RetrieveSnapshotStatementBuilder.RetrieveSnapshotStatement	Implementation of the CohQL "RETRIEVE SNAPSHOT" command.
Rollback	A qualifier annotation used for any ROLLBACK event.
Rollback.Literal	An annotation literal for the Rollback annotation.
RollbackTransitionException	A RollbackTransitionException may be thrown during an TransitionAction for a Transition if the said Transition should be aborted.
SafeClock	SafeClock maintains a "safe" time in milliseconds.
SafeComparator<T>	Null-safe delegating comparator.
SafeConfigurablePofContext	SafeConfigurablePofContext is an extension of ConfigurablePofContext that can serialize and deserialize any valid POF user type, even those that have not been explicitly configured, as well as any Java serializable types (Serializable, Externalizable, or ExternalizableLite).
SafeHashMap<K,V>	An implementation of java.util.Map that is synchronized, but minimally so.
SafeHashMap.Entry<K,V>	A map entry (key-value pair).
SafeHashSet	An implementation of java.util.Set that is synchronized, but minimally so.
SafeLinkedList	Implementation of the Collection Framework interface "List" using a linked list algorithm.
SafeLinkedList.Node	A Node in the List.
SafeLongArray<V>	A thread-safe variant of LongArray in which is protected by a ReentrantLock.
SafePersistenceWrappers	SafePersistenceWrappers provides safe wrapper implementations of persistence layer interfaces that can be used to consolidate error handling across the various persistence layers.
SafePersistenceWrappers.FailureContinuationFactory<R,T extends Throwable>	FailureContinuationFactory encapsulates failure continuations to handle unexpected exceptions thrown by implementations of the various persistence layers.
SafePersistenceWrappers.SafePersistenceEnvironment<R,T extends Throwable>	SafePersistenceEnvironment is a wrapper PersistenceEnvironment implementation which protects all operations on the underlying environment (and any PersistenceManger or PersistentStore instances opened through this environment) from unexpected failures, delegating the exception handling to a failure Continuation.
SafePersistenceWrappers.SafePersistenceManager<R,T extends Throwable>	SafePersistenceManager is a wrapper PersistenceManager implementation which protects all operations on the underlying manager (and any PersistentStore instances opened by the manager) from unexpected failures, delegating the exception handling to a failure Continuation.
SafePersistenceWrappers.SafePersistentStore<R,T extends Throwable>	SafePersistentStore is a wrapper PersistentStore implementation which protects all synchronous operations on the underlying store from unexpected failures, delegating the exception handling to a failure Continuation.
SafeSortedMap	Implementation of a SortedMap extending ConcurrentSkipListMap to support null keys and null values.
SafeSortedMap.EntrySet	Entry set delegation of the super map implementation.
SafeSortedMap.KeySet	Key set delegation of the super map implementation.
SafeSortedMap.Null
SafeSortedMap.NullableEntry	Map.Entry implementation that supports null key/value placeholders.
SafeSortedMap.SubMap	SubMap delegation to manage SafeSortedMap.NULL in entry key and/or value.
SafeSortedMap.Values	Values delegation of the super map implementation.
SafeStreamObserver<T>	A StreamObserver that handles exceptions correctly.
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.
SanityCheckStatementBuilder	A StatementBuilder that builds the QueryPlus "SANITY CHECK" command.
SaxParser	A simple XML parser.
Scheme	A Scheme defines the configuration information and necessary builders for the construction of various well-known and identifiable structures used by Coherence at runtime.
SchemeMappingRegistry	A SchemeMappingRegistry provides a mechanism to manage a collection of ResourceMappings, together with the ability to search the registry for said ResourceMappings, possibly using wildcards.
SchemeMappingRegistry.SchemeMappingKey	Key class for a scheme mapping.
SchemeRefPreprocessor	A SchemeRefPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that resolves declarations of <scheme-ref> as required by Coherence.
SchemesProcessor	A SchemesProcessor is an ElementProcessor for the <caching-schemes%gt; element of Coherence Cache Configuration files.
Scope	A qualifier annotation used when injecting Coherence resource to indicate that those resource should be obtained from a specific ConfigurableCacheFactory.
Scope.Literal	An annotation literal for the Scope annotation.
ScopedCacheFactoryBuilder	Implementation of CacheFactoryBuilder that manages multiple instances of ConfigurableCacheFactory.
ScopedParameterResolver	A ScopedParameterResolver is a ParameterResolver implementation that provides the ability to "scope" Parameter definitions to either an inner (wrapped) or outer ParameterResolver, such that those being defined in the outer ParameterResolver hide those (of the same name) in the inner (wrapped) ParameterResolver.
ScopeName	A qualifier annotation used to indicate a specific scope name.
ScopeName.Literal	An annotation literal for the ScopeName annotation.
ScopeNameProcessor	The ScopeNameProcessor is responsible for processing the <scope-name> XmlElement in a Coherence Cache Configuration file.
ScopeResolver	This interface is used to derive a scope name used to create an instance of ConfigurableCacheFactory.
ScriptAggregator<K,V,P,R>	ScriptAggregator is a InvocableMap.StreamingAggregator that wraps a script written in one of the languages supported by Graal VM.
ScriptException	Represents an exception of some sort has occurred while loading or executing scripts.
ScriptFilter<V>	ScriptFilter is a Filter that wraps a script written in one of the languages supported by Graal VM.
ScriptProcessor<K,V,R>	ScriptProcessor is an InvocableMap.EntryProcessor that wraps a script written in one of the languages supported by Graal VM.
ScriptValueExtractor<T,E>	ScriptValueExtractor is an AbstractExtractor that wraps a script written in one of the languages supported by Graal VM.
Seconds	Seconds is a specialized Duration whose default constructor assumes that the specified units of time (when the unit magnitude is not specified) are seconds.
Security	The Security class is used to associate client's identity with an action that requires access to protected clustered resources.
SecurityExceptionMapper	Maps SecurityExceptions to 403: Forbidden response.
SecurityFilter	Simple authentication filter.
SecurityHelper	A collection of security-related utilities.
SecurityProvider	Security Provider implementation that returns custom security services.
SegmentedConcurrentMap	An implementation of SegmentedHashMap that also implements the ConcurrentMap interface.
SegmentedConcurrentMap.ContentionObserver	ContentionObserver is used to observe the contention lock-related actions performed on the concurrent map.
SegmentedConcurrentMap.SizeAction	Action support for size().
SegmentedHashMap	An implementation of java.util.Map that is optimized for heavy concurrent use.
SegmentedHashMap.ContainsValueAction	Action support for containsValue().
SegmentedHashMap.Entry	A map entry (key-value pair).
SegmentedHashMap.EntryAction	An EntryAction encapsulates a logical action to be executed in the context of a key (that may or may not exist in the map).
SegmentedHashMap.EntryActionAdapter	EntryActionAdapter is a convenience class that provides default implementations for the EntryAction and IterableEntryAction interface methods.
SegmentedHashMap.IterableEntryAction	IterableEntryAction is an EntryAction that is suitable for applying to all keys in a map.
SegmentedHashMap.Segment	Segment metadata.
SegmentedHashSet	An implementation of java.util.Set that is optimized for heavy concurrent use.
SelectStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a SelectStatementBuilder.SelectStatement.
SelectStatementBuilder.AsyncSelectStatement	Async implementation of the CohQL "SELECT" command.
SelectStatementBuilder.SelectStatement	Implementation of the CohQL "SELECT" command.
Semaphore
Semaphores	Factory methods for local and remote semaphore implementations.
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.
SeppukuMapListener	A map listener that follows the "seppuku" pattern, invalidating the Map entries when MapEvents for another related ObservableMap are delivered.
SequenceBaseToken	SequenceBaseToken is a token that holds a sequence of tokens.
SerializableAdapter	A SerializableAdapter supports Java objects that implement the Serializable interface.
SerializableSerializer
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.
SerializationSupport	The SerializationSupport interface provides the ability for objects that are serialized by any Serializer to affect the initial stage of serialization and the final stage of deserialization.
Serializer	The Serializer interface provides the capability of reading and writing a Java object from and to an in-memory buffer.
SerializerAware	The SerializerAware interface provides the ability to configure a Serializer to be used by the implementing object when serializing or deserializing objects.
SerializerBuilderProcessor	An ElementProcessor for <serializer> elements defined by a Coherence Operational Configuration file.
SerializerFactory	A factory for Serializer objects.
SerializerFactoryProcessor	An ElementProcessor that will parse a <serializer> and produce a suitable SerializerFactory
SerializerFormat	A qualifier annotation used when injecting a Serializer to identify the specific Serializer to inject.
SerializerFormat.Literal	An annotation literal for the SerializerFormat annotation.
SerializerProducer	A CDI producer of Serializer instances.
SerializerProducer.Builder	A builder that builds SerializerProducer instances.
SerializersProcessor	An ElementProcessor for the <serializers%gt; element of Coherence Operational Configuration files.
SerializingInternalConverter<T>	An InternalConverter that converts values to and from their Coherence-based serialized Binary representation.
Server	This class bootstraps the CDI container, which will in turn start Coherence server via CDI extension.
ServerCoherenceProducer	A CDI server-side Coherence bean producer.
ServerLoggingInterceptor	A gRPC server interceptor that will log messages on the server.
Service	This Service interface represents a controllable service that operates in a clustered network environment.
Service	A Service is a Controllable that emits service lifecycle events.
Service.MemberJoinAction	MemberJoinAction is taken to allow a new member to join a clustered Service.
ServiceBuilder	The ServiceBuilder interface is used by a builder that creates a Service.
ServiceBuilderProcessor<T extends ServiceBuilder>	A ServiceBuilderProcessor is an ElementProcessor responsible for producing various kinds of ServiceBuilders.
ServiceDependencies	The ServiceDependencies interface defines externally provided dependencies for clustered services.
ServiceEvent	An event which indicates that a Service state has changed: a service is starting a service has started a service is stopping a service has stopped A ServiceEvent object is sent as an argument to the ServiceListener interface methods.
ServiceFailurePolicy	ServiceFailurePolicy is used to control how a Guardable associated with a service is managed by its Guardian after the configured timeout.
ServiceFailurePolicyBuilder	Build a default or customized ServiceFailurePolicy.
ServiceFailurePolicyProcessor	An ElementProcessor that will parse a <service-failure-policyr> and produce a suitable ServiceFailurePolicy
ServiceInfo	The ServiceInfo represents information about a Service that operates in a clustered network environment.
ServiceListener	The listener interface for receiving ServiceEvents.
ServiceLoad	A ServiceLoad encapsulates information about the current utilization of a Service.
ServiceLoadBalancer<S extends Service,T extends ServiceLoad>	A ServiceLoadBalancer is a pluggable strategy for controlling the client load across individual members of a clustered Service.
ServiceLoadBalancerBuilder	ServiceLoadBalancerBuilder defers evaluating configuration parameters until ServiceLoadBalancer is instantiated.
ServiceLoadBalancerProcessor	An ElementProcessor for <load-balancer> configuration used by federated and proxy services.
ServiceMonitor	The ServiceMonitor is a facility that keeps registered services alive.
ServiceName	A qualifier annotation used to indicate a specific service name.
ServiceName.Literal	An annotation literal for the ServiceName annotation.
ServiceScheme	This interface exposes service related scheme information.
ServiceSchemeRegistry	A ServiceSchemeRegistry provides a mechanism manage a collection of ServiceSchemes together with the ability to search the registry for said ServiceSchemes, either by name or service name.
ServicesStatementBuilder	A StatementBuilder that builds the QueryPlus "SERVICES" command.
ServiceStoppedException	Signals that a request was not able to execute because the underlying service has been stopped.
Session	A thread-safe mechanism to request Coherence-based resources, like NamedCaches, from a deployed module.
Session.Option	Deprecated. since 20.12 Session.Option has been replaced by SessionConfiguration
SessionConfiguration	A class that can provide the configuration options for a Session.
SessionConfiguration.Builder	A builder to build a SessionConfiguration.ConfigurableCacheFactorySessionConfig.
SessionConfiguration.ConfigurableCacheFactorySessionConfig	An immutable SessionConfiguration to configure a Session that wraps an underlying ConfigurableCacheFactory.
SessionDispatcher	A CoherenceDispatcher raises Events pertaining to operations on a Coherence instance: CoherenceLifecycleEvents
SessionInitializer	An interface that should be implemented by custom Coherence scoped session configurations in order to enable their discovery and automatic initialization at startup.
SessionLifecycleEvent	A SessionLifecycleEvent allows subscribers to capture events pertaining to the lifecycle of a Session instance.
SessionLifecycleEvent.Type	The emitted event types for a SessionLifecycleEvent.
SessionLifecycleEvents	SessionLifecycleEvents is an annotation that should be applied to EventInterceptor implementations that want to receive SessionLifecycleEvents.
SessionName	A qualifier annotation used when injecting Coherence resource to indicate a specific Session name.
SessionName.Literal	An annotation literal for the SessionName annotation.
SessionProducer	A CDI producer for Session instances.
SessionProvider	Creates Sessions for use by applications requiring Coherence-based resources, including NamedCaches, often for specific ClassLoaders, for deployed modules.
SessionProvider.Context	A context used by providers.
SessionProvider.DefaultContext
SessionProvider.Option	Deprecated. since 20.12 use SessionConfiguration and SessionProvider.createSession(SessionConfiguration, Coherence.Mode, Iterable)
SessionProvider.Provider	Implemented by suppliers of a SessionProvider.
SessionProvider.Providers	Deprecated. since 20.12 there is no replacement for this class
SetMap<K,V>	A Map implementation based on a known set of keys and a Function that when given a key can derive the value.
SetTimeoutStatementBuilder	A class that builds the QueryPlus "ALTER SESSION SET TIMEOUT millis" statement.
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
SimpleAdapter.BigDecimalAdapter	A simple property adapter for BigDecimal.
SimpleAdapter.BigIntegerAdapter	A simple property adapter for BigInteger.
SimpleAdapter.BooleanAdapter	A simple property adapter for boolean.
SimpleAdapter.ByteAdapter	A simple property adapter for byte.
SimpleAdapter.CharAdapter	A simple property adapter for char.
SimpleAdapter.DateAdapter	A simple property adapter for Date.
SimpleAdapter.DoubleAdapter	A simple property adapter for double.
SimpleAdapter.FloatAdapter	A simple property adapter for float.
SimpleAdapter.IntAdapter	A simple property adapter for int.
SimpleAdapter.LongAdapter	A simple property adapter for long.
SimpleAdapter.OldDateAdapter	A simple property adapter for the Date class from the java/util package.
SimpleAdapter.ShortAdapter	A simple property adapter for short.
SimpleAdapter.StringAdapter	A simple property adapter for String.
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.
SimpleAdapter.TimeAdapter	A simple property adapter for Time.
SimpleAdapter.TimestampAdapter	A simple property adapter for Timestamp.
SimpleAssignmentStrategy	SimpleAssignmentStrategy is a PartitionAssignmentStrategy that attempts to balance the partition distribution based on the number of primary and backup partitions owned.
SimpleAssignmentStrategy.BackupStrength	BackupStrength represents a level of "strength" or "resiliency" between the primary and backup owners of a partition.
SimpleAssignmentStrategy.LoadCalculator	LoadCalculator is used to calculate the scalar load (expressed as an integer) of a partition (or set of partitions).
SimpleAssignmentStrategy.SimpleLoadCalculator	SimpleLoadCalculator defines a "count-based" load (e.g. the load of each partition is defined to be 1).
SimpleAttribute	A SimpleAttribute provides a basic implementation of an XmlAttribute.
SimpleAttributeProcessor<T>	A SimpleAttributeProcessor is a simple AttributeProcessor implementation that will construct, initialize (via constructor injection) and return a specific type of object based on information in an XmlAttribute.
SimpleBuilderProcessor<T>	An ElementProcessor that returns a simple ParameterizedBuilder.
SimpleCacheStatistics	Implementation of the CacheStatistics interface intended for use by a cache to maintain its statistics.
SimpleDaemonPoolExecutor	An Executor that uses a DaemonPool to execute tasks.
SimpleDocument	A simple implementation of the XmlElement interface.
SimpleElement	A simple implementation of the XmlElement interface.
SimpleElementProcessor<T>	A SimpleElementProcessor is an ElementProcessor implementation that will construct, initialize (via constructor injection) and return a specific type of object based on information in an XmlElement.
SimpleEnumerator<E>	Provide a generic implementation of an array enumerator.
SimpleEvolvable	Simple implementation of Evolvable interface.
SimpleHandler	The SimpleHandler class is a CallbackHandler implementation based on a specified user name and password.
SimpleHolder<V>	SimpleHolder is a basic implementation of the Holder interface.
SimpleHolder<V>	General purpose container that can be used as an accumulator for any reference type.
SimpleLongArray	An implementation of LongArray that stores values in an array, thus is actually an "IntArray".
SimpleMapEntry<K,V>	A map entry (key-value pair).
SimpleMapEvent<K,V>	Simple representation of MapEvent that can be marshalled to JSON.
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.
SimpleMapIndex.IndexCalculator	A stateful calculator used to calculate the cost of a homogeneous index (holding all values of a single type).
SimpleMapIndex.IndexCalculator.CalculatorState	The CalculatorState identifies the method used by the calculator to calculate the cost of a key or a value type.
SimpleMemoryCalculator	A UnitCalculator implementation that weighs a cache entry based upon the amount of physical memory (in bytes) required to store the entry.
SimpleModel<S extends Enum<S>>	A SimpleModel is a basic implementation of a Model for a FiniteStateMachine.
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.
SimpleParameterizedBuilderRegistry	A basic implementation of a ParameterizedBuilderRegistry.
SimpleParameterList	A SimpleParameterList is a simple implementation of ParameterList.
SimpleParser	This class uses the XmlTokenizer to produce an XmlDocument from XML text.
SimplePartitionKey	SimplePartitionKey is a trivial PartitionAwareKey implementation.
SimplePofContext	Basic PofContext implementation.
SimplePofPath	A static PofNavigator implementation which uses an array of integer indices to navigate the PofValue hierarchy.
SimplePofValue	SimplePofValue represents POF values which do not contain children (e.g.
SimpleQueryRecord	Simple QueryRecord implementation.
SimpleQueryRecord.PartialResult	Simple QueryRecord.PartialResult implementation.
SimpleQueryRecord.PartialResult.IndexLookupRecord	Simple QueryRecord.PartialResult.IndexLookupRecord implementation.
SimpleQueryRecord.PartialResult.Step	Simple QueryRecord.PartialResult.Step implementation.
SimpleQueryRecordReporter	Simple query record reporter used to obtain a string representation of QueryRecord object.
SimpleResourceRegistry	A SimpleResourceRegistry is a basic implementation of a ResourceRegistry.
SimpleResourceResolver	A simple implementation of a ResourceResolver.
SimpleSerializationMap	Map implementation that stores and accesses its contents through an underlying BinaryStore.
SimpleServiceLoadBalancer<S extends Service,T extends ServiceLoad>	A simple ServiceLoadBalancer implementation.
SimpleServiceMonitor	The SimpleServiceMonitor starts and monitors services that are registered for monitoring.
SimpleStack	A LIFO (last in, first out) unbounded stack of objects.
SimpleStrategyMBean	Standard MBean interface that exposes management attributes and operations for a SimpleAssignmentStrategy used by a PartitionedService.
SimpleStrategyMBean.HAStatus	HAStatus represents the possible values to represent the High Availability Status of the associated PartitionedService.
SimpleStreamer<T>	Simple implementation of a Streamer.
SimpleValidator	Simple generic Validator implementation that uses hashCode values for the enlisted resources to resolve optimistic transaction conflicts.
SimpleValue	A simple implementation of the XmlValue interface.
SingleEntryAsynchronousProcessor<K,V,R>	An EntryProcessor wrapper class that allows for an asynchronous invocation of the underlying processor against a single cache entry.
SingletonCacheFactoryBuilder	Implementation of CacheFactoryBuilder that maintains a single ConfigurableCacheFactory instance regardless of the requesting ClassLoader if a URI is not provided.
SingleWaiterCooperativeNotifier	SingleWaiterCooperativeNotifier is an extension of the SingleWaiterMultiNotifier which attempts to offload potentially expensive "notification" work from signaling threads onto the waiting threads.
SingleWaiterMultiNotifier	A Condition-like object, used by a single thread to block for a notification, and optimized for many concurrent notifications by other threads.
Sizable	The Sizable interface is implemented by types that are capable of calculating the memory footprint of an instance.
SizeEstimatingBufferOutput	SizeEstimatingBufferOutput is a WriteBuffer.BufferOutput implementation which writes nothing, and simply maintains an estimated byte count of how much would have been written.
Snapshot	A Snapshot is the abstraction of a full or partial snapshot representation for the purposes of archiving.
SnapshotArchiver	An interface for archiving and restoring snapshots.
SnapshotArchiverFactory	A factory for SnapshotArchiver objects.
SocketAddressProvider	The SocketAddressProvider is an interface that serves as a means to provide addresses to a consumer.
SocketOptions	SocketOptions provides a means to configure the various aspects of Sockets.
SocketOptionsProcessor	An ElementProcessor for SocketOptions.
SocketProvider	SocketProvider defines an abstraction for creating various types of sockets.
SocketProviderBuilder	SocketProviderBuilder enables lazy instantiation of SocketProvider.
SocketProviderFactory	The SocketProviderFactory produces SocketProviders.
SocketProviderFactory.DefaultDependencies	DefaultDependencies is a basic implementation of the Dependencies interface.
SocketProviderFactory.Dependencies	Dependencies specifies all dependency requirements of the SocketProviderFactory.
SocketProviderFactory.Dependencies.ProviderType	Enumeration of Provider types.
SocketProviderProcessor	An ElementProcessor that will parse a <socket-provider> and produce a SocketProviderBuilder.
SocketProvidersProcessor	An SocketProvidersProcessor is responsible for processing <socket-provider> XmlElements SocketProvider definitions.
SortedBag<E>	SortedBag is a multiset or bag implementation that supports sorted traversal of the contained elements and is optimized for insertions and removals.
SortedEnumerator	Sorts the contents of the passed enumerator then enumerates those contents.
SourceStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a SourceStatementBuilder.SourceStatement.
SourceStatementBuilder.SourceStatement	Implementation of the CohQL "source" command.
SparseArray<V>	A data structure resembling an Object array indexed by long values.
SparseArray.ObjectNode<V>	Node mapping long key to Object value.
SpecificInstanceProcessor<T>	An ElementProcessor that will process an XmlElement defining a ParameterizedBuilder, after which it will eagerly realized to produce an instance of the required type.
SQLArchiveSnapshotOPToken	SQLArchiveSnapshotOPToken is used for parsing and specifying the AST used for archiving snapshots.
SQLBackupOPToken	SQLBackupOPToken is used for parsing and specifying the AST used for backing up a cache.
SQLCreateCacheOPToken	SQLCreateOPToken is used for parsing and specifying the AST used for a create cache.
SQLCreateIndexOPToken	SQLCreateOPToken is used for parsing and specifying the AST used for a create index query.
SQLCreateSnapshotOPToken	SQLCreateSnapshotOPToken is used for parsing and specifying the AST used for creating snapshots.
SQLDeleteOPToken	SQLDeleteOPToken is used for parsing and specifying the AST used for a delete query.
SQLDropCacheOPToken	SQLDropCacheOPToken is used for parsing and specifying the AST used for drop cache
SQLDropIndexOPToken	SQLDropIndexOPToken is used for parsing and specifying the AST used for drop index.
SQLExplainOPToken	SQLExplainOPToken is used for parsing and specifying the AST used for an explain plan statement.
SQLForceRecoveryOPToken	SQLForceRecoveryOPToken is used for parsing and specifying the AST used for forcing recovery.
SQLInsertOPToken	SQLInsertOPToken is used for parsing and specifying the AST used for a insert statment.
SQLListArchivedSnapshotsOPToken	SQLListArchivedSnapshotsOPToken is used for parsing and specifying the AST used for listing archived snapshots.
SQLListArchiverOPToken	SQLListArchiverOPToken is used for parsing and specifying the AST used for showing the archiver implementation for a service.
SQLListServicesOPToken	SQLListServicesOPToken is used for parsing and specifying the AST used for listing services and their persistence mode.
SQLListSnapshotsOPToken	SQLConnectOPToken is used for parsing and specifying the AST used for listing snapshots.
SQLOPToken	SQLOPToken provides useful convenience methods for subclasses.
SQLPeekOPToken	An CohQL implementation of a PeekOPToken.
SQLRecoverSnapshotOPToken	SQLRecoverSnapshotOPToken is used for parsing and specifying the AST used for creating snapshots.
SQLRemoveSnapshotOPToken	SQLRemoveSnapshotOPToken is used for parsing and specifying the AST used for creating snapshots.
SQLRestoreOPToken	SQLRestoreOPToken is used for parsing and specifying the AST used for restoring a cache.
SQLResumeServiceOPToken	SQLResumeServiceOPToken is used for parsing and specifying the AST used for resuming services.
SQLRetrieveSnapshotOPToken	SQLRetrieveSnapshotOPToken is used for parsing and specifying the AST used for retrieving snapshots.
SQLSelectOPToken	SQLSelectOPToken is used for parsing and specifying the AST used for a select statement.
SQLSourceOPToken	SQLSourceOPToken is used for parsing and specifying the AST used for sourcing (including) a file.
SQLSuspendServiceOPToken	SQLSuspendServiceOPToken is used for parsing and specifying the AST used for suspending services.
SQLTraceOPToken	SQLTraceOPToken is used for parsing and specifying the AST used for a trace statement.
SQLTruncateCacheOPToken	SQLTruncateCacheOPToken is used for parsing and specifying the AST used for truncate cache.
SQLUpdateOPToken	SQLUpdateOPToken is used for parsing and specifying the AST used for an update statement.
SQLValidateSnapshotOPToken	SQLValidateSnapshotOPToken is used for parsing and specifying the AST used for creating snapshots.
SSLHostnameVerifierProcessor	An ElementProcessor that will parse and produce a HostnameVerifier based on hostname-verifier configuration element.
SSLManagerProcessor	An ElementProcessor that will parse and produce a DefaultManagerDependencies based on a identity-manager/trust-manager configuration element.
SSLNameListProcessor	An ElementProcessor that will parse and produce a NameListDependencies based on a protocol-versions or cipher-suites configuration element.
SSLProcessor	An ElementProcessor that will parse an <ssl> and produce a SSLSocketProviderDependenciesBuilder object.
SSLSocketProviderDependenciesBuilder	SSLSocketProviderDependenciesBuilder enables lazy instantiation of SSL SocketProvider.
SSLSocketProviderDependenciesBuilder.DependenciesAware	Implemented by Provider classes that need to be aware of the SSL dependencies.
SSLSocketProviderDependenciesBuilder.HostnameVerifierBuilder	HostnameVerifier dependencies
SSLSocketProviderDependenciesBuilder.NameListDependencies	SSL encipher-suites and protocol-versions are both a list of names with a usage attribute of the value "white-list" or "black-list"
SSLSocketProviderDependenciesBuilder.NameListDependencies.USAGE
SSLSocketProviderDependenciesBuilder.ProviderBuilder	Provider dependencies
StackTrace	Class for providing StackTrace functionality.
StackTrace.StackFrame	A class that provides "stack frame" information from a line of a stack trace.
Started	A qualifier annotation used for any STARTED event.
Started.Literal	An annotation literal for the Started annotation.
Starting	A qualifier annotation used for any STARTING event.
Starting.Literal	An annotation literal for the Starting annotation.
StateEntryAction<S extends Enum<S>>	A StateEntryAction encapsulates the actions to be performed by a FiniteStateMachine when a particular state is entered.
StateExitAction<S extends Enum<S>>	A StateExitAction encapsulates the actions to be performed by a FiniteStateMachine when leaving a known state.
Statement	Implementations of this interface are able to execute CohQL statements, for example a Select, Update, a backup command etc.
StatementBuilder<T extends Statement>	Classes implementing this interface build instances of Statement implementations.
StatementExecutor	A class that parses and executes CohQL statements read from an instance of a Reader.
StatementResult	The result of executing a CohQL Statement.
StaticContent	A simple representation of static content, which is used as a pass-through storage format for content other than JSON.
StaticContentMarshaller	A pass-through marshaller that simply converts HTTP entities into a StaticContent and vice versa.
StaticFactoryInstanceBuilder<T>	A StaticFactoryInstanceBuilder is a ParameterizedBuilder that has been configured to realize objects based on the properties defined by an <instance> configuration element that uses the static <class-factory-name> approach.
Stopped	A qualifier annotation used for any STOPPED event.
Stopped.Literal	An annotation literal for the Stopped annotation.
Stopping	A qualifier annotation used for any STOPPING event.
Stopping.Literal	An annotation literal for the Stopping annotation.
StorageAccessAuthorizer	A pluggable facility for the server side access control authorization.
StorageAccessAuthorizerBuilderProcessor	An ElementProcessor for <storage-authorizer> elements defined by a Coherence Operational Configuration file.
StorageAccessAuthorizersProcessor	An ElementProcessor for the <storage-authorizers%gt; element of Coherence Operational Configuration files.
StorageProcessor	A StorageProcessor is responsible for processing <storage> XmlElements to produce a CachingScheme.
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)).
Streamer<T>	Enables traversal of elements in the underlying data set using either Iterator, Spliterator or a Stream, while allowing implementors to provide additional metadata, such as the size and other characteristics of the underlying data set.
StreamingAsynchronousProcessor<K,V,R>	An EntryProcessor wrapper class that allows for an asynchronous invocation of the underlying processor.
StringMarshaller	Marshaller that marshalls String object.
StringTable	Like a hash table, but built specifically for strings.
SubjectPofSerializer	PofSerializer implementation that can serialize and deserialize a Subject to/from a POF stream.
SubList<T>	Implements a list which is based on another list, represents a sub-list of the underlying list.
Subscriber<V>	A Subscriber subscribes either directly to a NamedTopic or to a subscriber group of a NamedTopic.
Subscriber.Channel	A representation of a topic channel within subscriber.
Subscriber.Channel.EmptyChannel	A default empty channel implementation.
Subscriber.ChannelOwnershipListener	A listener that receives notification of channel ownership changes.
Subscriber.ChannelOwnershipListeners<V>	A subscriber Subscriber.Option that allows one or more listeners to be added to the subscriber, that will be notified of changes to the subscribers channel ownership.
Subscriber.CommitResult	The result of a commit request.
Subscriber.CommitResultStatus	The different result statuses for a commit request.
Subscriber.CompleteOnEmpty<V>	The CompleteOnEmpty option indicates that the CompletableFuture returned from the Subscriber.receive() operation should complete with a null Subscriber.Element upon identifying that the topic is or has become empty.
Subscriber.Convert<V,U>	The Convert option specifies a ValueExtractor that will convert topic values that a subscriber is interested in receiving prior to sending them to the subscriber.
Subscriber.Element<V>	Element represents a container for returned values.
Subscriber.Filtered<V>	The Filtered option specifies a filter that will determine which topic values a subscriber is interested in receiving.
Subscriber.Id	A marker interface for Subscriber identifiers.
Subscriber.Name<V>	The Name option is used to specify a subscriber group name.
Subscriber.Option<V,U>	A marker interface to indicate that a class is a valid Subscriber.Option for a Subscriber.
SubscriberGroup	A qualifier annotation used when injecting Subscriber to a NamedTopic to indicate the name of the subscriber group that the subscriber should belong to.
SubscriberGroup.Literal	An annotation literal for the SubscriberGroup annotation.
SubscriberGroupBuilder<V>	The SubscriberGroupBuilder builds a Subscriber group.
SubscriberGroupProcessor	A ElementProcessor for the <subscriber-group> element.
SubscriberGroupsProcessor	A ElementProcessor for the <subscriber-groups> element.
SubSet<E>	Implements a set which is based on another set, which is assumed to be immutable.
SubtractionOperator	An operator representing the conditional mathematical subtraction operation.
SuspendServiceStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a SuspendServiceStatementBuilder.SuspendServiceStatement.
SuspendServiceStatementBuilder.SuspendServiceStatement	Implementation of the CohQL "SUSPEND SERVICE" command.
Synced	A qualifier annotation used for any SYNCED event.
Synced.Literal	An annotation literal for the Synced annotation.
Synchronous	A qualifier annotation that can be applied to MapListener CDI observers to register them as MapListener.synchronous() listeners.
Synchronous.Literal	An annotation literal for the Synchronous annotation.
SynchronousListener<K,V>	A tag interface indicating that a listener implementation has to receive the event notifications synchronously on the corresponding service's thread.
Syncing	A qualifier annotation used for any SYNCING event.
Syncing.Literal	An annotation literal for the Syncing annotation.
SystemDatagramSocketProvider	SystemDatagramSocketProvider produces JVM default datagram sockets
SystemEnvironmentParameterResolver	A SystemEnvironmentParameterResolver is a ParameterResolver that is an environment getter for Coherence environment properties implemented using System.getenv(String).
SystemPropertyParameterResolver	A SystemPropertyParameterResolver is a ParameterResolver that is based on property methods on System.
SystemPropertyPreprocessor	A SystemPropertyPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that will replace XmlElement content annotated with "system-property" attributes with appropriate System.getProperties().
SystemPropertyResolver	An abstraction that allows us to make system property resolution customizable.
SystemPropertyResolver.Default	Default SystemPropertyResolver implementation.
TaskDaemon	A Daemon thread handler that asynchronously executes Runnable tasks, either at a scheduled time or "as soon as possible".
TCPAcceptorPreprocessor	A TCPAcceptorPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that introduces re-writes <tcp-acceptor> configuration elements, in particular <local-address> declarations into an <address-provider> containing a <local-address>.
TcpAcceptorProcessor	An ElementProcessor that will parse an <tcp-acceptor> and produce a TcpAcceptorDependencies object.
TcpDatagramSocket	TCP based datagram socket implementation.
TcpDatagramSocket.Impl	A specialized version of DatagramSocketImpl.
TcpDatagramSocketProvider	TcpDatagramSocketProvider produces datagram sockets that uses TCP sockets underneath for unicast communication.
TcpDatagramSocketProvider.DefaultDependencies	DefaultDependenceis is a basic implementation of the Dependencies interface providing "setter" methods for each property.
TcpDatagramSocketProvider.Dependencies	Dependencies specifies all dependency requirements of the TcpDatagramSocketProvider.
TcpInitiatorProcessor	An ElementProcessor that will parse an <tcp-initiator> and produce a TcpInitiatorDependencies object.
Term	Term is the abstract class used to represent trees of Terms (term-trees).
TermLanguage	TermLanguage is a simple language for building Terms.
Terms	Terms is a utility class that provides static convenience methods for the construction of Terms.
TermWalker	TermWalker is a visitor class that provides a framework for walking Term Trees
ThreadFactory	Factory interface for Thread creation.
ThreadGate<R>	A thin extension of ThreadGate.
ThreadGateLite<R>	ThreadGateLite is a Gate implementation built around the ReentrantReadWriteLock.
ThreadGateLite.Bar	Bar represents the state of the bars placed on this gate.
ThreadLocalObject	This class provides an implementation of thread local storage.
ThreadPoolManager	A ThreadPoolManager manages the thread pool information for a Coherence service thread pool.
ThreadPoolSizingStrategy	A ThreadPoolSizingStrategy is a pluggable strategy used by a Coherence service thread pool to manage its size.
ThrowablePofSerializer	PofSerializer implementation that can serialize and deserialize a Throwable to/from a POF stream.
TimeHelper	Class for providing time functionality.
Timeout	Timeout provides a mechanism for allowing a thread to interrupt itself if it doesn't return to a specific call site within a given timeout.
TokenTable	TokenTable is a helper class used by Scanners to convert BaseTokens to to OPTokens.
TopicBackingMapManager<D extends TopicDependencies,S extends NamedTopicScheme>	A base class for topic backing map managers.
TopicDependencies	The dependencies for a topic.
TopicException	A exception that occurred during an operation on a NamedTopic.
TopicMapping	A TopicMapping captures configuration information for a pattern-match-based mapping from a proposed NamedTopic name to a topic scheme.
TopicMappingProcessor	An TopicMappingProcessor is responsible for processing <topic-mapping> XmlElements to produce a TopicMapping.
TopicPublisherException	An exception that occurred during publishing of a message on a topic.
TopicScheme<C extends NamedCollection,S>	The TopicScheme class is responsible for building a fully configured instance of a topic.
TopicSchemeMappingProcessor	An TopicSchemeMappingProcessor is responsible for processing <topic-scheme-mapping> XmlElements to update the ResourceMappingRegistry with ResourceMappings.
TopicService	A TopicService is a service providing Topics that can be used for publish/subscribe functionality and message queue processing.
TopNAggregator<K,V,T,E>	TopNAggregator is a ParallelAwareAggregator that aggregates the top N extracted values into an array.
TopNAggregator.PartialResult<E>	The sorted partial result.
TouchProcessor	Touches an entry (if present) in order to trigger interceptor re-evaluation and possibly increment expiry time.
TraceStatementBuilder	A StatementBuilder that builds the QueryPlus "TRACE" command.
TracingDaemonPool	A DaemonPool implementation that wraps another DaemonPool and adds activation of tracing spans for the Runnables executed by this pool.
TracingDaemonPool.TracingRunnable	A Runnable that executes another runnable after activating a tracing span.
TransactionalPreprocessor	A TransactionalPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that introduces (via cloning) internal cache-config xml content for xml elements.
TransactionalScheme	The TransactionalScheme class builds a transactional cache.
TransactionEvent	A TransactionEvent captures information pertaining to all mutations performed within the context of a single request.
TransactionEvent.Type	The TransactionEvent types.
TransactionEvents	TransactionEventInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive TransactionEvents.
TransactionMap	ConcurrentMap with additional transaction support.
TransactionMap.Validator	A callback interface used by TransactionMap implementations.
TransferEvent	A TransferEvent captures information concerning the transfer of a partition for a storage enabled member.
TransferEvent.RecoveryTransferEvent	A RecoveryTransferEvent is raised due to the recovery of a partition from a persistent store.
TransferEvent.Type	The TransferEvent types.
TransferEvents	TransferEventInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive TransferEvents.
TransformerProcessor	Responsible for processing view-filter elements.
Transition<S extends Enum<S>>	A Transition represents a transition in a FiniteStateMachine from one or more possible states to a desired state.
TransitionAction<S extends Enum<S>>	A TransitionAction encapsulates the actions to be performed as part of the Transition from one state to another.
Tree	A thread-safe balanced binary search tree.
TruncateCacheStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a TruncateCacheStatementBuilder.TruncateCacheStatement.
TruncateCacheStatementBuilder.TruncateCacheStatement	Implementation of the CohQL "TRUNCATE CACHE" command.
Truncated	A qualifier annotation used for any TRUNCATED event.
Truncated.Literal	An annotation literal for the Truncated annotation.
TypeAssertion<K,V>	Defines a NamedMap.Option for asserting the type of keys and values used with a NamedCache.
TypeAssertion.WithTypesAssertion<K,V>
UID	A UID is a 128-bit identifier that is almost guaranteed to be unique.
UnitCalculatorBuilder	The UnitCalculatorBuilder class builds a ConfigurableCacheMap.UnitCalculator.
UnitCalculatorProcessor	A UnitCalculatorProcessor is responsible for processing a unit-calculator XmlElement to produce a UnitCalculatorBuilder.
Units	Units is a union of MemorySize and unit count.
UniversalExtractor<T,E>	Universal ValueExtractor implementation.
UniversalExtractorBuilder	An ExtractorBuilder implementation that will build instances of UniversalExtractors.
UniversalUpdater	Universal ValueUpdater implementation.
Unsafe	A collection of "back-door" utilities and helpers used internally.
UnsolicitedCommitEvent	An UnsolicitedCommitEvent captures changes pertaining to all observed mutations performed against caches that were not directly caused (solicited) by the partitioned service.
UnsolicitedCommitEvent.Type	The UnsolicitedCommitEvent types.
UnsolicitedCommitEvents	UnsolicitedCommitInterceptor is an annotation that should be applied to EventInterceptor implementations that want to receive UnsolicitedCommitEvents.
UnsupportedFeatureProcessor	UnsupportedFeatureProcessor is an ElementProcessor that fails fast highlighting which feature is not supported in this edition of the product.
Updated	A qualifier annotation used for any UPDATED event.
Updated.Literal	An annotation literal for the Updated annotation.
UpdaterProcessor<K,V,T>	UpdaterProcessor is an EntryProcessor implementations that updates an attribute of an object cached in an InvocableMap.
UpdateStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a UpdateStatementBuilder.UpdateStatement.
UpdateStatementBuilder.UpdateStatement	Implementation of the CohQL "UPDATE" command.
Updating	A qualifier annotation used for any UPDATING event.
Updating.Literal	An annotation literal for the Updating annotation.
UriSerializable	An interface for URI serialization.
URLCertificateLoader	A PrivateKeyLoader that loads a Certificate file from a URL.
URLKeyStoreLoader	A KeyStoreLoader that loads a KeyStore file from a URL.
URLMemberIdentityProvider	A MemberIdentityProvider that retrieves identity values from URLs, files, or class path resources.
URLPasswordProvider	A PasswordProvider that reads the contents of a URL to obtain a password.
URLPrivateKeyLoader	A PrivateKeyLoader that loads a PrivateKey file in PEM format from a URL.
UsernameAndPassword	Security token containing a username and password.
Utf8Reader	A Utf8Reader is used to read character data from an underlying stream.
Utf8Writer	A Utf8Writer is used to write character data onto an underlying stream.
UUID	A UUID is a 256-bit identifier that, if it is generated, is statistically guaranteed to be unique.
ValidateSnapshotStatementBuilder	An implementation of a StatementBuilder that parses a CohQL term tree to produce an instance of a ValidateSnapshotStatementBuilder.ValidateSnapshotStatement.
ValidateSnapshotStatementBuilder.ValidateSnapshotStatement	Implementation of the CohQL "VALIDATE [ARCHIVED] SNAPSHOT" command.
ValidatingPofHandler	An implementation of PofHandler that validates a POF stream.
Value	A Value is an immutable object that represents a value whose type is unknown at compile time.
ValueChangeEventFilter<V,E>	Filter which evaluates the content of a MapEvent values based on the specified value extractor.
ValueExtractor<T,E>	ValueExtractor is used to both extract values (for example, for sorting or filtering) from an object, and to provide an identity for that extraction.
ValueMacroExpression	A ValueMacroExpression is a string value potentially containing expandable macros.
ValueMacroExpression.DefaultDelimiterExpansionProcessor	Process macro parameter default delimiter expansion.
ValueMacroExpression.MacroExpansionProcessor	A Macro Expansion Processor for a macro not containing any registered delimiters.
ValueMacroExpression.OffsetLengthSubstringExpansionProcessor	Process :offset and :length substring expansion.
ValueMacroExpression.SpaceDefaultDelimiterExpansionProcessor	ValueMacroExpression.SpaceDefaultDelimiterExpansionProcessor performs DefaultDelimiter expansion processing and disambiguates : - for offset and length from space for default delimiter.
ValueManipulator<T,V>	ValueManipulator represents a composition of ValueExtractor and ValueUpdater implementations.
ValueStorageSchemeProcessor	An ElementProcessor that creates a BackingMapScheme for use in a collection scheme.
ValueTypeAssertion<V>	Defines a NamedCollection.Option for asserting the type of values used with a NamedTopic.
ValueTypeAssertion.WithValueTypeAssertion<V>	Defines a NamedCollection.Option for asserting the type of values used with a NamedTopic.
ValueUpdater<T,U>	ValueUpdater is used to update an object's state.
Versionable<T extends Comparable<? super T>>	An interface for versionable data.
VersionAwareMapListener<K,V>	Direct implementations of this interface are generally considered advanced use cases, such as handling event receiver (client process) restarts.
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
VersionedOwnership	An extension of the partition Ownership object which also carries a change version.
VersionedPartitions	VersionedPartitions implementations provide a mapping from partition to version.
VersionedPartitions.Iterator<T>	An Iterator for partitions being tracked by a VersionedPartitions implementation that allows retrieval of the next partition as a primitive.
VersionedPartitions.VersionedIterator	An Iterator for partitions being tracked by a VersionedPartitions implementation that allows retrieval of partition and version.
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.
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.
View	A qualifier annotation used when injecting a cache view.
View.Literal	An annotation literal for the View annotation.
ViewBuilder<K,V>	The ViewBuilder provides a means to ViewBuilder.build() a view (ContinuousQueryCache) using a fluent pattern / style.
ViewMBean
ViewMBeanImpl
ViewScheme	A Scheme that realizes both services and caches for Coherence 12.2.1.4 feature named 'views'.
ViewSchemePreprocessor	DocumentElementPreprocessor.ElementPreprocessor for the "view-scheme" element.
VolatileHolder<V>	VolatileHolder is a basic implementation of the Holder interface where the held object is referenced from a volatile reference.
WheneverStatementBuilder	A class that builds the QueryPlus "WHENEVER" command.
WhereFilter	A FilterBinding annotation representing a Filter produced from a CohQL where clause.
WhereFilter.Literal	An annotation literal for the WhereFilter annotation.
WrapperBufferInput	This is an imitation BufferInput implementation that provides the BufferInput interface by delegating to an object that implements the DataInput interface.
WrapperBufferInput.VersionAwareBufferInput	A BufferInput implementation that in addition to delegating to the given DataInput provides an API to check whether the sender of the content of this BufferInput runs a version that supersedes (greater or equal to) the specified version.
WrapperBufferOutput	This is an imitation BufferOutput implementation that provides the BufferOutput interface by delegating to an object that implements the DataOutput interface.
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.
WrapperCacheService	CacheService implementation that delegates to a wrapped CacheService instance.
WrapperCachingScheme	A simple implementation of the CachingScheme interface built as a wrapper around another CachingScheme implementation.
WrapperCollections	A collection of abstract Collection implementation classes for wrapping Collection types.
WrapperCollections.AbstractWrapperCollection<E>	Collection implementation which delegates all calls to another Collection.
WrapperCollections.AbstractWrapperEntry<K,V>	Map.Entry implementation which delegates all calls to another Map.Entry.
WrapperCollections.AbstractWrapperIterator<E>	Iterator implementation which delegates all calls to another Iterator.
WrapperCollections.AbstractWrapperList<E>	List implementation which delegates all calls to another List.
WrapperCollections.AbstractWrapperLongArray<V>	Abstract wrapper implementation for LongArrays.
WrapperCollections.AbstractWrapperMap<K,V>	Map implementation which delegates all calls to another Map.
WrapperCollections.AbstractWrapperSet<E>	Set implementation which delegates all calls to another Set.
WrapperCollections.AbstractWrapperSortedSet<E>	SortedSet implementation which delegates all calls to another SortedSet.
WrapperCollections.ConcurrentWrapperCollection<E>	Collection implementation which uses a ReadWriteLock to manage concurrent access to an underlying Collection.
WrapperCollections.ConcurrentWrapperEntry<K,V>	Map Entry implementation which uses a ReadWriteLock to manage concurrent access to an underlying Map Entry.
WrapperCollections.ConcurrentWrapperEntrySet<K,V>	Map Entry Set implementation which uses a ReadWriteLock to manage concurrent access to the underlying Entry objects.
WrapperCollections.ConcurrentWrapperMap<K,V>	Map implementation which uses a ReadWriteLock to manage concurrent access to an underlying Map.
WrapperCollections.ConcurrentWrapperSet<E>	Set implementation which uses a ReadWriteLock to manage concurrent access to an underlying Set.
WrapperConcurrentMap<K,V>	A simple implementation of ConcurrentMap interface built as a wrapper around any Map implementation.
WrapperConcurrentMap.Lock	A lock object.
WrapperDataInputStream	This is an imitation DataInputStream class that provides the DataInput interface by delegating to an object that implements the DataInput interface.
WrapperDataOutputStream	This is an imitation DataOutputStream class that provides the DataOutput interface by delegating to an object that implements the DataOutput interface.
WrapperException	A WrapperException wraps a Throwable object as a RuntimeException.
WrapperInputStream	This is an InputStream class that delegates to another InputStream.
WrapperInvocationService	InvocationService implementation that delegates to a wrapped InvocationService instance.
WrapperMBeanServerProxy	A MBeanServerProxy that wraps a MBeanServer.
WrapperNamedCache<K,V>	A simple implementation of NamedCache interface built as a wrapper around any Map implementation.
WrapperObjectInputStream	This is an imitation ObjectInputStream class that provides the ObjectInput interface by delegating to an object that implements the ObjectInput interface.
WrapperObjectOutputStream	This is an imitation ObjectOutputStream class that provides the ObjectOutput interface by delegating to an object that implements the ObjectOutput interface.
WrapperObservableMap<K,V>	A simple implementation of ObservableMap interface built as a wrapper around any Map implementation.
WrapperOutputStream	This is an OutputStream class that delegates to another OutputStream.
WrapperQueryRecorderFilter<T>	QueryRecorderFilter wrapper class.
WrapperReentrantGate	A Gate implementation that allows for 2^31 reentrant enter calls by a single thread.
WrapperService	Service implementation that delegates to a wrapped Service instance.
WrapperSessionConfiguration	A SessionConfiguration that delegates to another SessionConfiguration.
WrapperSocketAddressProviderBuilder	The WrapperSocketAddressProviderBuilder wraps an AddressProviderBuilder so that it can produce a SocketAddressProvider.
WrapperStreamFactory	Deprecated. As of Coherence 3.7, deprecated with no replacement.
WrapperStreamFactoryListProcessor	Deprecated.
WriteBuffer	The WriteBuffer interface represents an in-memory block of binary data that is being accumulated (written to).
WriteBuffer.BufferOutput	The BufferOutput interface represents a DataOutputStream on top of a WriteBuffer.
WriterPrintStream	Overrides PrintStream to delegate to a PrintWriter.
WritingPofHandler	An implementation of PofHandler that writes a POF stream to a WriteBuffer using a BufferOutput object.
WritingPofHandler.Complex	A Complex object represents the current complex data structure in the POF stream.
WritingPofHandler.ComplexMap	A ComplexMap object represents a map data structure (with uniform keys or with uniform keys and values) in the POF stream.
XmlAttribute	An XmlAttribute represents an Xml Attribute, defined within an XmlElement.
XmlBean	This is a base class for building XmlSerializable value objects.
XmlBean.BeanInfo	A BeanInfo contains information about the XML bean and its properties.
XmlCollectionWriter	Provider responsible for converting Java collections to a XML formatted stream.
XmlConfigurable	Deprecated.
XmlDocument	An interface for XML document access.
XmlDocumentReference	An XmlDocumentReference provides an mechanism to reference an XmlDocument.
XmlElement	An interface for XML element access.
XmlElementAdapter	An XmlElementAdapter supports properties of type XmlElement.
XmlHelper	This abstract class contains XML manipulation methods.
XmlHelper.ParameterResolver	An interface that describes a callback to resolve a substitutable parameter value.
XmlJaxbMarshaller<T>	Deprecated. As of 12.2.1.0.0, replaced by JaxbXmlMarshaller
XmlKeysWriter	Provider responsible for converting set of keys to a XML formatted stream.
XmlMapWriter	Provider responsible for converting Java maps to an XML formatted stream.
XmlSerializable	An interface for XML serialization.
XmlSerializableAdapter	An XmlSerializableAdapter supports Java objects that implement the XmlSerializable interface.
XmlSerializablePofSerializer	PofSerializer implementation that supports the serialization and deserialization of any class that implements XmlSerializable to and from a POF stream.
XmlSimpleName	Denotes that a class is associated with the processing of a specifically named Xml element or attribute.
XmlValue	An interface for XML element content and element attribute values.
XorFilter	Filter which returns the logical exclusive or ("xor") of two other filters.
XorOperator	A class representing the logical XOR operator.