All Classes and Interfaces
Class
Description
Abstract base class implementation of
InvocableMap.EntryAggregator
that supports streaming aggregation.Abstract base class for asynchronous entry aggregators.
Abstract base class for asynchronous entry processors.
Abstract base class for asynchronous Coherence
repository
implementations.
Abstract base of the BackingMapManager implementations.
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.An abstract BinaryEntry-based bundler that serves as a base for
BinaryEntryStore operation bundling.
Abstract implementation of the BinaryStore interface.
Provides a basic implementation of ByteBufferManager.
An abstract base for processors that implement bundling strategy.
Statistics class contains the latest bundler statistics.
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
A simple base class for ByteSequence implementations.
A naive ByteSequence that glues two ByteSequence instances together.
A naive ByteSequence that represents a portion of another ByteSequence.
Abstract base class for caching CDI interceptors.
An abstract base class for the JCache CacheLoader.
An abstract base class for the JCache CacheLoader.
An
AbstractCachingScheme is a base implementation for an
CachingScheme.A base class for
CertificateLoader implementations.The base implementation of a
CoherenceBasedCache.A base implementation of a
CoherenceBasedCompleteConfiguration.Abstract aggregator that processes values extracted from a set of entries
in a Map, with knowledge of how to compare those values.
Abstract super class for ValueExtractor implementations that are based on
an underlying array of ValueExtractor objects.
The
AbstractCompositeScheme manages a scheme that is used to
build a composite cache consisting of a front map and a back cache/map.Abstract aggregator that processes numeric values extracted from a set of
entries in a Map.
A
ConditionalElementProcessor that provides defined behaviors
for processing empty XmlElements.The behavior of the
ConditionalElementProcessor when it encounters
an empty XmlElement.An abstract entry-based bundler serves as a base for NamedCache.put() and
CacheStore.store() operation bundling.
An abstract base class for custom cache eviction policies.
An abstract base class for implementing Evolvable objects.
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.Abstract base for ValueExtractor implementations.
An abstract base for Invocable and PriorityTask implementations.
Shared implementation between implementations of JCacheStatistics.
The
AbstractJournalScheme contains functionality common to all
Journal schemes.AbstractKeyBasedMap is a base class for Map implementations.
A DeferredCacheEvent is a
CacheEvent object that defers the loading
of the old value.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 is an extension to the AbstractKeyBasedMap that
has a full awareness of the set of keys upon which the Map is based.
A base class for
KeyStoreLoader implementations.The
AbstractLocalCachingScheme is provides common functionality
for local caching schemes, including local-scheme, external-scheme, etc.Abstract aggregator that processes numeric values extracted from a set of
entries in a Map.
An implementation of portions of the LongArray interface.
A base class that simplifies the implementation of a MapListener,
particularly inner classes that only implement one or two of the
three event methods.
Abstract base class for built-in marshallers.
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.The AbstractNioManagerBuilder class is an abstract class used to build
an NIO file manager or an NIO memory manager.
Abstract base class for partitioned iterators.
Abstract implementation of a ReadBuffer-based PersistentEnvironment.
Continuation implementation that accepts a Throwable and throws a
PersistenceException.
Abstract implementation of a ReadBuffer-based PersistentManager.
A collection of tasks to execute in a loop.
Abstract implementation of PersistenceTools which can be extended for either
local or archived snapshot operations.
An implementation of a
CachePersistenceHelper.Visitor to collect details
statistics from the snapshot we are analysing.An abstract implementation of PofHandler that delegates to a PofHandler.
Abstract base class for static, path-based implementations of
PofNavigator interface.An abstract base class that implements common functionality for all
PofValue types.
An abstract base for PriorityTask implementations.
A base class for
PrivateKeyLoader implementations.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.Abstract base class for QueryEngine implementations.
Immutable helper class that wraps both final query string and a map
of parameter types, keyed by parameter name.
This is the base class for command builders that are specific to the QueryPlus
tool rather than general CohQL statements.
Abstract base class implementation of
QueryRecorderFilter.Abstract base implementation of the ReadBuffer interface.
Abstract base class for Coherence
repository
implementations.
Base functionality for all Coherence
repository
implementations.
An interface that should be implemented by the clients interested in
repository events.
A builder for a simple, lambda-based
AbstractRepositoryBase.Listener.Adapter from
AbstractRepositoryBase.Listener to MapListener that can be
registered with the backing NamedMap.An abstract base class for thread-safe
LongArrays which are protected by lock(s).The
AbstractScheme is the base implementation of a Scheme.AbstractScriptBase is the base class for script based processing.
An abstract base class for serialization-based caches.
An abstract base for ServiceLoadBalancer implementations.
The
AbstractServiceScheme provides functionality common to all
schemes that use services.An abstract implementation of a
SnapshotArchiver which must be extended
to create a specific implementation.Abstract implementation of an
AbstractStatement providing functionality
useful for generic snapshot statements.A data structure resembling an array indexed by long values, stored as an
AVL tree.
An AVL tree node.
An abstract implementation of a snapshot operation which can
be extended to support different persistence operations.
Deprecated.
A base class for
Statement implementations.A base class for
StatementBuilder implementations.A base implementation of BinaryStoreManager interface that uses
BinaryMap objects built on a ByteBufferManager to provide
BinaryStore objects.The AbstractStoreManagerBuilder class builds an instance of a
BinaryStoreManager.
Abstract base for ValueUpdater implementations.
The AbstractWriteBuffer is a partial implementation of the WriteBuffer
interface intended to be used as a base class for easily creating concrete
WriteBuffer implementations.
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.
An
ElementProcessor that will parse an <acceptor-config> and
produce an AcceptorDependencies.The AccessController interface is used by the cluster services to verify
whether or not a caller has sufficient rights to access protected clustered
resources.
An Action represents a controllable action or behavior that a Service might
perform.
ActionPolicy defines which aspects of a Service's behavior are currently
allowed.
The abstract
ActionPolicyBuilder is a base class builder for building ActionPolicy's instances
and defers cache configuration validation until the instance is realized.ActionPolicyBuilder wrapper for a ParameterizedBuilder.ActionPolicy Null Implementation
Intermediate QuorumRule with enough information to report a ConfigurationException
at instantiation time.
A qualifier annotation used for any ACTIVATED event.
An annotation literal for the
Activated
annotation.A qualifier annotation used for any ACTIVATING event.
An annotation literal for the
Activating
annotation.A
BaseOperator implementation representing the
addition (+) operator.The AddressProvider is a subclass interface of
SocketAddressProvider
which returns InetSocketAddress from AddressProvider.getNextAddress().AddressProviderBuilder interface
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)A factory for
AddressProvider objects.The AggregatorConfig class encapsulates information related to a
Coherence REST EntryAggregator configuration.
A factory for aggregators.
A registry for
AggregatorFactory instances.Simple Aggregator DSL.
Filter which returns the logical "and" of a filter array.
A
FilterBinding annotation representing an
AlwaysFilter.Filter which always evaluates to true.
An annotation literal for the
AlwaysFilter
annotation.Filter which returns the logical "and" of two other filters.
An operator representing a logical AND (&&).
MapListener implementation that dispatches MapEvents
to a CDI observer.A producer of
Filter instances.A producer of
MapEventTransformer instances.Registers discovered CDI observer-based
MapListeners when the cache is
created, and unregisters them when it's destroyed.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.A silent
NotificationEmitter implementation for all NotificationEmitter
methods except getNotificationInfo().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.An
AnnotationDrivenModel is a Model created through extracting
information defined by Transitions annotation.A representation of an
Annotation that can be used for equality tests
where methods in the Annotation annotated with Nonbinding are ignored.Supports inline instantiation of annotation type instances.
An AnyEvent is an event used when no specific event implementation fits
and it is not worth making one.
Filter which returns the logical "or" of a filter array.
An AnyEvent is an event used when no specific event implementation fits
and it is not worth making one.
Deprecated.
this API is intended for internal purposes only and will be removed
in a future version of Coherence
FileFilter implementation that only includes directories.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a ArchiveSnapshotStatementBuilder.ArchiveSnapshotStatement.Implementation of the CohQL "ARCHIVE SNAPSHOT" command.
An ArrayAdapter supports properties of Java array types (not including
arrays of primitive types).
Filter which is a logical operator of a filter array.
A thin wrapper around a Filter allowing for sorting the filters
according to their effectiveness.
A qualifier annotation used for any ARRIVED event.
An annotation literal for the
Arrived
annotation.An AssertionException is thrown when an assertion fails.
Class for providing assertion functionality.
A qualifier annotation used for any ASSIGNED event.
An annotation literal for the
Assigned
annotation.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.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.A
boolean value that may be updated atomically.A
int value that may be updated atomically.A
long value that may be updated atomically.An
AtomicMarkableReference maintains an object reference
along with a mark bit, that can be updated atomically.An object reference that may be updated atomically.
An
AtomicStampedReference maintains an object reference
along with an integer "stamp", that can be updated atomically.An
ElementProcessor for an <async-backup> Configuration.An AsyncBinaryStore is a BinaryStore wrapper that performs the "O" (output)
portion of its I/O asynchronously on a daemon thread.
An AsyncBinaryStoreManager is a wrapper BinaryStoreManager that creates
wrapper AsyncBinaryStore objects.
Base class for asynchronous operations that provides a simple implementation
of the
Future interface.A marker
EntryAggregator wrapper class that allows for
an asynchronous invocation of the underlying aggregator.An
EntryProcessor wrapper class that allows for
an asynchronous invocation of the underlying processor.Local implementation of
AsyncAtomicBoolean interface,
that simply wraps java.util.concurrent.atomic.AtomicBoolean
instance and returns an already completed future from each method.Local implementation of
AsyncAtomicInteger interface,
that simply wraps java.util.concurrent.atomic.AtomicInteger
instance and returns an already completed future from each method.Local implementation of
AsyncAtomicLong interface,
that simply wraps java.util.concurrent.atomic.AtomicLong
instance and returns an already completed future from each method.Local implementation of
AsyncAtomicMarkableReference interface, that
simply wraps java.util.concurrent.atomic.AtomicMarkableReference instance
and returns an already completed future from each method.Local implementation of
AsyncAtomicReference interface,
that simply wraps java.util.concurrent.atomic.AtomicReference
instance and returns an already completed future from each method.Local implementation of
AsyncAtomicStampedReference interface, that
simply wraps java.util.concurrent.atomic.AtomicStampedReference instance
and returns an already completed future from each method.Asynchronous
NamedCache.Asynchronous
NamedMap.An immutable option for creating and configuring
AsyncNamedMaps.A configuration option which determines the ordering of async operations.
The remote implementation of
AsyncAtomicBoolean, backed by a
Coherence NamedMap entry.The remote implementation of
AsyncAtomicInteger, backed by a
Coherence NamedMap entry.The remote implementation of
AsyncAtomicLong, backed by a
Coherence NamedMap entry.The remote implementation of
AsyncAtomicMarkableReference, backed by a
Coherence NamedMap entry.The remote implementation of
AsyncAtomicReference, backed by a
Coherence NamedMap entry.The remote implementation of
AsyncAtomicStampedReference, backed by a
Coherence NamedMap entry.The AsyncStoreManagerBuilder class builds and instance of an
AsyncBinaryStoreManager.
A
boolean value that may be updated atomically.POF serializer implementation.
An
int value that may be updated atomically.POF serializer implementation.
A
long value that may be updated atomically.POF serializer implementation.
An
AtomicMarkableReference maintains an object reference
along with a mark bit, that can be updated atomically.POF serializer implementation.
An object reference that may be updated atomically.
POF serializer implementation.
Factory methods for various atomic value implementations.
Extension to
AtomicMarkableReference
to allow Java serialization.Extension to
AtomicStampedReference
to allow Java serialization.An
AtomicStampedReference maintains an object reference
along with an integer "stamp", that can be updated atomically.POF serializer implementation.
AtomicTerms is the class used to represent literal Terms such as String
and Numbers.
An
AttributeProcessor is responsible for processing XmlAttribute content
to return a strongly-typed value.Simple StorageAccessAuthorizer implementation that logs the authorization
requests and allows operations to proceed.
An
ElementProcessor for <authorized-hosts> Configuration
Elements.This interface represents an environment-specific facility for authorizing callers to perform actions
described by the corresponding permission objects.
An implementation of the BinaryEntry interface that is based on specified
binary key, binary value and BackingMapManagerContext.
The BackingMapContext provides an execution context to server side agents such
as
EntryProcessors and
EntryAggregators.A callback interface used by CacheService implementations.
A
BackingMapManagerBuilder realizes BackingMapManagers.The BackingMapManager context is used by the CacheService to pass information
to the BackingMapManager during the service initialization.
The
BackingMapScheme class is responsible for building a fully
configured instance of a backing map.A BackingMapSchemeProcessor is responsible for processing a
backing-map-scheme
XmlElement to produce a BackingMapScheme.A qualifier annotation used for any BACKLOG event.
An annotation literal for the
Backlog annotation.The backlog event type.
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.An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a BackupStatementBuilder.BackupStatement.Implementation of the CohQL "BACKUP" command.
Base class for providing standard functionality.
Inner class for over-riding the destination of log(), out() and err()
calls.
Reads binary data from a Reader using IETF RFC 2045 Base64 Content
Transfer Encoding.
Writes binary data into a Writer using IETF RFC 2045 Base64 Content
Transfer Encoding.
The
BaseGrpcCacheScheme is responsible for building a
remote gRPC cache service.The
BaseGrpcScheme is responsible for building a
remote gRPC service.A base class for gRPC services.
The default
BaseGrpcServiceImpl.Dependencies implementation.The dependencies to configure a
BaseGrpcServiceImpl.A base class for CohQL Operator implementations.
An extension of
BaseStream that adds support for
the RemotePipeline retrieval.BaseToken is the abstract base class for all tokens processed by the low
level BaseTokenScanner.
BaseTokenScanner gives clients a streaming api that returns a next
BaseToken by processing either a java.lang.String or a java.io.Reader.
BaseTokenScannerExpression is the RuntimeException thrown by the
BaseTokenScanner when expectations are not met.
Since BaseTokens can nest, BaseTokenStream creates for clients a utility
interface that allows streaming (atEnd(), next()) over a CompoundBaseToken.
The BdbStoreManagerBuilder class builds an instance of a
BerkeleyDBBinaryStoreManager.
Element processor for
<cdi:bean> XML element.Element processor for
<cdi:bean/> XML element.An implementation of the BinaryStore interface using Sleepycat Berkeley
DB Java Edition.
An implementation of the BinaryStoreManager interface using Sleepycat
Berkeley DB Java Edition.
Filter which compares the result of a method invocation with a value for
"Between" condition.
An operator representing the "between" conditional operator.
BetweenOPToken is used to parse a SQl like between statment.
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.Calculates a maximum of numeric values extracted from a set of entries in a
Map in a form of a
BigDecimal value.Calculates a minimum of numeric values extracted from a set of entries in a
Map in a form of a
BigDecimal value.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.A thread-safe immutable binary object.
A DeltaCompressor implementation that works with opaque (binary) values.
A
NamedTopic.ElementCalculator that calculates size of an element based on the
size of the serialized binary value.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 is analogous to the
CacheStore, but operates on
BinaryEntry objects.A helper class of methods to convert between
Binary
instances and proto-buffer byte values.Implements the Map interface to store Binary objects using Java's NIO
buffers.
A map entry (key-value pair).
An implementation of BinaryStore backed by a BinaryMap.
A pass-through marshaller that simply converts HTTP entities into a
Binary and vice versa.A UnitCalculator implementation that weighs a cache entry based upon the
amount of physical memory (in bytes) required to store the entry.
A simple mapping of CacheStore operations for Binary objects into a
Java interface.
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.
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.
A CacheStore that sits directly on top of a BinaryStore.
A manager that is capable of creating and destroying BinaryStore objects.
A
BinaryStoreManagerBuilder is responsible for realizing BinaryStoreManagers.A
BinaryStoreManagerBuilderCustomization class is one that allows or potentially requires,
a BinaryStoreManagerBuilder for the purposes of realizing a BinaryStoreManager.a WriteBuffer implementation whose primary purpose is to be used to create
Binary objects.
An interface implemented by bindable gRPC proxy services.
A collection of methods for bit-based operations.
Blocking provides a set of helper methods related to blocking a thread.
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.
An
ElementProcessor for the <buffer-type> Cache Configuration
element.A
Builder provides a mechanism for realizing a specific class of
object as required.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.Provides a collection of helper methods for working with
Builders.The
BundleManager class is responsible for configuring caches
to use bundling.The BundleConfig class contains the configuration for a Bundle.
Bundling NamedCache implementation.
BundlingSchemes define how the bundling (batching)
of operations will occur and the BundleManager used
to configure said bundling.A ReadBuffer on top of a byte array.
ByteArrayWriteBuffer is an implementation of WriteBuffer on a byte array.
Allocator is a WriteBufferPool implementation which allocates a new
ByteArrayWriteBuffer on each request to the pool, and does not retain
the returned buffer.
An InputStream implementation on top of a Java NIO ByteBuffer.
An interface for managing a ByteBuffer.
An OutputStream implementation on top of a Java NIO ByteBuffer.
A ReadBuffer implementation on top of a Java NIO ByteBuffer.
A WriteBuffer implementation on top of a Java NIO ByteBuffer.
Bytes is a specialized MemorySize whose default constructor
assumes that the specified units (when a magnitude is not specified) are always bytes.Represents a sequence of bytes.
Never get the value from cache, get it from method and cache the result.
An annotation literal for the
CacheAdd annotation.A CDI interceptor that always invokes target method and then
caches invocation result before returning it.
Implements a collator which caches its keys.
A
CacheConfig is the top-level container for Coherence Cache
Configuration, that of which is used at runtime to establish caches and
services.The
CacheConfigNamespaceHandler is responsible for capturing and creating Coherence
Cache Configurations when processing a Coherence Configuration file.A class that can add extensions to the
CacheConfigNamespaceHandler.Implementation of
OverrideProcessor that process cache configuration
override file.A
CacheDefaultsPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that introduces (via cloning) default xml
content for xml elements where the said content is missing.An extension of the MapEvent which allows to differentiate between client
driven (natural) events and cache internal (synthetic) events.
TransformationState describes how a CacheEvent has been or should be
transformed.An extension of the
MapEventFilter which allows selection of client
driven (natural) events, cache internal (synthetic) events, or both.Factory for the Coherence™ cache product.
CacheFactoryBuilder provides the means for building and managing configurable
cache factories across class loaders in a pluggable fashion.
Get the value from cache if present, invoke the method and cache the result
otherwise.
An annotation literal for the
CacheGet annotation.A CDI interceptor that returns cached value if present; otherwise it
returns and caches result of target method invocation.
Parameters annotated with this annotation are considered part of the key.
A CacheLifecycleEvent allows subscribers to capture events pertaining to
the lifecycle of a cache.
The emitted event types for a
CacheLifecycleEvent.A CacheLifecycleEventDispatcher raises
CacheLifecycleEvents.CacheLifecycleEvents is an annotation that should be applied to
EventInterceptor implementations
that want to receive CacheLifecycleEvents.A JCache CacheLoader.
A read-only CacheStore that wraps a CacheLoader.
An extension to the CacheLoaderCacheStore that implements the
IterableCacheLoader interface.
A CacheMap is a Map that supports caching.
A
CacheMapping captures configuration information for a pattern-match-based mapping from a proposed
NamedCache name to a caching scheme.An
CacheMappingProcessor is responsible for processing <cache-mapping> XmlElements to produce
a CacheMapping.Deprecated.
As Coherence 14.1.1, use
ResourceMappingRegistry.A qualifier annotation used to indicate a specific cache name.
An annotation literal for the
CacheName annotation.Static helper methods used in the persistence of a partitioned cache.
The Visitor interface allows the "iteration" of the persisted contents
(and metadata) of a cache service in the style of the
Visitor Pattern.
Deprecated.
Put a value to cache AND call the method.
An annotation literal for the
CachePut annotation.A CDI interceptor that stores parameter value in the Coherence cache.
Remove the value from the cache and call the method.
An annotation literal for the
CacheRemove annotation.A CDI interceptor that removes value from the cache and invokes target method.
A class that holds a gRPC request, an associated
NamedCache
and Binary converters.RESTful wrapper around a Coherence
NamedCache.A CacheService is a clustered service providing a collection of named Maps
that hold resources shared among members of a cluster.
CacheAction represents a type of action taken by a CacheService.
An
ElementProcessor that will parse cache-service-proxy configuration
element tp produce a DefaultCacheServiceProxyDependencies object.An interface for exposing Cache statistics.
A JCache cache store.
A backing Map implementation that delegates all operations to a CacheStore.
A Map implementation that delegates straight through to a CacheStore.
The
CacheStoreScheme class is responsible for building a fully
configured instance of a CacheStore, CacheLoader or remote NamedCache.Marks a parameter as the cache value.
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.
The
CachingScheme is a multi-builder for cache-based infrastructure.An
CachingSchemeMappingProcessor is responsible for processing <caching-scheme-mapping> XmlElements
to update the ResourceMappingRegistry with CacheMappings.A
CachingSchemesProcessor is an ElementProcessor for the
<caching-schemes%gt; element of Coherence Cache Configuration files.A
ConfigurableCacheMap backed by Caffeine.The
CaffeineScheme class is responsible for building a fully
configured instance of a CaffeineCache.CanonicallyNamed provides a way for objects to identify themselves by name.
Bridges the gap between
ServiceLoader and CDI, by registering itself
as a service and using CDI to discover available CDI-managed ConfigSources.An observer of events that wraps a CDI
ProcessObserverMethod.An implementation of
Injector that uses
the CDI bean manager to inject dependencies.An implementation of
InterceptorMetadataResolver
that knows how to extract interceptor metadata from a Weld proxy.An implementation of a
AnnotatedMapListener.MapEventObserver
that wraps a CDI ObserverMethod that observes MapEvent.Registers discovered CDI observer-based
MapListeners when the cache is
created, and unregisters them when it's destroyed.Bridges the gap between
ServiceLoader and CDI, by registering itself
as a service and delegating to all discovered CDI beans that implement
MetricsRegistryAdapter interface.Custom namespace handler for
cdi namespace.A class that can load an array of
certificates.An unmodifiable Collection that provides access to many collections in the
given order.
Composite comparator implementation based on a collection of comparators.
Provide an enumerator which enumerates the contents of multiple
enumerators.
A
ExtractorBinding annotation representing a
ChainedExtractor.Composite ValueExtractor implementation based on an array of extractors.
A holder for the repeatable
ChainedExtractor annotation.An annotation literal for the
ChainedExtractor.Extractors annotation.An annotation literal for the
ChainedExtractor annotation.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.A
ValueExtractor that extracts a Fragment from a
nested property of the target object.Chains two maps into one virtual map.
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.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.An unmodifiable Set that provides access to many sets in the
given order.
Provides a mechanism to represent and mutate a Cache Entry that was changed
in a Federated Cache.
Represents the key, value and name of the Participant from
which the entry originated.
ChangeRecordUpdater allows to update the given
ChangeRecord while processing the
FederatedChangeEvent.Resizable-array implementation of the List interface.
This abstract class contains dynamic (reflect-based) class, method, and
field manipulation methods.
Filter which discards all objects that are not of a certain class.
This abstract class contains dynamic (reflect-based) class, method, and
field manipulation methods.
The ClassLoaderAware interface provides the ability to configure a ClassLoader
to be used by the implementing object when loading classes or resources.
The
ClassScheme class is responsible for building custom CachingSchemes and
custom CacheStoreSchemes.This interface is meant to "fix" the usability issues related to the
Cloneable method-less interface.A Cloner provides an external means for producing copies of objects as
prescribed by the
Object.clone() contract.The Cluster interface represents a collection of
services that operate in a clustered network environment.
MemberTimeoutAction is taken by the cluster service to remove members from
the cluster who have exceeded a network timeout (e.g. packet-timeout).
The ClusterDependencies interface defines externally provided dependencies
for a
Cluster.A provider of nw service instances.
The ClusteredCachingScheme interface represents schemes that are used
for clustered caches.
Deprecated.
As of release 3.4, replaced by
PortableExceptionThis class represents access to a clustered resource such as a Service
or NamedCache.
A CDI producer that produces instances of the singleton Coherence
Cluster.Defer cache configuration validation of a
ClusterQuorumPolicyBuilder until realized.A Codec provides an interception point for any specific code that needs to
be executed pre or post (de)serialization.
Codecs is a container for accessing default
Codec implementations.Abstract
Codec implementations that encodes objects by simply
delegating to PofWriter.writeObject(int, Object).Implementation of
Codec that delegates to
PofReader.readObjectArray(int, Object[]) and
PofWriter.writeObjectArray(int, Object[]) to deserialize and serialize
an object.Implementation of
Codec that delegates to
PofReader.readCollection(int, Collection) and
PofWriter.writeCollection(int, Collection) to deserialize and
serialize an object.Implementation of
Codec that simply delegates to
PofReader.readObject(int) and
PofWriter.writeObject(int, Object) to deserialize and serialize
an object.Implementation of
Codec that delegates to
PofReader.readLongArray(int, LongArray) and
PofWriter.writeLongArray(int, LongArray) to deserialize and serialize
an object.Implementation of
Codec that delegates to
PofReader.readMap(int, Map) and
PofWriter.writeMap(int, Map) to deserialize and serialize
an object.A builder to build
Coherence instances.An interface implemented by listeners of
CoherenceLifecycleEvents.An enum representing the different modes that a
Coherence
instance can run in.An Coherence-based implementation of a
Cache.The Coherence-based implementation of a
CacheManager.The Coherence-based implementation of a
CachingProvider.An Coherence-based
CompleteConfiguration that provides
setter methods.A
Configuration for a CoherenceBasedCache.A
Cache.Entry implementation.A minimal implementation of the
CacheEntryEvent.An adapter to provide
Iterables over Cache Entries, those of which
are filtered using a CacheEntryEventFilter.An
Iterators to allow filtering of CacheEntryEvents.A runtime representation of a
CacheEntryListener registration, including
its CacheEntryListenerConfiguration.Collects and appropriately dispatches
CacheEntryEvents to
CacheEntryListeners.The Coherence implementation of a
CacheMXBean.An implementation of
ConfigSource
that reads configuration properties from a Coherence map.The immutable configuration for a
Coherence instance.A builder to build a
CoherenceConfiguration instance.A simple immutable implementation of
CoherenceConfiguration.An
InternalConverter that uses two Coherence Converters
as a means of performing conversions to and from internal representations.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.A CoherenceDispatcher raises
Events pertaining to
operations on a Coherence instance:
CoherenceLifecycleEvents
A Coherence-based
EntryProcessorResult.A Coherence CDI
Extension that is used on both cluster members and
the clients.A provider of
NamedEventInterceptor instances.A
CoherenceLifecycleEvent allows subscribers
to capture events pertaining to the lifecycle of
a Coherence instance.The emitted event types for a
CoherenceLifecycleEvent.CoherenceLifecycleEvents is an annotation that should be applied to
EventInterceptor implementations
that want to receive CoherenceLifecycleEvents.A producer that creates the default
Coherence bean.CoherenceQueryLanguage is a simple language for building
Filters and doing simple queries that are similar in style to SQL.
Coherence QL-based implementation of
QueryEngine.A Coherence CDI
Extension that should only be used within the
cluster members.An implementation of a
Session allowing applications to use
the new operator to create a Session via the default
SessionProvider.Allows us to register Coherence-specific tags by augmenting the value
returned by the
CoherenceTagsConfigSource.GLOBAL_TAGS_VARIABLE config property.An exception thrown when errors occur building CohQL queries.
A CollectionAdapter supports properties whose types implement the
java.util.Collection interface.
Deprecated.
As of Coherence 12.1.2
A Collector is mechanism for receiving items.
Colon is used to make attributes in a list or bag.
A class that builds the QueryPlus "COMMANDS" command.
A qualifier annotation used for any COMMITTED event.
An annotation literal for the
Committed
annotation.A qualifier annotation used for any COMMITTING event.
An annotation literal for the
Committing
annotation.A qualifier annotation used for any COMMITTING_LOCAL event.
An annotation literal for the
CommittingLocal
annotation.A qualifier annotation used for any COMMITTING_REMOTE event.
An annotation literal for the
CommittingRemote
annotation.Calculates a maximum among values extracted from a set of entries in a Map.
Calculates a minimum among values extracted from a set of entries in a Map.
Comparator builder that provides a small set of builder methods to
simplify creation of a chain of
ExtractorComparators from given
ValueExtractors.ComparatorHelper is a utility class that provides a factory method used to
create a java.util.Comparator instance from a string expression.
Filter which compares the result of a method invocation with a value.
A base class for comparison operators, which are operators
that are used in conditional clauses such as equals, greater than,
less than, etc.
A synthetic ValueExtractor that returns a result of comparison between two
values extracted from the same target.
An abstract base class for complex POF types, such as collections, arrays,
maps, and user types.
CompositeActionPolicy represents the "intersection" of two policies.
CompositeAddressProvider is a composite of one or more AddressProviders or
addresses that also implements the Set interface.
An Iterator over the addresses in this AddressProvider.
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.
Deprecated.
As of Coherence 12.2.1.
Key class that consists of a primary and secondary component.
The CompositeProcessor represents a collection of entry processors that are
invoked sequentially against the same Entry.
A
CompositeSchemeProcessor is a CustomizableBuilderProcessor for schemes
that consist of a front and back scheme.CompositeSocketAddressProvider is a composite of one or more
SocketAddressProviders.
A ValueUpdater implementation based on an extractor-updater pair that could
also be used as a ValueManipulator.
CompoundBaseToken is the abstract base class for all tokens processed by the
low level BaseTokenScanner that are made up of two or more BaseTokens.
Deprecated.
As of Coherence 3.7
DeflaterOutputShell enforces the "end" call for the
corresponding Deflater object.
InflaterInputShell enforces the "end" call for the
corresponding Inflater object.
Map with additional concurrency features.
A Condition-like object, usable by multiple threads to both wait and signal.
A link in a stack of waiting threads.
A
ConditionalElementProcessor is an ElementProcessor that supports conditionally
processing XmlElements.An IndexAwareExtractor implementation that is only used to create a
ConditionalIndex.ConditionalIndex is a
MapIndex implementation that uses an associated
filter to evaluate whether or not an entry should be indexed.Conditional entry processor represents a processor that is invoked
conditionally based on the result of an entry evaluation.
ConditionalPut is an EntryProcessor that performs an
Entry.setValue
operation if the specified condition is satisfied.ConditionalPutAll is an EntryProcessor that performs a
Entry.setValue operation for multiple entries that satisfy the specified
condition.ConditionalRemove is an EntryProcessor that performs an
Entry.remove
operation if the specified condition is satisfied.Config is a helper class for processing a Coherence configuration
system properties.An event that will be raised whenever any config property is added to,
updated in, or removed from the
CoherenceConfigSource.An implementation of Coherence property resolvers that reads system
properties and environment variables from MP Config.
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:
A stateful holder for an obtaining an InetSocketAddress object.
Deprecated.
An interface for cache factory.
A factory of
ConfigurableCacheFactory supplier functions
that can return a ConfigurableCacheFactory for a given
scope name.The default
ConfigurableCacheFactory supplier.A fixed
ConfigurableCacheFactory supplier that only supplies
the ConfigurableCacheFactory instances provided when it was
constructed.An extension to the CacheMap interface that supports runtime configuration
and monitoring of various caching properties.
A cache Entry carries information additional to the base Map Entry in
order to support eviction and expiry.
EvictionApprover is used to approve the eviction of an entry
from the underlying ConfigurableCacheMap.
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.
A unit calculator is an object that can calculate the cost of caching
an object.
ConfigurableLocalAddressProvider is an AddressProvider which is only
capable of returning local addresses.
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.The information related to the configuration of a particular PofContext
for a specific URI and ClassLoader.
ConfigurableQuorumPolicy provides a Quorum-based
ActionPolicy for
services based on the cluster-configuration.ClusterQuorumPolicy defines an action policy that is applicable to the
cluster.
MembershipQuorumPolicy is a quorum policy that is stateless and based
solely on service membership sizes.
A quorum rule defines a set of allowable actions beyond the rule's
threshold size.
PartitionedCacheQuorumPolicy defines a configurable quorum policy that is
applicable to a DistributedCacheService.
Action Rules for
ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicyNotification is a simple struct carrying the notification info.
ProxyQuorumPolicy defines a configurable quorum policy that is applicable
to a proxy service.
Deprecated.
A
SnapshotArchiverFactory implementation that creates instances of
a SnapshotArchiver class configured using an XmlElement.A
ConfigurationException captures information concerning an invalid configuration of Coherence.A
ConfigurationProcessor is responsible for processing a
configuration XmlElement to produce a CacheConfig object.A qualifier annotation used to indicate a configuration resource URI.
An annotation literal for the
ConfigUri annotation.A qualifier annotation used for any CONNECTING event.
An annotation literal for the
Connecting
annotation.Constants used by the Coherence JCache Adapter.
Helpers for supporting Coherence JCache in Container Environment.
An
EventInterceptor that initializes JCache for running within a container.An extension of
PassThroughResourceConfig that should be used for
container deployments of Coherence REST when pass-through is required.An extension of
DefaultResourceConfig that should be used for
container deployments of Coherence REST.Filter which tests a
Collection or Object array value returned from
a method invocation for containment of all values in a Set.An operator representing the conditional "contains all" operation.
Filter which tests a
Collection or Object array value returned from
a method invocation for containment of any value in a Set.An operator representing the conditional "contains any" operation.
Filter which tests a
Collection or Object array value returned from
a method invocation for containment of a given value.An operator representing the conditional "contains" operation.
ContainsOPToken is used to implement a contains operation that checks for
membership in a list.
JCache Statistics implementation.
Continuation interface is used to implement asynchronous post-processing,
the pattern that is also known as the
"Continuation-passing style".
Create a materialized view of a
NamedCache using the Coherence
Continuous Query capability.This scheme is internally used to provide the
ParameterizedBuilder that constructs the view-filter
for the ViewScheme.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.
Provide for "pluggable" object conversions.
Provide for "pluggable" object conversions.
A collection of Collection implementation classes that use the Converter
interface to convert the items stored in underlying collection objects.
An abstract Map Entry that lazily converts the key and value.
A ConfigurableCacheMap.Entry that lazily converts the key and value.
A Converter CacheEvent views an underlying CacheEvent through a set of
key and value Converters.
A converter MapListener that converts events of the underlying
MapListener for the underlying NamedCache.
A Converter CacheMap views an underlying CacheMap through a set of key
and value Converters.
A Converter Collection views an underlying Collection through a
Converter.
A Comparator that Converts the elements before
comparing them.
A Converter ConcurrentMap views an underlying ConcurrentMap through a
set of key and value Converters.
A Map Entry that lazily converts the key and value.
A Converter Entry Set views an underlying Entry Set through a set of
key and value Converters.
Provide an implementation of an enumerator which converts each of the
items which it enumerates.
A Holder that converts the element before returning them.
A Converter InvocableMap views an underlying InvocableMap through a
set of key and value Converters.
A Converter List views an underlying List through a Converter.
A Converter ListIterator views an underlying ListIterator through a
Converter.
ConverterLongArray converts the value of the LongArray from its raw form
(type
F) to the desired from (type T).A Converter Map views an underlying Map through a set of key and value
Converters.
A ConverterMapEvent views an underlying MapEvent through a set of key and
value Converters.
A converter MapListener that converts events of the underlying
MapListener for the underlying map.
A Converter NamedCache views an underlying NamedCache through a set of
key and value Converters.
A Converter ObservableMap views an underlying ObservableMap through a
set of key and value Converters.
A Converter QueryMap views an underlying QueryMap through a set of key
and value Converters.
A Converter Set views an underlying Set through a Converter.
A Converter SortedMap views an underlying SortedMap through a set of
key and value Converters.
A Converter SortedSet views an underlying SortedSet through a
Converter.
Deprecated.
As of Coherence 12.1.2, replaced by
ConverterCollections.ConverterEnumeratorA thread-safe variant of
LongArray in which all mutating operations
(e.g.Unmodifiable view of a LongArray.Iterator.
A thread-safe variant of
Map in which all mutating operations
(e.g.A qualifier annotation used when injecting Coherence resource to specify
the latch count.
Calculates a number of values in an entry set.
An annotation literal for the
Count annotation.An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a CreateCacheStatementBuilder.CreateCacheStatement.Implementation of the CohQL "CREATE CACHE" command.
A qualifier annotation used for any CREATED event.
An annotation literal for the
Created
annotation.An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a CreateIndexStatementBuilder.CreateIndexStatement.Implementation of the CohQL "CREATE INDEX" command.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a CreateSnapshotStatementBuilder.CreateSnapshotStatement.Implementation of the CohQL "CREATE SNAPSHOT" command.
A helper class to resolve gRPC credentials.
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}.
This class builds an AddressProviderBuilder from a customized
ParameterizedBuilder of
AddressProvider.A
CustomizableBinaryStoreManagerBuilderProcessor is a CustomizableBuilderProcessor that additionally
processes the required definition of a BinaryStoreManagerBuilder for those classes supporting
BinaryStoreManagerBuilderCustomization.A
CustomizableBuilderProcessor is a multi-purpose ElementProcessor
responsible for processing xml elements that produce objects supporting BuilderCustomization.The CustomStoreManagerBuilder class builds an instance of a custom
BinaryStoreManager.
A abstract Daemon thread handler.
A
ParameterizedBuilder that builds a DaemonPool.An
Executor that uses a DaemonPool to execute tasks.Daemon pool metrics and management.
An
ElementProcessor to process a daemon pool configuration.DaemonThreadFactory is a ThreadFactory which produces daemon threads.
Factory for Berkeley DB Environments and Databases.
Holder for Berkeley DB Environment and its Databases.
Directory based lock.
A manager for Berkeley DB Database factories.
Provides an OutputStream on top of a DatagramPacket.
DatagramSocketProivder defines an interface for creating datagram and multicast
sockets.
A property adapter for formatting formatting and parsing dates in a
locale-sensitive manner.
Enumeration that defines different ways for serialization of date/time values.
A property adapter for the <xs:dateTime> format conforming to ISO 8601
This is an imitation DataOutputStream class that logs the output in a
human-readable format for debugging purposes.
A DeltaCompressor implementation that works with decorated binary values.
DecorationOnlyDeltaCompressor is a DeltaCompressor which optimizes for
"decoration-only" updates.
The default implementation of
AggregatorFactory.The
DefaultBuilderCustomization class is the default implementation
of BuilderCustomization.DefaultCacheFactoryBuilder is the default implementation of CacheFactoryBuilder.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.
Deprecated.
CacheInfo is a placeholder for cache attributes retrieved during parsing
the corresponding cache mapping element.
The default implementation of the AccessController interface.
The default
GrpcAcceptorController implementation.The default implementation of the IdentityAsserter interface.
The default implementation of the IdentityTransformer interface, which
simply returns the Subject that is passed to it.
A DefaultKeyAssociator provides key associations on behalf of keys that
implement the
KeyAssociation interface.Default implementation of
KeyConverter for a given key class.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.
The default implementation of a
ProcessingContext.The default implementation of
ProcessorFactory.Default ProxyServiceLoadBalancer implementation.
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.
Default root resource implementation.
A
DefaultsCreationPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that
creates necessary defaults, like for <serializer>s, if they are missing
from the <defaults> element.A Serializer implementation that uses the ExternalizableHelper implementation
for serialization and deserialization of objects.
A simple implementation of the ServletContextListener interface
that calls
CacheFactory.shutdown() during servlet context shutdown.The
DefaultsProcessor is responsible for processing the <defaults> XmlElement
in a Coherence Cache Configuration file, registering each of the processed elements with
the ResourceRegistry.A default implementation of a
StatementResult.Default implementation of
VersionedPartitions,A DelegatingWriteBuffer is a WriteBuffer that writes through to an
underlying (or "containing") WriteBuffer.
A qualifier annotation used for any DELETED event.
An annotation literal for the
Deleted
annotation.An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a DeleteStatementBuilder.DeleteStatement.Implementation of the CohQL "DELETE" query.
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.
An ElementProcessor for processing <compressor> configurations.
Implements a set which is based on another set, which is assumed to be
immutable.
A qualifier annotation used for any DEPARTED event.
An annotation literal for the
Departed
annotation.A qualifier annotation used for any DEPARTING event.
An annotation literal for the
Departing
annotation.Represents a double-ended queue (dequeue) of objects.
An AddressProvider that additionally allows to retrieve a human readable
description of underlying addresses without doing a DNS lookup.
The Description annotation allows a description to be specified for a method
on an MBean, and for an MBean interface itself.
DeserializationAccelerator is an
IndexAwareExtractor implementation that
is used to create a ForwardOnlyMapIndex, which in turn is used for
deserialization optimization.A qualifier annotation used for any DESTROYED event.
An annotation literal for the
Destroyed
annotation.An implementation of a
SnapshotArchiver that uses a shared directory
to store archived snapshots.Holder for direct query configuration.
A qualifier annotation used for any DISCONNECTED event.
An annotation literal for the
Disconnected
annotation.The Disposable interface is used for life-cycle management of resources.
Deprecated.
use
Disposable insteadA qualifier annotation used for any DISPOSING event.
An annotation literal for the
Disposing
annotation.Return the set of unique values extracted from a set of entries in a Map.
A DistributedCacheService is a clustered cache service that partitions its
data across cluster members that provide backing storage.
The
DistributedScheme class builds a distributed cache.The
DistributedScheme.BackupConfig class manages configuration for the partitioned
cache backup map.A DistributionManager coordinates the distribution of partitions for a
partitioned service.
An operator representing the conditional mathematical division operation.
A helper class to expose the
Subject.doAs(javax.security.auth.Subject, java.security.PrivilegedAction<T>) call as a privileged action.A
DocumentElementPreprocessor is a DocumentPreprocessor
that is designed to operate with one or more DocumentElementPreprocessor.ElementPreprocessors.An
DocumentElementPreprocessor.ElementPreprocessor provides a mechanism to examine and optionally
mutate an XmlElement prior to it being processed by a
ElementProcessor.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.A
DocumentProcessor is responsible for processing in an XmlDocument to produce a resulting
configured resource.The
DocumentProcessor.DefaultDependencies is the default implementation of the
DocumentProcessor DocumentProcessor.Dependencies interface.Calculates an average for values of any numeric type extracted from a set
of entries in a Map.
Calculates a maximum of numeric values extracted from a set of entries in a
Map.
Calculates a minimum of numeric values extracted from a set of entries in
a Map.
Sums up numeric values extracted from a set of entries in a Map.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a DropCacheStatementBuilder.DropCacheStatement.Implementation of the CohQL "DROP CACHE" command.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a DropIndexStatementBuilder.DropIndexStatement.Implementation of the CohQL "create index" command.
An implementation of PofHandler that passes each call onto two different
PofHandler objects.
The
ElementCalculatorBuilder class builds an NamedTopic.ElementCalculator.A
ElementCalculatorProcessor is responsible for processing an element-calculator
XmlElement to produce an ElementCalculatorBuilder.An
ElementProcessor is responsible for processing XmlElement content
to return a strongly-typed value.An
ElementProcessorHelper provides a number of helper methods for ElementProcessors.A
KeyStoreLoader that loads an empty, non-password
protected KeyStore.An OPToken representing the end of a CohQL statement.
An OPToken representing the end of a token stream.
Provides a way to create entity instances with a known identity.
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.Comparator implementation used to compare map entries.
An EntryEvent captures information relating to actions performed
on
entries.The
EntryEvent types.EntryEventInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive EntryEvents.The EntryExtractor is a base abstract class for special purpose custom
ValueExtractor implementations.
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.
An EntryProcessorEvent captures information relating to the execution of
InvocableMap.EntryProcessors.The
EntryProcessorEvent types.EntryProcessorEventInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive EntryProcessorEvents.REST resource representing a single cache entry.
A trivial Map implementation that is based on a specified set of entries.
REST resource representing a set of cache entries.
Provider responsible for marshalling map entries.
Provide a implementation of an Iterator based on data from an Enumeration.
PofSerializer implementation that can be used to serialize all enum
values.A
EnumProcessor is responsible for processing Coherence Enum values
and return the corresponding Enum type.An abstraction that allows us to make environment variable resolution
customizable.
Default
EnvironmentVariableResolver implementation.Filter which compares the result of a method invocation with a value for
equality.
An operator implementation representing the equality operator.
A qualifier annotation used for any ERROR event.
An annotation literal for the
Error
annotation.Error helper methods.
An
Event object captures the necessary information required to
adequately describe some activity that has occurred.An event dispatched by a
PartitionedCacheDispatcher.A PartitionedServiceEvent captures information concerning an operation on
a PartitionedService.
An
Event captures the information that may trigger a Transition
in a FiniteStateMachine from one state to another.An InterceptorRegistrationEvent allows
EventInterceptors to observe
other EventInterceptors being added or removed from an EventDispatcher
instance.The InterceptorRegistrationEvent types.
EventDispatcherAwareInterceptor is an
EventInterceptor implementation
that takes responsibility for registering itself with the EventDispatcher.An EventDispatcherRegistry manages the registration of
EventDispatchers.Helper class providing various functionality related to event handling.
An EventInterceptor provides an implementation that is capable of
intercepting and processing
Events.Manages registration of CDI observers with
InterceptorRegistry
upon ConfigurableCacheFactory activation, and their subsequent
un-registration on deactivation.Handler for
CacheLifecycleEvents.Handler for
CoherenceLifecycleEvents.Handler for
EntryEvents.Handler for
EntryProcessorEvents.Abstract base class for all observer-based interceptors.
An observer of a specific event type.
Handler for
LifecycleEvents.Abstract base class for all observer-based service interceptors.
Handler for
SessionLifecycleEvents.Handler for
TransactionEvents.Handler for
TransactionEvents.Handler for
UnsolicitedCommitEvents.Meta annotation that must be applied to all event interceptor annotations,
in order to make them discoverable.
The
EvictionPolicyBuilder builds a ConfigurableCacheMap.EvictionPolicy.A
EvictionPolicyProcessor is responsible for processing an
eviction-policy XmlElement to produce an EvictionPolicyBuilder.The Evolvable interface is implemented by classes that require forwards-
and backwards-compatibility of their serialized form.
Storage for evolvable classes.
Defines an interface that should be implemented by the classes that want to
support evolution.
Extension of the
PortableObject interface that supports forwards- and
backwards-compatibility of POF data streams.Class for providing exception support.
A qualifier annotation used for any EXECUTED event.
An annotation literal for the
Executed
annotation.A qualifier annotation used for any EXECUTING event.
An annotation literal for the
Executing
annotation.Instances of this context are passed to
Statements to allow
commands to discern execution conditions, altering their behavior / result
as needed.Provides contextual information about a
FiniteStateMachine,
typically to aid in runtime decision making for actions
(eg: TransitionActions, StateEntryActions and/or
StateExitActions) and Events.ExecutorMBean provides a monitor interface for the
Executor statistics.An
ElementProcessor that will parse and produce a
Executor based on an ssl/executor configuration element.A
Expression represents a calculation to be evaluated at runtime, during which, one or more
Parameters may be required.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.A class that builds the QueryPlus "EXTENDED LANGUAGE" command.
An
ExtendPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that will
inject an "acceptor-config" XmlElement into a "proxy-scheme"
XmlElement if one does not exist.ExtensibleConfigurableCacheFactory provides a facility to access caches
declared in a "coherence-cache-config.xsd" compliant configuration file.
The
ExtensibleConfigurableCacheFactory.DefaultDependencies is a simple implementation of
the ExtensibleConfigurableCacheFactory ExtensibleConfigurableCacheFactory.Dependencies
interface.The
ExtensibleConfigurableCacheFactory.DependenciesHelper provides helper method for constructing
ExtensibleConfigurableCacheFactory.Dependencies implementations for ExtensibleConfigurableCacheFactorys.The Manager class uses builders to create the required backing maps
and provides client access to those maps.
The PartitionedBackingMapManager is used by PartitionAwareBackingMap(s) to
lazily configure the enclosing PABM based on the configuration settings of
the enclosed maps.
Helpers for the Serializable, Externalizable and the ExternalizableLite
interface.
DecoratedMultiBufferReadBuffer is a MultiBufferWriteBuffer that
represents a binary "decorated" value, and allows a more
optimized
ExternalizableHelper.getUndecorated(ReadBuffer) operation.Default ObjectStreamFactory implementation.
A DeltaCompressor wrapper implementation that removes/replaces the
serialization format byte (FMT_EXT) before/after delegating to the
underlying compressor.
Integer decorated object.
Marker interface.
An OutputStream that implements DataOutput that delegates all
operations other than flush and close to an underlying object that
implements DataOutput.
An InputStream that delegates all operations other than close to an
underlying InputStream.
An OutputStream that implements ObjectOutput that delegates all
operations other than flush and close to an underlying object that
implements ObjectOutput.
An OutputStream that delegates all operations other than flush and
close to an underlying OutputStream.
An implementation XmlBeanClassCache that uses a pre-defined list of
XmlBean implementations.
Serialization statistics for a given user type.
An interface for caching class reference by integer ID values.
Optimized serialization.
PofSerializer implementation that supports the serialization and
deserialization of any class that implements ExternalizableLite to
and from a POF stream.The ExternalizableLiteSerializer interface provides the capability of reading and writing a
Java object from and to a DataInput/DataOutput stream.
PofSerializer implementation that supports the serialization and
deserialization of any class that implements Externalizable to
and from a POF stream.Class-level annotation specifying
serializer
for this type.The
ExternalScheme class is responsible for building
a fully configured instance of a ExternalCache.Specifies that an annotation type is a
ValueExtractor
binding type.ExtractorBuilders provide a mechanism to construct a
ValueExtractor
for a provided cache name, target and property chain (ExtractorBuilder.realize(String, int, String)).Comparator implementation that uses specified
ValueExtractor to extract value(s) to be used for comparison.ExtractorEventTransformer is a special purpose
MapEventTransformer
implementation that transforms emitted events, extracting one or more
properties from either the OldValue or the NewValue.A factory that produces instances of
ValueExtractor
for a given Annotation.Base Filter implementation for doing extractor-based processing.
ExtractorProcessor is an EntryProcessor implementations that extracts a
value from an object cached in an InvocableMap.
A CDI bean that produces
ValueExtractor instances using ExtractorFactory beans annotated with ExtractorBinding
annotations.A {
ExtractorFactory that produces MultiExtractor containing ValueExtractor instances produced from the annotations contained in a
ChainedExtractor.Extractors annotation.A {
ExtractorFactory that produces chained ValueExtractor instances for an array of property or method names.A {
ExtractorFactory that produces MultiExtractor containing ValueExtractor instances produced from the annotations contained in a
PofExtractor.Extractors annotation.A {
ExtractorFactory that producesValueExtractor
instances for a given POF index or property path.A {
ExtractorFactory that produces MultiExtractor containing ValueExtractor instances produced from the annotations contained in a
PropertyExtractor.Extractors annotation.A {
ExtractorFactory that producesValueExtractor
instances for a given property or method name.Simple Extractor DSL.
The Factory interface provides a means of producing objects of a given
type.
This class builds an AddressProviderBuilder from a AddressProviderFactory.
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.
EntryEventInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive FederatedChangeEvents.EntryEventInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive FederatedConnectionEvents.EntryEventInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive FederatedPartitionEvents.Federation event handlers that allow CDI observers to handle any federation
event.
A Collection of helper methods for files.
Provide for "pluggable" conditional behavior.
Specifies that an annotation type is a
Filter
binding type.FilterBuilder is a visitor class that converts a given Abstract Syntax
Tree into a Filter.
FilterBuildingException is the RuntimeException thrown by the
QueryHelper when building a Filter.Provide a generic implementation of an enumerator which can enumerate
items based on an inclusion test.
A factory that produces instances of
Filter for a
given Annotation.A CDI bean that produces
Filter instances using
FilterFactory beans annotated with FilterBinding
annotations.A
FilterFactory that produces AlwaysFilter
instances.A
FilterFactory that produces Filter
instances from a CohQL where clause.Simple Filter DSL.
A generic Filter-based MapTrigger implementation.
A
FiniteStateMachine implements a general purpose finite-state-machine.A FiniteStateMachineListener listens for state related events on a
FiniteStateMachine.A fixed implementation of a
NamedTopic.ElementCalculator that gives all elements a size of 1.The
FlashJournalScheme is used to create an instance of a
Flash Journal map.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).
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a ForceRecoveryStatementBuilder.ForceRecoveryStatement.Implementation of the CohQL "FORCE RECOVERY" command.
An implementation of a
StatementResult which assumes the result is
a Map with value being a Object or Object[].Class for providing formatting functionality for various types.
ForwardOnlyMapIndex is a
MapIndex implementation that unlike the
SimpleMapIndex maintains only a forward index and not the inverse index.An object that represents a fragment of another object.
A
ValueExtractor that is used to extract a Fragment from
an object.This class contains a number of
ParameterizedBuilder
implementations for the standard built-in CohQL functions.A thin extension of
Gate.An
ElementProcessor that will parse a <global-socket-provider> and
produce the global SocketProviderBuilder.Filter which compares the result of a method invocation with a value for
"Greater or Equal" condition.
A class representing the conditional greater than or equal to operator.
Filter which compares the result of a method invocation with a value for
"Greater" condition.
A class representing the greater than operator.
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.
Deprecated.
As of Coherence 12.2.1.
A holder for gRPC connection metrics.
A MBean to track gRPC connections.
A
ServerInterceptor that enables capturing of gRPC metrics.The gRPC Proxy metrics MBean implementation.
The gRPC Proxy metrics MBean.
An interface implemented by gRPC proxy services.
A class that can configure gRPC server builders prior to them being used to start the servers.
A controller class that starts and stops the default gRPC server
by responding to
DefaultCacheServer
lifecycle events.A listener that will start the gRPC server base on
Coherence or
DefaultCacheServer lifecycle events.The dependencies for a gRPC bindable service.
The default
GrpcServiceDependencies implementation.A Guardable is a logical execution unit whose lifetime may be guarded by a
Guardian.
A Guardian is responsible for monitoring the registered
Guardable
objects.A GuardContext represents the lifecycle status of a Guardable.
A concrete implementation of Guardian/Guardable interactions.
Static helper methods to encode and decode the attributes related to the
storage of a persistent form of a partition.
Resolver used during a recovery to discover the newest available GUID
for a given partition.
HashEncoded interface represents an ability to retrieve an encoded hash
value; most commonly used to calculate a partition id.
A Hasher provides an external means for producing hash codes and comparing
objects for equality.
This abstract class contains helper functions for
calculating hash code values for any group of
java intrinsics.
This abstract class contains helper functions for
calculating hash code values for any group of
java intrinsics.
A class that can return its health status
A simple executable class that will perform a health check query
against a specific URL.
Helper methods for the Coherence JCache implementation.
A
StatementBuilder that builds the QueryPlus "HELP" command.A Holder is a reference like object, i.e. it simply holds another object.
An
ElementProcessor to produce a HttpAcceptorDependencies
from a <http-acceptor%gt; configuration.An interface for access to a key of a value object
IdentifierBaseToken is a token that represents an identifier
IdentifierOPToken is used to implement identifiers.
IdentityAsserter validates a token in order to establish a user's identity.
Trivial ValueExtractor implementation that does not actually extract
anything from the passed value, but returns the value itself.
IdentityHasher provides a Hasher implementation based upon an object's
identity hashCode and reference
equality.A Holder implementation which additionally provides an equals/hashCode implementation based on the held
object's identity.
IdentityTransformer transforms a Subject to a token that asserts identity.
A class representing the case-insensitive "ilike" operator.
Implementation of the Collection Framework interface "List" in a read-
only fashion on top of an array data structure.
Implementation of the List interface in a read-only fashion based on a
collection of arrays.
An IndentingWriter is used to indent line-based output to an underlying
Writer.
IndexAwareExtractor is an extension to the
ValueExtractor interface
that supports the creation and destruction of an index.IndexAwareFilter is an extension to the EntryFilter interface that allows
a filter to use a Map index to fully or partially evaluate itself.
An annotation that should be applied to accessor methods for the
properties that need to be indexed.
Helper class that encapsulates common InetAddress functionality.
The RoutableFilter evaluates to true for any InetAddress which is
externally routable.
SubnetMaskFilter evaluates to true for any address with matches the
pattern for the masked bits
InetAddressRangeFilterBuilder defers evaluating configuration parameters
until Filter is instantiated.
POF serializer for
java.net.InetAddress.POF serializer for
java.net.InetSocketAddress.Filter which checks whether the result of a method invocation belongs to a
predefined set of values.
InfixOPToken is used to implement infix operators.
InfixRightOPToken is used to implement infix operators that like to bind
to the right which is typical of exponentiation rules.
A Collection implementation which optimizes memory consumption for
collections that often contain just a single value.
A marker interface which is used to identify internally inflated
Collections.
A List specialization of InflatableCollection.
A Set specialization of InflatableCollection.
An
ElementProcessor that will parse an <initator-config> and
produce an InitiatorDependencies.An
Expression implementation that represents the use of
a {cache-ref} macro in a Configuration File.An
Expression implementation that represents the use of
a {collection-ref} macro in a Configuration File.An
Expression implementation that represents the use of
a {cache-ref} macro in a Cache Configuration File.An
Expression implementation that represents the use of
a {resource} macro in a configuration File.An
Expression implementation that represents the use of
a {scheme-ref} macro in a Cache Configuration File.An
InitParamsProcessor is responsible for processing <init-params> XmlElements to produce
ResolvableParameterLists.Denotes that a Java Bean setter method may be injected with a value.
A binder for REST API dependencies.
Filter that limits the underlying filter evaluation only to the specified
set of keys.
A class representing the "in"operator.
This is the interface represented by the Java InputStream class.
A base class for
PasswordProvider implementations that read the
contents of an InputStream to obtain a password.A qualifier annotation used for any INSERTED event.
An annotation literal for the
Inserted
annotation.A qualifier annotation used for any INSERTING event.
An annotation literal for the
Inserting
annotation.An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a InsertStatementBuilder.InsertStatement.Implementation of the CohQL "INSERT" command.
An
InstanceBuilder is a ParameterizedBuilder implementation that additionally supports injection
based on Coherence <instance%gt; or <class-scheme> configurations.An
InstanceProcessor is responsible for processing <instance> XmlElements
to produce ParameterizedBuilders.A marker interface for
Instructions to FiniteStateMachines.Interceptor is an annotation that can be applied to
EventInterceptor implementations.This enum provides an indication of whether the
EventInterceptor should request to be
first in the chain of
EventInterceptors, hence have a HIGH
priority.Supports custom resolution of interceptor class in cases when the
interceptor may be proxied, such as when using CDI.
A
ElementProcessor for the <interceptor> element.An InterceptorRegistry manages the registration of
EventInterceptors
and facilitates the introduction of EventInterceptors to EventDispatchers.A
ElementProcessor for the <interceptors> element.A
InternalCacheSchemeProcessor is responsible for processing an
internal-cache-scheme XmlElements to produce a MapBuilder.Converts values of a specified type to and from an internal representation.
InvalidConfigServiceLoadBalancerBuilder defers reporting
configuration exception until realized.InverseComparator is a wrapper comparator which simply inverses the comparison result.
Comparator that reverses the result of another comparator.
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.
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.
An InvocableMap is a Map against which both entry-targeted processing and
aggregating operations can be invoked.
An InvocableMap.Entry contains additional information and exposes
additional operations that the basic Map.Entry does not.
An EntryAggregator represents processing that can be directed to occur
against some subset of the entries in an InvocableMap, resulting in a
aggregated result.
An invocable agent that operates against the Entry objects within a Map.
Deprecated.
This interface was deprecated in Coherence 12.2.1 and might be
removed in a future release.
Deprecated.
This interface was deprecated in Coherence 12.2.1 and might be
removed in a future release.
A StreamingAggregator is an extension of
InvocableMap.EntryAggregator that
processes entries in a streaming fashion and provides better control
over execution characteristics.Helper methods for InvocableMap implementations and Filter related
evaluation.
MapListener implementation that routes the map events into the
corresponding MapIndex calls.
BinaryEntry wrapper that routes the getValue()/getBinaryValue()
calls onto getOriginalValue()/getOriginalBinaryValue().
MapTrigger.Entry wrapper that routes the getValue() call onto
getOriginalValue().
Simple implementation of the InvocableMap.Entry interface.
The InvocationObserver is an object that asynchronously receives
notification of results from the execution of Invocable objects.
The
InvocationScheme class builds an Invocation service.The InvocationService is a Service for delivering executable objects to
cluster members for distributed invocation.
An
ElementProcessor that will parse invocation-service-proxy configuration
element tp produce a DefaultInvocationServiceProxyDependencies object.Filter which tests the result of a method invocation for inequality to null.
Filter which compares the result of a method invocation with null.
An IterableAdapter is the base class for any data type that must be
iterated over to serialize/deserialize, such as arrays, collections
and maps.
A JCache CacheLoader that can iterate its underlying contents.
Provide a implementation of an enumerator based on data from an Iterator.
JAAS-based implementation of
IdentityAsserter.Jackson-based marshaller that marshals object to/from JSON.
Provider responsible for converting Java object to/from JSON/XML.
JAXB-based marshaller that marshals object to/from XML.
Coherence JCache Context on each storage member node for JCache Cache.
Represents the JCache metadata for a key and value pair stored in a
Cache.A
NamespaceHandler to enable and enhance Coherence-based
configurations to be used with the Coherence-based JCache Extend implementationAn internal class to represent the unique identity of a JCache cache.
A
NamespaceHandler to enable and enhance Coherence-based
configurations to be used with the Coherence-based JCache implementationInterface for JCache Statistics.
An implementation of a Coherence
MBeanServerFinder
that creates a JMXConnectorServer server that uses
JMXMP as its transport rather than RMI.Provider responsible for converting Java collections to a JSON formatted
stream.
Deprecated.
As of 12.2.1.0.0, replaced by
JacksonJsonMarshallerA 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.POF serializer for JsonMap.
Filter which limits the scope of another filter according to the key
association information.
A KeyAssociation represents a key object that has a natural association
with another key object.
A KeyAssociator provides key associations on behalf of a set of keys.
An interface that must be implemented by key converters.
Marshaller that marshalls objects using a cache's key converter.
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.
EntryFilter which checks whether an entry key belongs to a set.
A KeyPartitioningStrategy is a pluggable strategy for assigning keys
to specific partitions.
PartitionAwareKey is a well-known interface that should be respected by
KeyPartitioningStrategy implementations.A class that can create a
KeyStore.An
ElementProcessor that will parse and produce a
DefaultKeystoreDependencies based on a key-store configuration element.KeyValueArrayMap is a Map implementation backed by an array of keys, and an
array of the associated values.
KeywordOPToken acts like a PunctuationOPToken when used in a led role
and a Identifier when used as a nud.
Factory methods for various distributed countdown latch implementations.
LeafBaseToken is the abstract base class for all tokes processed by the
low level BaseTokenScanner that are considered leaves.
An
ElementProcessor for Coherence <lease-granularity>
configurationFilter which compares the result of a method invocation with a value for
"Less or Equals" condition.
A class representing the logical less than or equal to operator.
Filter which compares the result of a method invocation with a value for
"Less" condition.
A class representing the logical less than or equal to operator.
A
LifecycleAwareEvent is a specialized Event that
receives callbacks during the processing of the Event by
a FiniteStateMachine.A LifecycleEvent encapsulates a lifecycle action that has
occurred on a
ConfigurableCacheFactory.The
LifecycleEvent types.LifecycleEventInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive LifecycleEvents.Filter which compares the result of a method invocation with a value for
pattern match.
A class representing the "like" operator.
LikeOPToken is used to parse a SQL like statement.
Filter which truncates the results of another filter.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a ListArchiverStatementBuilder.ListArchiverStatement.Implementation of the CohQL "LIST ARCHIVER" command.
This class builds an AddressProviderBuilder from a list of address and port.
Provide a simple, efficient, and thread-safe implementation of a list
of event listeners.
As of Coherence 3.2, the ListMap simply extends Java's own LinkedHashMap,
which became available in JDK 1.4.
ListOPToken is used to process expressions between bracketing characters
such as are between "[" and "]" which should result in a list (e.g
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a ListServicesStatementBuilder.ListServicesStatement.Implementation of the CohQL "LIST SERVICES" command.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a ListSnapshotsStatementBuilder.ListSnapshotsStatement.Implementation of the CohQL "LIST SNAPSHOTS" command.
A qualifier annotation that can be applied to
MapListener CDI
observers to register them as lite listeners.An annotation literal for the
Lite
annotation.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 is the BaseToken that represents literals such as String,
Integer, Long, Float, and Double.
A
LiteralExpression is a literal (aka: constant) Expression.LiteralOpToken is used to implement literals.
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.
A non-sticky HTTP load-balancer.
An AddressPort is an immutable combination of an IP address and a port
number.
A Queue is used to effeciently queue up items for daemon threads to
work on.
A SocketHandler is an abstract daemon thread.
An
ElementProcessor that parses a <local-address> to produce
an InetSocketAddress.This class builds an AddressProviderBuilder from a local address.
Local implementation of
AtomicBoolean
interface, that simply wraps java.util.concurrent.atomic.AtomicBoolean instance.Local implementation of
AtomicInteger
interface, that simply wraps java.util.concurrent.atomic.AtomicInteger instance.Local implementation of
AtomicLong
interface, that simply wraps java.util.concurrent.atomic.AtomicLong instance.Local implementation of
AtomicMarkableReference interface, that simply wraps java.util.concurrent.atomic.AtomicMarkableReference
instance.Local implementation of
AtomicReference
interface, that simply wraps java.util.concurrent.atomic.AtomicReference instance.Local implementation of
AtomicStampedReference
interface, that simply wraps java.util.concurrent.atomic.AtomicStampedReference instance.An in-process local cache implementation of a
Cache based
on a Coherence <local-cache>.A LocalCache implementation that supports the JCache API, CacheLoader and
CacheStore objects.
JCache Entry iterator
The InternalEvictionPolicy represents a pluggable eviction policy for
the non-pluggable built-in (internal) eviction policies supported by
this cache implementation.
The InternalUnitCalculator represents a pluggable UnitCalculator for
the non-pluggable built-in (internal) UnitCalculator implementation
provided by this cache implementation.
MapListener for Coherence-based JCache adapter implementation to generate JCache
CoherenceCacheEntryEvent.Server side filter to filter out both coherence and jcache synthetic events.
A
Configuration for a
Cache based on a Coherence <local-scheme>,
or more specifically an in-process NamedCache.Synchronous version of LocalCacheAsynchronousMapListener.
Represents the internal Cache Entry Value with in an
LocalCache.Synthetic Update
Local implementation of
CountDownLatch
interface, that simply wraps java.util.concurrent.CountDownLatch instance.This class is for local (non-clustered) permissions.
The
LocalScheme class is responsible for building a fully
configured instance of a LocalCache.Local implementation of
Semaphore
interface, that simply wraps java.util.concurrent.Semaphore instance.The Lockable interface is used for managing exclusive access to thread-safe
classes.
The Unlockable interface is used for releasing the exclusive access to
this Lockable.
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.
Factory methods for various local and remote lock implementations.
Logging API.
An implementation of PofHandler that logs all of the stream contents for
debugging / testing purposes.
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.
An Iterator that adds a "current element" concept, similar to the
Map.Entry interface.Calculates a maximum of numeric values extracted from a set of entries in a
Map.
Calculates a minimum of numeric values extracted from a set of entries in a
Map.
Sums up numeric values extracted from a set of entries in a Map.
A qualifier annotation used for any LOST event.
An annotation literal for the
Lost
annotation.A MapAdapter supports properties whose types implement the java.util.Map
interface.
The
MapBuilder interface is used by a builder to create an instance
of a Map that is a local to a Java process.A CacheStore that sits directly on top of a Map.
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.
Filter which evaluates the content of a MapEvent object according to the
specified criteria.
MapListener implementation that converts Coherence MapEvents
into Jersey Server Sent Events (SSE).MapEventTransformer interface is used to allow an event consumer to change
the content of a
MapEvent destined for the corresponding
MapListener.Specifies that an annotation type is a
MapEventTransformer
binding type.A factory that produces instances of
MapEventTransformer
for a given Annotation.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.A CDI bean that produces
MapEventTransformer instances
using MapEventTransformerFactory beans annotated with
MapEventTransformerBinding annotations.MapIndex is used to correlate values stored in an indexed Map (or
attributes of those values) to the corresponding keys in the indexed Map.
A class that can serialize and deserialize
Maps
to and from json.The listener interface for receiving MapEvents.
A
MapListenerProcessor is responsible for processing a listener
XmlElements to produce a ParameterizedBuilder for a
MapListener.A class to encapsulate bidirectional streaming of map events for a single cache.
NamedCacheDeactivationListener that will communicate cache truncation
and destruction events over the proxy.A holder for filter information.
Converter for cache key instances.
MapListenerSupport.PrimingListener that delegates calls to the wrapped MapListener.This class provides support for advanced MapListener functionality.
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.
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.
A tag interface indicating that tagged MapListener implementation
has to receive the MapEvent notifications in a synchronous manner.
A base class for various wrapper listener classes.
A wrapper class that turns the specified MapListener into
a priming listener.
A wrapper class that turns the specified MapListener into
a synchronous listener.
A qualifier annotation used to indicate a specific map name.
An annotation literal for the
MapName annotation.An exception to indicate that a required map does not exist.
Manages a ByteBuffer on a file.
An implementation of BinaryStoreManager interface that uses
BinaryMap
objects built on the MappedBufferManager to provide BinaryStore
objects.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 represents a functional agent that allows to validate, reject or
modify mutating operations against an underlying map.
A MapTrigger Entry represents a pending change to an Entry that is about
to committed to the underlying Map.
MapTriggerListener is a special purpose MapListener implementation that is
used to register a
MapTrigger on a corresponding ObservableMap.The
ViewBuilder provides a means to MapViewBuilder.build() a map view
using a fluent pattern / style.An interface that must be implemented by REST marshallers.
Registry for marshaller instances.
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).
The Remote.Function for the
MBeanServerConnection.getAttributes
method.The Remote.Function for the
MBeanServerConnection.invoke
method.The Query Builder for generating Coherence MBean queries.
A ParsedQuery represents the result of a call to
MBeanAccessor.QueryBuilder.build().The Remote.Function for the
MBeanServerConnection.setAttributes
method.Utility class to expose Coherence JMX MBeans via the Sun JMX reference
implementation HtmlAdaptorServer or a JMX Remote
JMXConnectorServer.Helper class providing various functionality related to aggregation of
attributes and methods exposed by Coherence JMX framework MBeans.
MBeanReference holds all necessary information to uniquely identify an MBean.
MBeanServerFinder represents a facility that allows a pluggable run-time
selection of an MBeanServer to be used by the Coherence JMX framework.
MBeanServerProxy allows any cluster node that runs the Management service
to obtain and set attributes or invoke methods on registered MBeans.
A convenience class for registering CacheStatisticsMBeans with an MBeanServer.
The type of registered Object
Megabytes is a specialized MemorySize whose default constructor
assumes that the specified units (when a they are not specified) are
measured in megabytes.The Member interface represents a cluster member.
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.
The MemberIdentity interface represents the identity of a cluster member.
A provider of values for a member's identity.
The listener interface for receiving MemberEvents.
An ElementProcessor to process a <member-listener> to produce a
List containing a single MemberListener.
A
MemorySizeProcessor is responsible for processing Coherence
memory sizes and returning them in bytes.An
ElementProcessor for JMS <message-delivery-mode>
configurations.An entry processor that invokes specified method on a value of a cache entry
and optionally updates the entry with a modified value.
The MetricsLabels descriptor annotation adds a
metrics.labels field
and its value to the descriptor
for a method on an MBean.The MetricsScope descriptor annotation adds a metrics.scope field and its
value to the
descriptor
for an MBean.The MetricsTag descriptor annotation adds a
metrics.tag field
and its value to the descriptor
for a method on an MBean.The MetricsValue descriptor annotation adds a metrics.value field
and its value to the
descriptor
for a method on an MBean.Millis is a specialized Duration whose default constructor
assumes that the specified units of time (when the unit magnitude is not
specified) are milliseconds.A
MillisProcessor is responsible for processing Coherence time values
and returning them in milliseconds.A PartitionAssignmentStrategy used by a service to attempt to co-locate the
primary ownership of partitions on the same members as another service.
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.An implementation of
MetricsRegistryAdapter registers Coherence
metrics with Helidon's vendor or application registry.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.
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.
A WriteBufferPool is used to dynamically allocate WriteBuffer
objects as the MultiBufferWriteBuffer requires them.
Reads binary data from a series of byte arrays.
An OutputStream that accumulates the written data to a series of byte
arrays that do not exceed a specified size.
Composite ValueExtractor implementation based on an array of extractors.
A base class that simplifies the implementation of a MapListener by
multiplexing all events into a single listener method.
A
Serializer implementation that multiplexes serialization/deserialization requests
across multiple Serializer implementations.Simple wrapper class to hold decorated info added by the serialization process.
An operator representing the mathematical multiplication operation.
A Long like class which supports mutation.
A qualifier annotation used when injecting Coherence resource to indicate a
specific resource name.
An annotation literal for the
Name annotation.A Map-based data-structure that manages entries across one or more processes.
A
NamedCacheBuilder realizes NamedCaches.A NamedCache service.
The default
NamedCacheService.Dependencies implementation.The dependencies to configure a
NamedCacheServiceImpl.A plain gRPC implementation of NamedCache service.
A gRPC NamedCache service.
NamedCollection defines a common base interface for various named collection types.
The Option interface defines the root interface of all NamedCollection Options.
A
NamedCollectionBuilder realizes NamedCollections.A wrapper for
EventInterceptors allowing additional metadata to be
associated with the interceptor without augmenting the interceptor contract.An NamedEventInterceptorBuilder facilitates the construction of a
NamedEventInterceptor, which wraps an EventInterceptor.A Map-based data-structure that manages entries across one or more processes.
An immutable option for requesting and configuring
NamedMaps.Holder for configured named query data.
REST resource representing a set of filtered cache entries.
A factory that produces
Serializer instances for a given name.NamedTopic represents a topic entity for publish/subscribe messaging.
A unit calculator is an object that can calculate the cost of
storing an element in a topic.
The
TopicScheme class is responsible for building a fully
configured instance of a NamedTopic.A NameService is a service that accepts connections from external clients
(e.g.
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.An object which implements
NameService.RequestContext stores information about the NameService request.During the
lookup call, if the retrieved
object is NameService.Resolvable, then the result of the resolve
call is returned.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 provides an Associator implementation for objects that
implement the
Associated interface.A Cloner that clones
Cloneable objects.NaturalComparator is a comparator which simply delegates to a Comparable object's compare implementation.
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.
The
NearScheme is used to realize (create) an instance of a NearCache.NestedBaseTokens is a token that holds a sequence of tokens as well as the
two bracketing characters.
NestingOPToken is an abstract classused to implement parsing situation
where some nesting is implied.
Filter which always evaluates to false.
The NioFileManagerBuilder class builds an instance of a MappedStoreManager.
NodeTerm is the class used to represent trees of Terms that can have
children.
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 provides a means to integrate Coherence with an underlying
data source that offers a non-blocking API.
An
NonBlockingFiniteStateMachine is a specialized FiniteStateMachine implementation that performs transitions
asynchronously to the threads that request state changes.A
NonBlockingFiniteStateMachine.CoalescedEvent is a LifecycleAwareEvent that
coalesces other (wrapped) Events with the same discriminator
so that only one Event actually executes.A
NonBlockingFiniteStateMachine.CoalescedEvent.Discriminator is an object that is used to uniquely
differentiate events to be coalesced, scoped by a NonBlockingFiniteStateMachine.The
NonBlockingFiniteStateMachine.CoalescedEvent to process.Implementation of Dependencies for Task
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.A specialized
Instruction for NonBlockingFiniteStateMachines
that enables a StateEntryAction to request an Event to
be processed at some point in the future.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.Dependencies for Task.
NonBlockingInvocable is an
Invocable that can be executed asynchronously.TCP based non-blocking datagram socket implementation.
A specialization of
TcpDatagramSocket.Impl which provides
non-blocking functionality, see NonBlockingTcpDatagramSocket.Impl.send(DatagramPacket).Server side filter to filter out both coherence and jcache synthetic events.
An
ElementProcessor that does nothing.Filter which compares the result of a method invocation with a value for
inequality.
A class representing the not equals operator.
Filter which negates the results of another filter.
The Notification annotation provides a means for an MBean interface to
describe the notification it emits.
A NotificationManager is responsible for JMX notification delivery from a
managed node to a set of subscribing managing nodes.
A Condition-like object, used to block thread(s) for a notification.
NotOPToken is used to implement not operators.
Filter which discards null references.
A collection of classes that do nothing.
An implementation of an ActionPolicy that allows all actions.
Null implementation of
AddressProvider.An implementation of BackingMapManagerContext that does nothing.
An implementation of an CacheStore that does nothing.
A
Collector implementation that does nothing.A Continuation that does nothing.
A Converter that does nothing.
An implementation of a DeltaCompressor that does nothing and always
returns the new stream.
An implementation of an EntryProcessor that does nothing and returns
Boolean.TRUE as a result of execution.
An empty enumerator.
An immutable empty
LongArrayA Map that contains nothing and does nothing.
An implementation of a
MemberIdentityProvider that
returns null for all its methods.An immutable ObservableMap which contains nothing.
An OutputStream that does basically nothing.
An implementation of
PartitionAssignmentStrategy that does nothing.A
PersistenceEnvironment that does nothing.A
PersistenceManager that does nothing.A
PersistentStore that does as little as possible.An implementation of PofContext that does nothing.
An implementation of PofHandler that does nothing.
A reader that does basically nothing.
A
ResourceRegistry implementation that does nothing.An immutable set which contains nothing.
A ValueExtractor that always results in the passed-in value.
A writer that does basically nothing.
The NumberIncrementor entry processor is used to increment a property value
of a
Number type.ProcessorFactory that can be used to create a
NumberIncrementor.The NumberMultiplier entry processor is used to multiply a property value
of a
Number type.ProcessorFactory that can be used to create a
NumberMultiplier.Filter used to prevent registering MBeans that match the specified pattern.
Class for providing comparison functionality.
Provides the means to create ObjectInput and ObjectOutput streams based on
primitive data streams in a layered, pluggable fashion.
Provider responsible for marshalling Java objects.
An
ObservableCachingScheme is a CachingScheme that supports
defining and adding MapListeners to realized Maps and
NamedCaches.An ObservableMap implementation that extends the SafeHashMap.
ObservableMap interface represents an object with a model being
a Map that allows for pluggable notifications for occurring changes.
The ObservableSplittingBackingCache is an implementation of the
ConfigurableCacheMap interface that works as an observable backing map
in a partitioned system.
A subclass of PartitionSplittingBackingMap which allows an injected instance
of
ObservableSplittingBackingMap to be called immediately before
inserting a value(s) in a partition map.An observable, cache-aware PartitionAwareBackingMap implementation.
An implementation of
Map that is optimized for memory
footprint.An implementation of
Set that is optimized for memory
footprint.A set of utility method for dealing with OpenMBean APIs
because they stupidly have constructors that throw exceptions.
The
OperationalConfigNamespaceHandler is responsible for capturing and
creating the Coherence operational configuration when processing a Coherence
operational configuration file.Implementations of
OperationalConfigNamespaceHandler.Extension are able to modify the OperationalConfigNamespaceHandler
before it is used.OperationalContext is an interface for providing Oracle Coherence
operational configuration.
A
OperationalDefaultsPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that introduces
(via cloning) default xml content for xml elements where the said content is missing.A
OperationBundlingProcessor is responsible for processing an
operation-bundling XmlElement to produce an BundleManager.OperatorBaseToken is a token that represents a known operator.
OPExpression is the RuntimeException thrown by the OPParser and OPScanner
when problems are detected.
OPParser is the parser class for the Top Down Operator Presidence Parsing
framework.
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.
The
OptimisticScheme class builds an optimistic cache.POF serializer for
java.util.OptionalDouble.POF serializer for
java.util.OptionalInt.POF serializer for
java.util.OptionalLong.POF serializer for
java.util.Optional.OPToken is the root class for the Top Down Operator Precedence Parsing
framework's tokens.
Filter which returns the logical "or" of two other filters.
A class representing the logical OR operator.
This is the interface represented by the Java OutputStream class.
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).
The ExpirableStatus adds expiry to the base Status object.
A CacheEvent that carries a recent value (to avoid it being lost during
eviction).
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.
A
OverrideProcessor is responsible for processing override config
elements and merging the elements with the Document root elements.Ownership is a light-weight data structure that contains a partition
ownership information.
This is an imitation DataInputStream class that reads from streams that
were produced by a corresponding
PackedDataOutputStream.This is an imitation DataOutputStream class that packs its data tighter
using variable-length integers and supports UTF longer than 64KB.
The
PagedExternalScheme class is responsible for building a
fully configured instance of a PagedExternalCache.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.
Advancer is a pluggable component that knows how to load a new page
(Collection) of objects to be used by the enclosing PagedIterator.
A helper class for cache key set and entry set paged queries.
A
PagedTopicScheme is responsible for building a topic.An
ElementProcessor that parses a <paged-topic-scheme> element;
produces a PagedTopicScheme.A
TopicService which provides globally ordered topics.A scheme that builds the inner scheme of the backing map scheme of a topic.
A
Parameter represents an optionally named and optionally explicitly typed Expression.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.Deprecated.
The
ParameterizedBuilderHelper defines helper methods for ParameterizedBuilder implementations.A registry of strongly typed and possibly named
ParameterizedBuilders.Defines a single
ParameterizedBuilder registration with a
ParameterizedBuilderRegistry.A
ParameterMacroExpression is an Expression representing the use of a Coherence Parameter Macro,
typically occurring with in a Coherence Cache Configuration file.A
ParameterMacroExpressionParser is an ExpressionParser for Coherence Parameter Macros.A
ParameterResolver provides a mechanism resolve and lookup named Parameters.A
ParamTypeProcessor is responsible for processing <param-type> XmlElements to produce a
fully qualified class name.ParenOPToken is used to process expressions that are between "(" and ")".
Base class for dynamically generated partial classes.
Class loader implementation that is used to define and load partial
classes.
A qualifier annotation used to indicate a specific participant name.
An annotation literal for the
ParticipantName annotation.A PartitionAssignmentStrategy is a pluggable strategy used by a
PartitionedService to manage partition distribution.
An ElementProcessor to process a <partition-assignment-strategy> to
produce a PartitionAssignmentStrategy.
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.
JCache of Key, Value pairs implemented over distributed cache.
JCache Entry iterator
MapListener for coherence cache to implement jcache map events.
NonSyntheticEntryFilter
Generic Coherence BinaryEntryStore for Coherence JCache Adapter.
A
Configuration for a
Cache based on a Coherence <distributed-scheme>
or more specifically a partitioned (aka: distributed)
NamedCache.MapListener for meta-information about JCache
PartitionedCache instances.A PartitionedCacheDispatcher raises the following server-side
Events pertaining to backing-map operations:
CacheLifecycleEvents
EntryEvents
EntryProcessorEvents
Defer cache configuration validation of an ActionPolicy until realized.
Synchronous version of PartitionedCacheAsynchronousMapListener.
MapListener for coherence cache to generate JCache ExpiryEvents.
Server side filter for JCache ExpiryCacheEvents.
Filter which limits the scope of another filter to those entries that have
keys that belong to the specified partition set.
An Iterator that iterates over keys in a partition-by-partition or
member-by-member manner.
compute cache statistics across all storage-enabled data members.
Get CacheStatistics from binEntry's context for JCache id.
Collect JCache CacheStatistics from all storage-enabled members.
Clear JCache CacheStatistics from all storage-enabled members.
An ElementProcessor that will parse a <partitioned-quorum-policy-scheme>
and produce a suitable
ActionPolicyA PartitionedService is aware of a mapping of keys to partitions and of
partitions to cluster members.
PartitionedAction represents a type of action taken by a
PartitionedService.
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.
A PartitionedServiceDispatcher dispatches
Events
from a PartitionedService.The PartitionEvent carries information about an event related to one or more
partitions.
The listener interface for receiving PartitionEvents.
An ElementProcessor to process a <partition-listener> to produce a
List containing a single PartitionListener.
PartitionSet is a light-weight data structure that represents a set of
partitions that are used in parallel processing.
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.
The MapArray is a data structure that provides a mapping between
partition IDs and backing maps.
PartitionStatistics encapsulates the statistics gathered for a given partition
in a PartitionedService.
A
Cache that delegates (ie: passed-through) requests directly
onto an existing Coherence NamedCache.An implementation of a
CacheEntryEvent based on an underlying
Coherence MapEvent.Captures the Coherence-based
MapListener and MapEventFilter
instances used for a CacheEntryListenerConfigurationAn alternate
ResourceConfig implementation that supports pass-through
access to all the caches defined by the cache configuration.An alternate
ResourceConfig implementation that supports pass-through
access to all the caches defined by the cache configuration.PasswordProvider allows Coherence users to plug in their own mechanism to determine the appropriate password.
An
ElementProcessor for <password-provider> elements defined by
a Coherence Operational Configuration file.This class is to wrap the existing password into the password-provider approach.
A
PasswordProvidersProcessor is responsible for processing <password-providers>
XmlElement of Coherence Operational Configuration filesThe
PasswordURLProcessor is responsible for processing the <password-url>
XmlElement in a Coherence configuration file.PathOPToken is used to implement dereferencing paths where you have
a sequence of identifiers or function calls seperated by a path separator.
A PeekOPToken is a token that contains other
OPToken
instances.PermissionInfo holds the information needed to validate and respond to a
security related request.
The identity of a acquirer, represented by the UUID of the member, and the ID
of a thread holding or attempting to acquire permit.
A qualifier annotation used when injecting Coherence resource to specify
the permits count.
An annotation literal for the
Permits annotation.Interface that exposes management attributes for a PersistenceEnvironment.
Build a
PersistenceEnvironment.A
PersistenceEnvironmentInfo
implementation that exposes the active, snapshot and trash directories,
in addition to the persistence mode.An
ElementProcessor for the <persistence-environments%gt; element of
Coherence Operational Configuration files.An
ElementProcessor for children elements
of <persistence-environments%gt; element of Coherence Operational
Configuration files.Standard MBean interface that exposes management attributes and operations
relating to a PartitionedService configured with on-demand or active persistence.
An
ElementProcessor that will parse a <persistence> element to
produce a PersistenceDependencies instance.Ping is a simple utility for testing if a machine is reachable.
A
PofAnnotationSerializer provides annotation based
de/serialization.PofArray is a
PofValue implementation for arrays.PofReader implementation that reads POF-encoded data from a
BufferInput.The UserTypeReader implementation is a contextually-aware PofReader
whose purpose is to advance through the properties of a value of a
specified user type.
PofWriter implementation that writes POF-encoded data to a
BufferOutput.A "library" of object references and their corresponding identities in
the POF stream.
The UserTypeWriter implementation is a contextually-aware PofWriter
whose purpose is to write the properties of a value of a specified user
type.
PofCollection is
PofValue implementation for collections.A provider of POF configuration URIs to load into a
ConfigurablePofContext.The constants related to POF streams.
The PofContext interface represents a set of user types that can be
serialized to and deserialized from a POF stream.
A DeltaCompressor implementation that works with Portable Object Format
(POF) values.
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.
A
ExtractorBinding annotation representing a PofExtractor.POF-based ValueExtractor implementation.
A holder for the repeatable
PofExtractor annotation.An annotation literal for the
PofExtractor.Extractors annotation.An annotation literal for the
PofExtractor
annotation.This interface defines the handler for an event-driven approach to parsing
(or assembling) a POF stream.
Collection of helper methods for POF streams.
Map implementation backed by a List of Map.Entry objects.
Immutable Map implementation backed by a Set of Map.Entry objects.
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 indicates a failure to navigate a
PofValue
hierarchy.The PofNavigator interface represents an algorithm for navigating a PofValue
hierarchy in order to locate a contained PofValue for extraction, modification
or removal purposes.
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.
A "push" parser (event-based parser) for ripping through a POF stream and
delivering the contents as events to a PofHandler object.
Generic Principal implementation that can be used to represent the identity
of any remote entity.
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.
Collection of helper methods for POF reflection.
The PofSerializer interface provides the capability of reading and writing a
Java object from and to a POF stream.
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 is
PofValue implementation for sparse arrays.NilPofValue represents a value that does not exist in the original POF stream.
PofUniformArray is
PofValue implementation for uniform arrays.PofUniformCollection is
PofValue implementation for uniform collections.PofUniformSparseArray is
PofValue implementation for uniform sparse
arrays.POF-based ValueUpdater implementation.
PofUserType is
PofValue implementation for user types.PofValue represents the POF data structure in a POF stream, or any
sub-structure or value thereof.
Parses POF-encoded binary and returns an instance of a
PofValue
wrapper for it.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.
The Pollable interface describes a component which supports element removal.
Deprecated.
Since Coherence 14.1.2.
A
PortableException is an exception that allows information about a remote
exception or error to be serialized and deserialized to/from a POF stream.The PortableObject interface is implemented by Java classes that can self-
serialize and deserialize their state to and from a POF data stream.
PofSerializer implementation that supports the serialization and
deserialization of any class that implements PortableObject to and
from a POF stream.Deprecated.
Since Coherence 14.1.2.
A
PofSerializer implementation that serializes classes that implement
PortableObject interface (and optionally EvolvableObject
interface).An opaque representation of the position of an element within a channel of a topic.
Predicate represents a boolean test of an object.
A
java.util.function.Predicate based ExtractorFilter.PrefixOPToken is used to implement prefix operators.
PreloadRequest is a simple EntryProcessor that performs a
Entry.getValue
call.Filter which returns true for
InvocableMap.Entry
objects that currently exist in a Map.A PrimitiveArrayAdapter supports arrays of primitive types, such as
"int", "char", etc.
A PropertyAdapter supporting boolean[].
A PropertyAdapter supporting byte[].
A PropertyAdapter supporting char[].
A PropertyAdapter supporting double[].
A PropertyAdapter supporting float[].
A PropertyAdapter supporting int[].
A PropertyAdapter supporting long[].
A PropertyAdapter supporting short[].
A data structure resembling a long array indexed by long values.
Node mapping long key to Object value.
PofSerializer implementation that can serialize and deserialize a
Principal to/from a POF stream.PriorityAggregator is used to explicitly control the scheduling priority and
timeouts for execution of EntryAggregator-based methods.
A
Comparator that orders values that are annotated with
the Priority annotation.PriorityFilter is used to explicitly control the scheduling priority and
timeouts for execution of filter-based methods.
PriorityProcessor is used to explicitly control the scheduling priority and
timeouts for execution of EntryProcessor-based methods.
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.
A class that can create a
PrivateKey.A
ProcessingContext provides contextual information concerning the processing of content in an xml document.A qualifier annotation used to indicate processor class when observing
EntryProcessorEvents.An annotation literal for the
Processor
annotation.The ProcessorConfig class encapsulates information related to a
Coherence REST EntryProcessor configuration.
A factory for processors.
A registry for
ProcessorFactory instances.Simple
InvocableMap.EntryProcessor DSL.The PropertyAdapter is the base class for handling the operations that
can occur on any property.
A
ExtractorBinding annotation representing a UniversalExtractor.A holder for the repeatable
PropertyExtractor annotation.An annotation literal for the
PropertyExtractor.Extractors annotation.An annotation literal for the
PropertyExtractor annotation.PropertyManipulator is a reflection based ValueManipulator implementation
based on the JavaBean property name conventions.
PropertyProcessor is a base class for EntryProcessor implementations that
depend on a ValueManipulator.
Represents a set of named properties and allows the extraction of those
properties from a target object.
Specification for a single property.
An
ElementProcessor that will parse and produce a
ProviderBuilder based on a provider configuration element.An interface that should be implemented by the classes that are able to
create a client-side proxy for itself.
Defer cache configuration validation of a ProxyQuorumPolicy until realized.
An
ElementProcessor that will parse a <proxy-quorum-policy-scheme>
and produce a suitable ActionPolicyThe
ProxyScheme class builds a Proxy scheme.A ProxyService is a clustered service that accepts connections from
external clients (e.g.
ProxyAction represents a type of action taken by a ProxyService.
A ProxyServiceLoad encapsulates information about the current utilization
of a ProxyService.
A ProxyServiceLoadBalancer is a pluggable strategy for controlling the
client load across individual members of a clustered ProxyService.
ProxyServiceLoadBalancerBuilder defers evaluating configuration parameters
until ServiceLoadBalancer is instantiated.Publisher provides a means to publish values to the
NamedTopic.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.This option controls how a
Publisher handles a failure of an individual
Publisher.publish(V) call.A marker interface to indicate that a class is a valid
Publisher.Option
for a Publisher.Orderable represents a value published by
Publisher that has a natural
ordering.The OrderBy option specifies the ordering of async operations with respect
to one another.
Publisher.OrderBy option ensures ordering of sent values across
all threads which share the same orderId.Publisher.OrderBy option enforces no specific ordering between sent values allowing
for the greatest level of parallelism.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.OrderBy option which ensures that a sequence of sent values issued by a single
thread will complete in order.Publisher.OrderBy option which computes the unit-of-order based on applying constructor's orderIdFunction parameter on sent value.The status for a successfully published element.
PunctuationBaseToken is a token that represents a known punctuation.
PunctuationOPToken is used in situations where you need a place holder to
test for something like a ",".
A property adapter for
QName
primitive datatype.
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).Defines an interface that Query implementations must support.
Holder for query configuration.
The QueryContext provides an execution context to server-side agents during
query execution.
The QueryEngine interface provides a pluggable mechanism for producing
queries that can be executed against a NamedCache.
Holder for
QueryEngine configuration.A registry for
QueryEngine instances.Query execution specific exception.
QueryHelper is a utility class that provides a set of factory methods
used for building instances of
Filter or
ValueExtractor.Map with additional query features.
A QueryMap Entry exposes additional index-related operation that the
basic Map Entry does not.
This interface is used by Comparator implementations that can use value
extraction optimization exposed by the
QueryMap.Entry interface.QueryPlus implements a simple command line processor for a sql like
language.
A default implementation of
QueryPlus.Dependencies.The Dependencies for QueryPlus.
The DependenciesHelper provides helper method for constructing
QueryPlus.Dependencies implementations for QueryPlus.The QueryRecord object carries information regarding the estimated or actual
execution cost for a query operation.
A QueryRecord.PartialResult is a partial query record that contains
recorded costs for a query operation.
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.An IndexLookupRecord holds the recorded information about an index
lookup performed during filter evaluation as part of a query
record.
A QueryRecord.RecordableStep is a
step that provides the
ability to record the cost of evaluating a filter as part of a
query operation.A QueryRecord.Step carries the recorded cost of evaluating a filter
as part of a query operation.
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.This aggregator is used to produce a
QueryRecord object that
contains an estimated or actual cost of the query execution for a given filter.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 is an extension of EntryFilter that allows the
projected or actual costs of query execution to be recorded.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a QueryRecorderStatementBuilder.QueryRecorderStatement.Implementation of the CohQL "QueryRecorder" command.
The
RamJournalScheme is used to create an instance of a Ram Journal map.Class for providing random functionality.
An immutable POF date value.
An immutable POF date-time value.
An immutable POF day-time interval value.
An immutable POF 128-bit float.
An immutable POF time value.
An immutable POF time interval value.
An immutable POF year-month interval value.
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.
The BufferInput interface represents a DataInputStream on top of a
ReadBuffer.
A thread-safe LongArray implementation for read heavy workloads but which is also efficient with frequent and/or
bursty writes.
The
ReadLocatorBuilder class builds a BiFunction that given
the current ownership of a partition and service will return a member to target reads against.A
ReadLocatorProcessor is responsible for processing the
read-locator xml to produce a ReadLocatorBuilder.A simple extension of the WrapperNamedCache implementation that shields all
content mutating operations such as put(), remove(), lock() etc.
Class for providing read functionality.
Backing Map implementation that provides a size-limited cache of a
persistent store and supports configurable write-behind and refresh-
ahead caching.
A CacheStore wrapped around a CacheLoader.
A Map implementation used for a backup map that evicts all data that
has been successfully written.
A synchronization construct used to coordinate asynchronous loads by the
refresh-ahead thread with cache accesses by other threads.
The
RemoteCacheScheme is responsible for creating a fully
configured ReadWriteBackingMap.A PartitionAwareBackingMap extension to the ReadWriteBackingMap.
A qualifier annotation used for any RECOVERED event.
An annotation literal for the
Recovered
annotation.An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a RecoverSnapshotStatementBuilder.RecoverSnapshotStatement.Implementation of the CohQL "RECOVER SNAPSHOT" command.
Extends SafeLinkedList and adds recycling of Node objects.
The ReducerAggregator is used to implement functionality similar to
CacheMap.getAll(Collection) API.An
InternalConverter that simply returns a reference to the
provided value.Reflection-based ValueExtractor implementation.
An
ExtractorBuilder implementation that will build
instances of ReflectionExtractors.A collection of utilities to assist in using Reflection to create
objects.
Reflection-based ValueUpdater implementation.
A RefreshableAddressProvider is an AddressProvider implementation
that wraps another AddressProvider and refresh the address list of
the provider asynchronously.
A refreshable
SslContext.Implemented by classes that wish to control whether an
SSLContext
is updated when its scheduled update check runs.An extension of
CacheMapping that can use a regular expression to
match with a given cache name.Filter which uses the regular expression pattern match defined by the
String.matches(String) contract.A RegistrationBehavior is used by numerous registries for the
purpose of specifying the required behavior when registering an artifact.
The Coherence cluster management gateway is an abstraction of the basic
JMX registration APIs that is specific to managing Coherence clustered
resources.
A resource that is activated and then at a later time be released.
A qualifier annotation used when injecting Coherence resource to indicate
that a resource is remote.
Helper interfaces and methods that enable capture of standard JDK
functional interfaces as serializable lambdas.
Represents an operation that accepts two input arguments and returns no
result.
Represents a function that accepts two arguments and produces a result.
Represents an operation upon two operands of the same type, producing a
result of the same type as the operands.
Represents a predicate (boolean-valued function) of two arguments.
Represents a supplier of
boolean-valued results.A task that returns a result and may throw an exception.
A comparison function, which imposes a total ordering on some
collection of objects.
Represents an operation that accepts a single input argument and returns
no result.
Represents an operation upon two
double-valued operands and
producing a double-valued result.Represents an operation that accepts a single
double-valued
argument and returns no result.Represents a function that accepts a double-valued argument and produces
a result.
Represents a predicate (boolean-valued function) of one
double-valued argument.Represents a supplier of
double-valued results.Represents a function that accepts a double-valued argument and produces
an int-valued result.
Represents a function that accepts a double-valued argument and produces
a long-valued result.
Represents an operation on a single
double-valued operand that
produces a double-valued result.Represents a function that accepts one argument and produces a result.
Represents an operation upon two
int-valued operands and
producing an int-valued result.Represents an operation that accepts a single
int-valued argument
and returns no result.Represents a function that accepts an int-valued argument and produces a
result.
Represents a predicate (boolean-valued function) of one
int-valued argument.Represents a supplier of
int-valued results.Represents a function that accepts an int-valued argument and produces a
double-valued result.
Represents a function that accepts an int-valued argument and produces a
long-valued result.
Represents an operation on a single
int-valued operand that
produces an int-valued result.An annotation literal for the
Remote
annotation.Represents an operation upon two
long-valued operands and
producing a long-valued result.Represents an operation that accepts a single
long-valued
argument and returns no result.Represents a function that accepts a long-valued argument and produces a
result.
Represents a predicate (boolean-valued function) of one
long-valued argument.Represents a supplier of
long-valued results.Represents a function that accepts a long-valued argument and produces a
double-valued result.
Represents a function that accepts a long-valued argument and produces an
int-valued result.
Represents an operation on a single
long-valued operand that
produces a long-valued result.Represents an operation that accepts an object-valued and a
double-valued argument, and returns no result.Represents an operation that accepts an object-valued and a
int-valued argument, and returns no result.Represents an operation that accepts an object-valued and a
long-valued argument, and returns no result.Represents a predicate (boolean-valued function) of one argument.
The
Runnable interface should be implemented by any
class whose instances are intended to be executed by a thread.Represents a supplier of results.
Represents a function that produces a BigDecimal-valued result.
Represents a function that produces a Comparable-valued result.
Represents a function that accepts two arguments and produces a
double-valued result.
Represents a function that produces a double-valued result.
Represents a function that accepts two arguments and produces an
int-valued result.
Represents a function that produces an int-valued result.
Represents a function that accepts two arguments and produces a
long-valued result.
Represents a function that produces a long-valued result.
Represents an operation on a single operand that produces a result of the
same type as its operand.
The remote implementation of
AtomicBoolean,
backed by a Coherence NamedMap entry.The remote implementation of
AtomicInteger,
backed by a Coherence NamedMap entry.The remote implementation of
AtomicLong,
backed by a Coherence NamedMap entry.The remote implementation of
AtomicMarkableReference, backed by a Coherence NamedMap entry.The remote implementation of
AtomicReference,
backed by a Coherence NamedMap entry.The remote implementation of
AtomicStampedReference, backed by a Coherence NamedMap entry.A remote partitioned-cache implementation of a
Cache based
on a Coherence <partitioned-cache>.A
Configuration for a
Cache based on a Coherence <remote-scheme>,
or more specifically a NamedCache.The
RemoteCacheScheme is responsible for building a remote cache.An extension of
Collector that adds serialization support.Static factory for various
RemoteCollectors that can be executed in
parallel in a distributed environment.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.A sequence of primitive double-valued elements supporting sequential and parallel
aggregate operations.
A sequence of primitive int-valued elements supporting sequential and
parallel aggregate operations.
The
RemoteInvocationScheme class builds a remote invocation service.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.A sequence of primitive long-valued elements supporting sequential and parallel
aggregate operations.
A RemoteMember is a special
Member implementation that carries
the remote IP/port information of a member that isn't in the cluster.A serializable pipeline of intermediate stream operations.
An implementation of
ReadWriteLock supporting similar semantics to
ReentrantReadWriteLock, but with support for access synchronization
across multiple cluster members.The lock returned by method
RemoteReadWriteLock.readLock().The lock returned by method
RemoteReadWriteLock.writeLock().A distributed counting semaphore.
This interface is an extension of
java.util.stream.Stream that captures
lambdas used as method arguments as serializable lambdas.A qualifier annotation used for any REMOVED event.
An annotation literal for the
Removed
annotation.An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a RemoveSnapshotStatementBuilder.RemoveSnapshotStatement.Implementation of the CohQL "REMOVE [ARCHIVED] SNAPSHOT" command.
A qualifier annotation used for any REMOVING event.
An annotation literal for the
Removing
annotation.Provides Render capabilities for
FiniteStateMachines, in particular their Models.The
ReplicatedScheme class builds replicated cache.A qualifier annotation used for any REPLICATING event.
An annotation literal for the
Replicating
annotation.A class that holds a gRPC request and
Binary converters.Signals that a request execution in a distributed environment failed to
complete successfully.
Signals that a request was not allowed to complete due to the related service
action being disallowed by the corresponding ActionPolicy.
A factory to simplify creating proto-buffer requests.
Signals that a request execution in a distributed environment did not
complete in a pre-determined amount of time.
A
ResolvableParameterList is a ParameterList implementation that additionally supports
name-based Parameter resolution as defined by the ParameterResolver interface.Marker interface for Resolving*Stream implementations.
Provides an ObjectInputStream that uses a caller provided
ClassLoader to resolve classes during objects deserialization.
A marker implementation to mirror the ResolvingObjectInputStream
implementation.
An
ElementProcessor for <resource> elements defined by
a Coherence Operational Configuration file.The ResourceConfig class encapsulates information related to a Coherence
REST resource.
A base class for mapping elements.
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.A
ResourceRegistry is a registry and owner of strongly typed and
explicitly named resources.The
ResourceRegistry.ResourceLifecycleObserver interface defines lifecycle handlers
for resources registered with a ResourceRegistry.A
ResourceResolver provides a mechanism to lookup and resolve
optionally named, strongly typed resources.Provides helpful methods for working with
ResourceResolvers.Implement simple basis for package (and other) resources.
An
ElementProcessor for the <resources%gt; element of
Coherence Operational Configuration files.Helper methods to handle gRPC async responses.
The RestConfig class encapsulates information related to Coherence REST
configuration.
A collection of utility methods used by Coherence REST.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a RestoreStatementBuilder.RestoreStatement.Implementation of the CohQL "RESTORE" command.
A collection of Collection implementation classes that limit the data type.
A restricted Collection that requires its contents to be of a
specified class.
A restricted Collection that requires its contents to be of a
specified class.
A restricted List that requires its contents to be of a
specified class.
A restricted ListIterator that requires its contents to be of a
specified class.
A restricted Map that requires its keys and values to be of
specified classes.
A restricted Set that requires its contents to be of a
specified class.
A restricted SortedMap that requires its keys and values to be of
specified classes.
A restricted Set that requires its contents to be of a
specified class.
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).An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a ResumeServiceStatementBuilder.ResumeServiceStatement.Implementation of the CohQL "RESUME SERVICE" command.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a RetrieveSnapshotStatementBuilder.RetrieveSnapshotStatement.Implementation of the CohQL "RETRIEVE SNAPSHOT" command.
A qualifier annotation used for any ROLLBACK event.
An annotation literal for the
Rollback
annotation.A
RollbackTransitionException may be thrown during an TransitionAction
for a Transition if the said Transition should be aborted.SafeClock maintains a "safe" time in milliseconds.
Null-safe delegating comparator.
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).
An implementation of java.util.Map that is synchronized, but minimally so.
A map entry (key-value pair).
An implementation of java.util.Set that is synchronized, but minimally so.
Implementation of the Collection Framework interface "List" using a linked
list algorithm.
A Node in the List.
A thread-safe variant of
LongArray in which is protected by a ReentrantLock.SafePersistenceWrappers provides safe wrapper implementations of persistence
layer interfaces that can be used to consolidate error handling across the
various persistence layers.
FailureContinuationFactory encapsulates failure continuations to handle
unexpected exceptions thrown by implementations of the various persistence
layers.
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.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.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.Implementation of a
SortedMap extending ConcurrentSkipListMap
to support null keys and null values.Entry set delegation of the super map implementation.
Key set delegation of the super map implementation.
Map.Entry implementation that supports null key/value placeholders.
SubMap delegation to manage
SafeSortedMap.NULL in entry key and/or value.Values delegation of the super map implementation.
A
StreamObserver that handles exceptions correctly.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.A
StatementBuilder that builds
the QueryPlus "SANITY CHECK" command.A simple XML parser.
A
Scheme defines the configuration information and necessary
builders for the construction of various well-known and identifiable
structures used by Coherence at runtime.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.Key class for a scheme mapping.
A
SchemeRefPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that resolves declarations of
<scheme-ref> as required by Coherence.A
SchemesProcessor is an ElementProcessor for the
<caching-schemes%gt; element of Coherence Cache Configuration files.A qualifier annotation used when injecting Coherence resource to indicate
that those resource should be obtained from a specific
ConfigurableCacheFactory.An annotation literal for the
Scope annotation.Implementation of
CacheFactoryBuilder that manages multiple
instances of ConfigurableCacheFactory.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.A qualifier annotation used to indicate a specific scope name.
An annotation literal for the
ScopeName annotation.The
ScopeNameProcessor is responsible for processing the <scope-name> XmlElement
in a Coherence Cache Configuration file.This interface is used to derive a scope name used to create an instance
of
ConfigurableCacheFactory.ScriptAggregator is a
InvocableMap.StreamingAggregator that wraps a script written
in one of the languages supported by Graal VM.Represents an exception of some sort has occurred while loading or
executing scripts.
ScriptFilter is a
Filter that wraps a script written in one of the
languages supported by Graal VM.ScriptProcessor is an
InvocableMap.EntryProcessor that wraps a script
written in one of the languages supported by Graal VM.ScriptValueExtractor is an
AbstractExtractor that wraps a script
written in one of the languages supported by Graal VM.Seconds is a specialized Duration whose default constructor
assumes that the specified units of time (when the unit magnitude is not
specified) are seconds.The Security class is used to associate client's identity with an action
that requires access to protected clustered resources.
Maps SecurityExceptions to 403: Forbidden response.
Simple authentication filter.
A collection of security-related utilities.
Security Provider implementation that returns custom security services.
An implementation of SegmentedHashMap that also implements the ConcurrentMap
interface.
ContentionObserver is used to observe the contention lock-related actions
performed on the concurrent map.
Action support for size().
An implementation of java.util.Map that is optimized for heavy concurrent use.
Action support for containsValue().
A map entry (key-value pair).
An EntryAction encapsulates a logical action to be executed in the
context of a key (that may or may not exist in the map).
EntryActionAdapter is a convenience class that provides default
implementations for the EntryAction and IterableEntryAction interface
methods.
IterableEntryAction is an EntryAction that is suitable for applying to
all keys in a map.
Segment metadata.
An implementation of java.util.Set that is optimized for heavy concurrent
use.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a SelectStatementBuilder.SelectStatement.Async implementation of the CohQL "SELECT" command.
Implementation of the CohQL "SELECT" command.
Factory methods for local and remote semaphore implementations.
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.
A map listener that follows the "seppuku" pattern, invalidating the Map
entries when MapEvents for another related ObservableMap are delivered.
SequenceBaseToken is a token that holds a sequence of tokens.
A SerializableAdapter supports Java objects that implement the
Serializable interface.
A version of SerializationMap that implements an LRU policy.
The InternalEvictionPolicy represents a pluggable eviction policy for
the non-pluggable built-in (internal) eviction policies supported by
this cache implementation.
Map implementation that stores its contents in a BinaryStore.
A version of SerializationMap that implements an LRU policy using
time-based paging of the cache.
A lite BinaryStore implementation used when the real underlying
BinaryStore gets destroyed.
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.The Serializer interface provides the capability of reading and writing a
Java object from and to an in-memory buffer.
The SerializerAware interface provides the ability to configure a
Serializer to be used by the implementing object when serializing or
deserializing objects.
An
ElementProcessor for <serializer> elements defined by
a Coherence Operational Configuration file.A factory for
Serializer objects.An ElementProcessor that will parse a <serializer> and produce a
suitable SerializerFactory
A qualifier annotation used when injecting a
Serializer
to identify the specific Serializer to inject.An annotation literal for the
SerializerFormat annotation.A CDI producer of
Serializer instances.A builder that builds
SerializerProducer
instances.An
ElementProcessor for the <serializers%gt; element of
Coherence Operational Configuration files.An
InternalConverter that converts values to and from their
Coherence-based serialized Binary representation.This class bootstraps the CDI container, which will in turn start Coherence
server via CDI extension.
A CDI server-side
Coherence bean producer.A gRPC server interceptor that will log messages on the server.
This Service interface represents a controllable service that operates in a
clustered network environment.
A Service is a Controllable that emits service lifecycle events.
MemberJoinAction is taken to allow a new member to join a clustered
Service.
The ServiceBuilder interface is used by a builder that creates a Service.
A
ServiceBuilderProcessor is an ElementProcessor responsible for producing various kinds of
ServiceBuilders.The ServiceDependencies interface defines externally provided dependencies
for
clustered services.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 is used to control how a Guardable associated with a
service is managed by its Guardian after the configured timeout.
Build a default or customized
ServiceFailurePolicy.An ElementProcessor that will parse a <service-failure-policyr> and
produce a suitable ServiceFailurePolicy
The ServiceInfo represents information about a Service that
operates in a clustered network environment.
The listener interface for receiving ServiceEvents.
A ServiceLoad encapsulates information about the current utilization
of a Service.
A ServiceLoadBalancer is a pluggable strategy for controlling the
client load across individual members of a clustered Service.
ServiceLoadBalancerBuilder defers evaluating configuration parameters
until ServiceLoadBalancer is instantiated.An
ElementProcessor for <load-balancer> configuration used
by federated and proxy services.The
ServiceMonitor is a facility that keeps registered services
alive.A qualifier annotation used to indicate a specific service name.
An annotation literal for the
ServiceName annotation.This interface exposes service related scheme information.
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.A
StatementBuilder that builds
the QueryPlus "SERVICES" command.Signals that a request was not able to execute because the underlying service
has been stopped.
A thread-safe mechanism to request Coherence-based resources, like
NamedCaches, from a deployed module.Deprecated.
since 20.12
Session.Option has been replaced by SessionConfigurationA class that can provide the configuration options for a
Session.A builder to build a
SessionConfiguration.ConfigurableCacheFactorySessionConfig.An immutable
SessionConfiguration to configure a Session that
wraps an underlying ConfigurableCacheFactory.A CoherenceDispatcher raises
Events pertaining to
operations on a Coherence instance:
CoherenceLifecycleEvents
An interface that should be implemented by custom Coherence scoped session
configurations in order to enable their discovery and automatic initialization
at startup.
A
SessionLifecycleEvent allows subscribers
to capture events pertaining to the lifecycle of
a Session instance.The emitted event types for a
SessionLifecycleEvent.SessionLifecycleEvents is an annotation that should be applied to
EventInterceptor implementations
that want to receive SessionLifecycleEvents.A qualifier annotation used when injecting Coherence resource to indicate a
specific Session name.
An annotation literal for the
SessionName annotation.A CDI producer for
Session instances.Creates
Sessions for use by applications requiring Coherence-based
resources, including NamedCaches, often for specific
ClassLoaders, for deployed modules.A context used by providers.
Deprecated.
Implemented by suppliers of a
SessionProvider.Deprecated.
since 20.12 there is no replacement for this class
A class that builds the QueryPlus "ALTER SESSION SET TIMEOUT millis" statement.
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
A simple property adapter for BigDecimal.
A simple property adapter for BigInteger.
A simple property adapter for boolean.
A simple property adapter for byte.
A simple property adapter for char.
A simple property adapter for Date.
A simple property adapter for double.
A simple property adapter for float.
A simple property adapter for int.
A simple property adapter for long.
A simple property adapter for the Date class from the java/util package.
A simple property adapter for short.
A simple property adapter for String.
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.
A simple property adapter for Time.
A simple property adapter for Timestamp.
SimpleAssignmentStrategy is a PartitionAssignmentStrategy that attempts to
balance the partition distribution based on the number of primary and backup
partitions owned.
BackupStrength represents a level of "strength" or "resiliency" between
the primary and backup owners of a partition.
LoadCalculator is used to calculate the scalar load (expressed as an
integer) of a partition (or set of partitions).
SimpleLoadCalculator defines a "count-based" load (e.g. the load of each
partition is defined to be 1).
A
SimpleAttribute provides a basic implementation of an XmlAttribute.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.An
ElementProcessor that returns a
simple ParameterizedBuilder.Implementation of the CacheStatistics interface intended for use by a cache
to maintain its statistics.
An
Executor that uses a DaemonPool to execute tasks.A simple implementation of the XmlElement interface.
A simple implementation of the XmlElement interface.
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.Provide a generic implementation of an array enumerator.
Simple implementation of
Evolvable interface.The SimpleHandler class is a CallbackHandler implementation
based on a specified user name and password.
SimpleHolder is a basic implementation of the Holder interface.
General purpose container that can be used as an accumulator for any
reference type.
An implementation of LongArray that stores values in an array, thus is
actually an "IntArray".
A map entry (key-value pair).
Simple representation of
MapEvent that can be marshalled to JSON.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.
A stateful
calculator
used to calculate the cost of a homogeneous index (holding all values of a
single type).The CalculatorState identifies the method used by the calculator to
calculate the cost of a key or a value type.
A UnitCalculator implementation that weighs a cache entry based upon the
amount of physical memory (in bytes) required to store the entry.
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).
A combination Filter and Converter used to iterate through the
status map in order to iterate through the front keys.
A stateless Comparator that compares
Object.hashCode() values.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.
A basic implementation of a
ParameterizedBuilderRegistry.A
SimpleParameterList is a simple implementation of ParameterList.This class uses the XmlTokenizer to produce an XmlDocument from XML text.
SimplePartitionKey is a trivial
PartitionAwareKey implementation.Basic
PofContext implementation.A static
PofNavigator implementation which uses an array of integer
indices to navigate the PofValue hierarchy.SimplePofValue represents POF values which do not contain children (e.g.
Simple QueryRecord implementation.
Simple QueryRecord.PartialResult implementation.
Simple QueryRecord.PartialResult.IndexLookupRecord implementation.
Simple QueryRecord.PartialResult.Step implementation.
Simple query record reporter used to obtain a string representation of
QueryRecord object.A
SimpleResourceRegistry is a basic implementation of a ResourceRegistry.A simple implementation of a
ResourceResolver.Map implementation that stores and accesses its contents through an
underlying BinaryStore.
A simple ServiceLoadBalancer implementation.
The
SimpleServiceMonitor starts and monitors services that are
registered for monitoring.A LIFO (last in, first out) unbounded stack of objects.
Standard MBean interface that exposes management attributes and operations for
a
SimpleAssignmentStrategy used by a PartitionedService.HAStatus represents the possible values to represent the High Availability Status of the
associated PartitionedService.
Simple implementation of a
Streamer.Simple generic Validator implementation that uses hashCode values
for the enlisted resources to resolve optimistic transaction conflicts.
A simple implementation of the XmlValue interface.
An
EntryProcessor wrapper class that allows for
an asynchronous invocation of the underlying processor against a single
cache entry.Implementation of
CacheFactoryBuilder that maintains a single
ConfigurableCacheFactory instance regardless of the requesting
ClassLoader if a URI is not provided.SingleWaiterCooperativeNotifier is an extension of the SingleWaiterMultiNotifier which attempts to offload
potentially expensive "notification" work from signaling threads onto the waiting threads.
A Condition-like object, used by a single thread to block for a
notification, and optimized for many concurrent notifications by other
threads.
The Sizable interface is implemented by types that are capable of calculating
the memory footprint of an instance.
SizeEstimatingBufferOutput is a WriteBuffer.BufferOutput implementation which writes nothing, and simply maintains
an estimated byte count of how much would have been written.
A Snapshot is the abstraction of a full or partial snapshot representation
for the purposes of archiving.
An interface for archiving and restoring snapshots.
A factory for
SnapshotArchiver objects.The SocketAddressProvider is an interface that serves as a means to provide
addresses to a consumer.
SocketOptions provides a means to configure the various aspects of Sockets.
An
ElementProcessor for SocketOptions.SocketProvider defines an abstraction for creating various types of sockets.
SocketProviderBuilder enables lazy instantiation of SocketProvider.The SocketProviderFactory produces SocketProviders.
DefaultDependencies is a basic implementation of the Dependencies
interface.
Dependencies specifies all dependency requirements of the SocketProviderFactory.
Enumeration of Provider types.
An
ElementProcessor that will parse a <socket-provider> and
produce a SocketProviderBuilder.An
SocketProvidersProcessor is responsible for processing <socket-provider>
XmlElements SocketProvider definitions.SortedBag is a
multiset or bag implementation that supports sorted traversal
of the contained elements and is optimized for insertions and removals.
Sorts the contents of the passed enumerator then enumerates those contents.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a SourceStatementBuilder.SourceStatement.Implementation of the CohQL "source" command.
A data structure resembling an Object array indexed by long values.
Node mapping long key to Object value.
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 is used for parsing and specifying the AST
used for archiving snapshots.
SQLBackupOPToken is used for parsing and specifying the AST
used for backing up a cache.
SQLCreateOPToken is used for parsing and specifying the AST
used for a create cache.
SQLCreateOPToken is used for parsing and specifying the AST
used for a create index query.
SQLCreateSnapshotOPToken is used for parsing and specifying the AST
used for creating snapshots.
SQLDeleteOPToken is used for parsing and specifying the AST
used for a delete query.
SQLDropCacheOPToken is used for parsing and specifying the AST
used for drop cache
SQLDropIndexOPToken is used for parsing and specifying the AST
used for drop index.
SQLExplainOPToken is used for parsing and specifying the AST
used for an explain plan statement.
SQLForceRecoveryOPToken is used for parsing and specifying the AST
used for forcing recovery.
SQLInsertOPToken is used for parsing and specifying the AST
used for a insert statment.
SQLListArchivedSnapshotsOPToken is used for parsing and specifying the AST
used for listing archived snapshots.
SQLListArchiverOPToken is used for parsing and specifying the AST
used for showing the archiver implementation for a service.
SQLListServicesOPToken is used for parsing and specifying the AST
used for listing services and their persistence mode.
SQLConnectOPToken is used for parsing and specifying the AST
used for listing snapshots.
SQLOPToken provides useful convenience methods for subclasses.
An CohQL implementation of a
PeekOPToken.SQLRecoverSnapshotOPToken is used for parsing and specifying the AST
used for creating snapshots.
SQLRemoveSnapshotOPToken is used for parsing and specifying the AST
used for creating snapshots.
SQLRestoreOPToken is used for parsing and specifying the AST
used for restoring a cache.
SQLResumeServiceOPToken is used for parsing and specifying the AST
used for resuming services.
SQLRetrieveSnapshotOPToken is used for parsing and specifying the AST
used for retrieving snapshots.
SQLSelectOPToken is used for parsing and specifying the AST
used for a select statement.
SQLSourceOPToken is used for parsing and specifying the AST
used for sourcing (including) a file.
SQLSuspendServiceOPToken is used for parsing and specifying the AST
used for suspending services.
SQLTraceOPToken is used for parsing and specifying the AST
used for a trace statement.
SQLTruncateCacheOPToken is used for parsing and specifying the AST
used for truncate cache.
SQLUpdateOPToken is used for parsing and specifying the AST
used for an update statement.
SQLValidateSnapshotOPToken is used for parsing and specifying the AST
used for creating snapshots.
An
ElementProcessor that will parse and produce a
HostnameVerifier based on hostname-verifier configuration element.An
ElementProcessor that will parse and produce a
DefaultManagerDependencies based on a identity-manager/trust-manager configuration element.An
ElementProcessor that will parse and produce a
NameListDependencies based on a protocol-versions or cipher-suites configuration element.An
ElementProcessor that will parse an <ssl> and
produce a SSLSocketProviderDependenciesBuilder object.SSLSocketProviderDependenciesBuilder enables lazy instantiation of SSL SocketProvider.Implemented by
Provider classes that need
to be aware of the SSL dependencies.HostnameVerifier dependencies
SSL encipher-suites and protocol-versions are both a list of names with a usage attribute of the value "white-list" or "black-list"
Provider dependencies
Class for providing StackTrace functionality.
A class that provides "stack frame" information from a line of a stack
trace.
A qualifier annotation used for any STARTED event.
An annotation literal for the
Started
annotation.A qualifier annotation used for any STARTING event.
An annotation literal for the
Starting
annotation.A
StateEntryAction encapsulates the actions to be performed by
a FiniteStateMachine when a particular state is entered.A
StateExitAction encapsulates the actions to be performed by
a FiniteStateMachine when leaving a known state.Implementations of this interface are able to execute CohQL statements,
for example a Select, Update, a backup command etc.
Classes implementing this interface build instances of
Statement implementations.A class that parses and executes CohQL statements read from
an instance of a
Reader.The result of executing a CohQL
Statement.A simple representation of static content, which is used as a pass-through
storage format for content other than JSON.
A pass-through marshaller that simply converts HTTP entities into a
StaticContent and vice versa.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.A qualifier annotation used for any STOPPED event.
An annotation literal for the
Stopped
annotation.A qualifier annotation used for any STOPPING event.
An annotation literal for the
Stopping
annotation.A pluggable facility for the server side access control authorization.
An
ElementProcessor for <storage-authorizer> elements defined by
a Coherence Operational Configuration file.An
ElementProcessor for the <storage-authorizers%gt; element of
Coherence Operational Configuration files.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)).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.An
EntryProcessor wrapper class that allows for
an asynchronous invocation of the underlying processor.Marshaller that marshalls String object.
Like a hash table, but built specifically for strings.
PofSerializer implementation that can serialize and deserialize a
Subject to/from a POF stream.Implements a list which is based on another list, represents a sub-list of the underlying list.
A representation of a topic channel within subscriber.
A default empty channel implementation.
A listener that receives notification of channel ownership changes.
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.The result of a commit request.
The different result statuses for a commit request.
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.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.Element represents a container for returned values.
The Filtered option specifies a filter that will determine which topic values a
subscriber is interested in receiving.
A marker interface for
Subscriber identifiers.The Name option is used to specify a subscriber group name.
A marker interface to indicate that a class is a valid
Subscriber.Option
for a Subscriber.A qualifier annotation used when injecting
Subscriber
to a NamedTopic to indicate the name of the
subscriber group that the subscriber should belong to.An annotation literal for the
SubscriberGroup annotation.The
SubscriberGroupBuilder builds a Subscriber group.A
ElementProcessor for the <subscriber-group> element.A
ElementProcessor for the <subscriber-groups> element.Implements a set which is based on another set, which is assumed to be
immutable.
An operator representing the conditional mathematical subtraction operation.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a SuspendServiceStatementBuilder.SuspendServiceStatement.Implementation of the CohQL "SUSPEND SERVICE" command.
A qualifier annotation used for any SYNCED event.
An annotation literal for the
Synced
annotation.A qualifier annotation that can be applied to
MapListener CDI
observers to register them as MapListener.synchronous() listeners.An annotation literal for the
Synchronous
annotation.A tag interface indicating that a listener implementation has to receive
the event notifications synchronously on the corresponding service's thread.
A qualifier annotation used for any SYNCING event.
An annotation literal for the
Syncing
annotation.SystemDatagramSocketProvider produces JVM default datagram sockets
A
SystemEnvironmentParameterResolver is a ParameterResolver that is
an environment getter for Coherence environment properties implemented using
System.getenv(String).A
SystemPropertyParameterResolver is a ParameterResolver that is
based on property methods on System.A
SystemPropertyPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that will
replace XmlElement content annotated with "system-property" attributes with appropriate
System.getProperties().An abstraction that allows us to make system property resolution
customizable.
Default
SystemPropertyResolver implementation.A Daemon thread handler that asynchronously executes Runnable tasks, either
at a scheduled time or "as soon as possible".
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>.An
ElementProcessor that will parse an <tcp-acceptor> and
produce a TcpAcceptorDependencies object.TCP based datagram socket implementation.
A specialized version of
DatagramSocketImpl.TcpDatagramSocketProvider produces datagram sockets that uses
TCP sockets underneath for unicast communication.
DefaultDependenceis is a basic implementation of the Dependencies
interface providing "setter" methods for each property.
Dependencies specifies all dependency requirements of the TcpDatagramSocketProvider.
An
ElementProcessor that will parse an <tcp-initiator> and
produce a TcpInitiatorDependencies object.Term is the abstract class used to represent trees of Terms (term-trees).
TermLanguage is a simple language for building Terms.
Terms is a utility class that provides static convenience methods for
the construction of Terms.
TermWalker is a visitor class that provides a framework for walking
Term Trees
Factory interface for Thread creation.
A thin extension of
ThreadGate.ThreadGateLite is a Gate implementation built around the
ReentrantReadWriteLock.Bar represents the state of the
bars placed on this gate.This class provides an implementation of thread local storage.
A ThreadPoolManager manages the thread pool information for a Coherence
service thread pool.
A ThreadPoolSizingStrategy is a pluggable strategy used by a
Coherence service thread pool to manage its size.
Class for providing time functionality.
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 is a helper class used by Scanners to convert BaseTokens to
to OPTokens.
A base class for topic backing map managers.
The dependencies for a topic.
A exception that occurred during an operation on a
NamedTopic.A
TopicMapping captures configuration information for a pattern-match-based mapping from a proposed
NamedTopic name to a topic scheme.An
TopicMappingProcessor is responsible for processing <topic-mapping>
XmlElements to produce a TopicMapping.An exception that occurred during publishing of a message on a topic.
The
TopicScheme class is responsible for building a fully
configured instance of a topic.An
TopicSchemeMappingProcessor is responsible for processing
<topic-scheme-mapping> XmlElements to update the
ResourceMappingRegistry with ResourceMappings.A TopicService is a service providing Topics that can be used for
publish/subscribe functionality and message queue processing.
TopNAggregator is a ParallelAwareAggregator that aggregates the top N
extracted values into an array.
The sorted partial result.
Touches an entry (if present) in order to trigger interceptor re-evaluation
and possibly increment expiry time.
A
StatementBuilder that builds the
QueryPlus "TRACE" command.A
DaemonPool implementation that wraps another
DaemonPool and adds activation of tracing spans
for the Runnables executed by this pool.A
Runnable that executes another runnable
after activating a tracing span.A
TransactionalPreprocessor is an DocumentElementPreprocessor.ElementPreprocessor that
introduces (via cloning) internal cache-config xml content for xml elements.The
TransactionalScheme class builds a transactional cache.A TransactionEvent captures information pertaining to all mutations
performed within the context of a single request.
The TransactionEvent types.
TransactionEventInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive TransactionEvents.ConcurrentMap with additional transaction support.
A callback interface used by TransactionMap implementations.
A TransferEvent captures information concerning the transfer
of a partition for a storage enabled member.
A RecoveryTransferEvent is raised due to the recovery of a partition
from a persistent store.
The
TransferEvent types.TransferEventInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive TransferEvents.Responsible for processing
view-filter elements.A
Transition represents a transition in a FiniteStateMachine from one
or more possible states to a desired state.A
TransitionAction encapsulates the actions to be performed as part
of the Transition from one state to another.A thread-safe balanced binary search tree.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a TruncateCacheStatementBuilder.TruncateCacheStatement.Implementation of the CohQL "TRUNCATE CACHE" command.
A qualifier annotation used for any TRUNCATED event.
An annotation literal for the
Truncated
annotation.Defines a
NamedMap.Option for asserting the type
of keys and values used with a NamedCache.A UID is a 128-bit identifier that is almost guaranteed to be unique.
The
UnitCalculatorBuilder class builds a ConfigurableCacheMap.UnitCalculator.A
UnitCalculatorProcessor is responsible for processing a
unit-calculator XmlElement to produce a UnitCalculatorBuilder.Units is a union of MemorySize and unit count.Universal ValueExtractor implementation.
An
ExtractorBuilder implementation that will build
instances of UniversalExtractors.UniversalManipulator implementation.
Universal ValueUpdater implementation.
A collection of "back-door" utilities and helpers used internally.
An UnsolicitedCommitEvent captures changes pertaining to all observed
mutations performed against caches that were not directly caused (solicited)
by the partitioned service.
The UnsolicitedCommitEvent types.
UnsolicitedCommitInterceptor is an annotation that should be applied to
EventInterceptor implementations
that want to receive UnsolicitedCommitEvents.UnsupportedFeatureProcessor is an ElementProcessor that fails fast highlighting
which feature is not supported in this edition of the product.
A qualifier annotation used for any UPDATED event.
An annotation literal for the
Updated
annotation.UpdaterProcessor is an EntryProcessor implementations that updates an
attribute of an object cached in an InvocableMap.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a UpdateStatementBuilder.UpdateStatement.Implementation of the CohQL "UPDATE" command.
A qualifier annotation used for any UPDATING event.
An annotation literal for the
Updating
annotation.An interface for URI serialization.
A
PrivateKeyLoader that loads a Certificate
file from a URL.A
KeyStoreLoader that loads a KeyStore
file from a URL.A
MemberIdentityProvider that retrieves identity
values from URLs, files, or class path resources.A
PasswordProvider that reads the contents of a URL to obtain a password.A
PrivateKeyLoader that loads a PrivateKey
file in PEM format from a URL.Security token containing a username and password.
A Utf8Reader is used to read character data from an underlying stream.
A Utf8Writer is used to write character data onto an underlying stream.
A UUID is a 256-bit identifier that, if it is generated, is statistically
guaranteed to be unique.
An implementation of a
StatementBuilder
that parses a CohQL term tree to produce an instance of a ValidateSnapshotStatementBuilder.ValidateSnapshotStatement.Implementation of the CohQL "VALIDATE [ARCHIVED] SNAPSHOT" command.
An implementation of PofHandler that validates a POF stream.
A
Value is an immutable object that represents a value whose type is unknown at compile time.Filter which evaluates the content of a MapEvent values based on the
specified value extractor.
ValueExtractor is used to both extract values (for example, for sorting
or filtering) from an object, and to provide an identity for that extraction.
A
ValueMacroExpression is a string value potentially containing expandable macros.Process macro parameter default delimiter expansion.
A Macro Expansion Processor for a macro not containing any registered delimiters.
Process
:offset and :lengthValueMacroExpression.SpaceDefaultDelimiterExpansionProcessor performs DefaultDelimiter expansion processing
and disambiguates : - for offset and length from space for default delimiter.ValueManipulator represents a composition of
ValueExtractor and
ValueUpdater implementations.An
ElementProcessor that creates a BackingMapScheme
for use in a collection scheme.Defines a
NamedCollection.Option for asserting the type
of values used with a NamedTopic.Defines a
NamedCollection.Option for asserting the type
of values used with a NamedTopic.ValueUpdater is used to update an object's state.
An interface for versionable data.
Direct implementations of this interface are generally considered advanced
use cases, such as handling event receiver (client process) restarts.
Deprecated.
as of Coherence 3.2 all the functionality of this class has been
superceded by the ReadWriteBackingMap implementation
Deprecated.
as of Coherence 3.2 all the functionality of this class has been
superceded by the NearCache implementation
An extension of the partition Ownership object which also carries a change
version.
VersionedPartitions implementations provide a mapping from partition to version.
An Iterator for partitions being tracked by a
VersionedPartitions
implementation that allows retrieval of the next partition as a primitive.An Iterator for partitions being tracked by a
VersionedPartitions
implementation that allows retrieval of partition and version.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 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.A qualifier annotation used when injecting a cache view.
An annotation literal for the
View annotation.The
ViewBuilder provides a means to ViewBuilder.build() a view
(ContinuousQueryCache) using a fluent pattern / style.A Scheme that realizes both services and caches for Coherence 12.2.1.4 feature
named 'views'.
DocumentElementPreprocessor.ElementPreprocessor for the "view-scheme" element.VolatileHolder is a basic implementation of the Holder interface where
the held object is referenced from a volatile reference.
A class that builds the QueryPlus "WHENEVER" command.
A
FilterBinding annotation representing a
Filter produced from a CohQL where clause.An annotation literal for the
WhereFilter annotation.This is an imitation BufferInput implementation that provides the
BufferInput interface by delegating to an object that implements the
DataInput interface.
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.
This is an imitation BufferOutput implementation that provides the
BufferOutput interface by delegating to an object that implements the
DataOutput interface.
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.
CacheService implementation that delegates to a wrapped CacheService
instance.
A simple implementation of the
CachingScheme interface
built as a wrapper around another CachingScheme implementation.A collection of abstract Collection implementation classes for wrapping
Collection types.
Collection implementation which delegates all calls to another Collection.
Map.Entry implementation which delegates all calls to another Map.Entry.
Iterator implementation which delegates all calls to another Iterator.
List implementation which delegates all calls to another List.
Abstract wrapper implementation for LongArrays.
Map implementation which delegates all calls to another Map.
Set implementation which delegates all calls to another Set.
SortedSet implementation which delegates all calls to another SortedSet.
Collection implementation which uses a ReadWriteLock to manage
concurrent access to an underlying Collection.
Map Entry implementation which uses a ReadWriteLock to manage concurrent
access to an underlying Map Entry.
Map Entry Set implementation which uses a ReadWriteLock to manage
concurrent access to the underlying Entry objects.
Map implementation which uses a ReadWriteLock to manage concurrent
access to an underlying Map.
Set implementation which uses a ReadWriteLock to manage concurrent
access to an underlying Set.
A simple implementation of ConcurrentMap interface built as a
wrapper around any Map implementation.
A lock object.
This is an imitation DataInputStream class that provides the DataInput
interface by delegating to an object that implements the DataInput
interface.
This is an imitation DataOutputStream class that provides the DataOutput
interface by delegating to an object that implements the DataOutput
interface.
A WrapperException wraps a Throwable object as a RuntimeException.
This is an InputStream class that delegates to another InputStream.
InvocationService implementation that delegates to a wrapped
InvocationService instance.
A
MBeanServerProxy that wraps a MBeanServer.A simple implementation of NamedCache interface built as a
wrapper around any Map implementation.
This is an imitation ObjectInputStream class that provides the
ObjectInput interface by delegating to an object that implements the
ObjectInput interface.
This is an imitation ObjectOutputStream class that provides the
ObjectOutput interface by delegating to an object that implements the
ObjectOutput interface.
A simple implementation of ObservableMap interface built as a wrapper
around any Map implementation.
This is an OutputStream class that delegates to another OutputStream.
QueryRecorderFilter wrapper class.
A Gate implementation that allows for 2^31 reentrant enter calls by a single
thread.
Service implementation that delegates to a wrapped Service instance.
A
SessionConfiguration that delegates to another SessionConfiguration.The WrapperSocketAddressProviderBuilder wraps an AddressProviderBuilder so
that it can produce a SocketAddressProvider.
Deprecated.
As of Coherence 3.7, deprecated with no replacement.
Deprecated.
The WriteBuffer interface represents an in-memory block of binary data
that is being accumulated (written to).
The BufferOutput interface represents a DataOutputStream on top of a
WriteBuffer.
Overrides PrintStream to delegate to a PrintWriter.
An implementation of PofHandler that writes a POF stream to a WriteBuffer
using a BufferOutput object.
A Complex object represents the current complex data structure in the
POF stream.
A ComplexMap object represents a map data structure (with uniform keys
or with uniform keys and values) in the POF stream.
An
XmlAttribute represents an Xml Attribute, defined within an
XmlElement.This is a base class for building XmlSerializable value objects.
A BeanInfo contains information about the XML bean and its properties.
Provider responsible for converting Java collections to a XML formatted
stream.
Deprecated.
An interface for XML document access.
An
XmlDocumentReference provides an mechanism to reference an XmlDocument.An interface for XML element access.
An XmlElementAdapter supports properties of type XmlElement.
This abstract class contains XML manipulation methods.
An interface that describes a callback to resolve a substitutable
parameter value.
Deprecated.
As of 12.2.1.0.0, replaced by
JaxbXmlMarshallerProvider responsible for converting set of keys to a XML formatted
stream.
Provider responsible for converting Java maps to an XML formatted stream.
An interface for XML serialization.
An XmlSerializableAdapter supports Java objects that implement the
XmlSerializable interface.
PofSerializer implementation that supports the serialization and
deserialization of any class that implements XmlSerializable to
and from a POF stream.Denotes that a class is associated with the processing of a
specifically named Xml element or attribute.
An interface for XML element content and element attribute values.
Filter which returns the logical exclusive or ("xor") of two other filters.
A class representing the logical XOR operator.
AbstractStableIterator