| Interface | Description |
|---|---|
| AnyListener |
An AnyEvent is an event used when no specific event implementation fits
and it is not worth making one.
|
| BinaryEntry<K,V> |
Map.Entry that internally stores both key and value in a Binary format and
uses an underlying Serializer to convert it to and from an Object view.
|
| BinaryLongMap |
A BinaryLongMap is an interface representing a mapping from Binary values
to long values.
|
| BinaryLongMap.Entry |
Represents an Entry stored in a BinaryLongMap.
|
| BinaryLongMap.EntryVisitor |
Represent a visitor to be applied to one or more entries in the
BinaryLongMap.
|
| Builder<T> |
A
Builder provides a mechanism for realizing a specific class of
object as required. |
| ByteSequence |
Represents a sequence of bytes.
|
| ConcurrentMap<K,V> |
Map with additional concurrency features.
|
| Controllable |
The Controllable interface represents a configurable daemon-like object,
quite often referred to as a service, that usually operates on its
own thread and has a controllable life cycle.
|
| Converter<F,T> |
Provide for "pluggable" object conversions.
|
| Disposable | Deprecated
As of Coherence 12.1.2, replaced by
Disposable |
| ExternalizableHelper.Shielded |
Marker interface.
|
| ExternalizableHelper.XmlBeanClassCache |
An interface for caching class reference by integer ID values.
|
| Filter<T> |
Provide for "pluggable" conditional behavior.
|
| Gate<R> |
A thin extension of
Gate. |
| HashEncoded |
HashEncoded interface represents an ability to retrieve an encoded hash
value; most commonly used to calculate a partition id.
|
| InflatableCollection.InflatedCollection |
A marker interface which is used to identify internally inflated
Collections.
|
| InvocableMap<K,V> |
An InvocableMap is a Map against which both entry-targeted processing and
aggregating operations can be invoked.
|
| InvocableMap.Entry<K,V> |
An InvocableMap.Entry contains additional information and exposes
additional operations that the basic Map.Entry does not.
|
| InvocableMap.EntryAggregator<K,V,R> |
An EntryAggregator represents processing that can be directed to occur
against some subset of the entries in an InvocableMap, resulting in a
aggregated result.
|
| InvocableMap.EntryProcessor<K,V,R> |
An invocable agent that operates against the Entry objects within a Map.
|
| InvocableMap.ParallelAwareAggregator<K,V,P,R> | Deprecated
This interface was deprecated in Coherence 12.2.1 and might be
removed in a future release.
|
| InvocableMap.ParallelAwareAggregator.PartialResultAggregator<P> | Deprecated
This interface was deprecated in Coherence 12.2.1 and might be
removed in a future release.
|
| InvocableMap.StreamingAggregator<K,V,P,R> |
A StreamingAggregator is an extension of
InvocableMap.EntryAggregator that
processes entries in a streaming fashion and provides better control
over execution characteristics. |
| LongArray<V> |
An interface, similar in its methods to List, and similar in its purpose
to a Java array, designed for sparse storage and indexed by long values.
|
| LongArray.Iterator<V> |
An Iterator that adds a "current element" concept, similar to the
Map.Entry interface. |
| MapEventTransformer<K,V,U> |
MapEventTransformer interface is used to allow an event consumer to change
the content of a
MapEvent destined for the corresponding
MapListener. |
| MapIndex<K,V,E> |
MapIndex is used to correlate values stored in an indexed Map (or
attributes of those values) to the corresponding keys in the indexed Map.
|
| MapListener<K,V> |
The listener interface for receiving MapEvents.
|
| MapListenerSupport.PrimingListener<K,V> |
A tag interface indicating that this listener is registered as a
synchronous listener for lite events (carrying only a key) and generates
a "priming" event when registered.
|
| MapListenerSupport.SynchronousListener<K,V> |
A tag interface indicating that tagged MapListener implementation
has to receive the MapEvent notifications in a synchronous manner.
|
| MapTrigger<K,V> |
MapTrigger represents a functional agent that allows to validate, reject or
modify mutating operations against an underlying map.
|
| MapTrigger.Entry<K,V> |
A MapTrigger Entry represents a pending change to an Entry that is about
to committed to the underlying Map.
|
| MultiBinaryLongMap.BinaryLongMapListener |
A listener that allows the owner of one of the delegating maps to
respond to changes in the key set made by an owner of another
delegating map.
|
| MultiBinaryLongMap.SafeEntryVisitor |
SafeEntryVisitor is a marker interface used internally by the implementation
of the MultiBinaryLongMap to indicate that an
BinaryLongMap.EntryVisitor
implementation is "safe" and does not retain any references to passed
Entries. |
| MultiBinaryLongMap.SafePredicate |
SafePredicate is a marker interface used internally by the implementation
of the MultiBinaryLongMap to indicate that a
Predicate
implementation is "safe" and does not retain any references to passed
Entries. |
| ObservableMap<K,V> |
ObservableMap interface represents an object with a model being
a Map that allows for pluggable notifications for occurring changes.
|
| PagedIterator.Advancer |
Advancer is a pluggable component that knows how to load a new page
(Collection) of objects to be used by the enclosing PagedIterator.
|
| Proxyable<T> |
An interface that should be implemented by the classes that are able to
create a client-side proxy for itself.
|
| QueryContext |
The QueryContext provides an execution context to server-side agents during
query execution.
|
| QueryMap<K,V> |
Map with additional query features.
|
| QueryMap.Entry<K,V> |
A QueryMap Entry exposes additional index-related operation that the
basic Map Entry does not.
|
| QueryRecord |
The QueryRecord object carries information regarding the estimated or actual
execution cost for a query operation.
|
| QueryRecord.PartialResult |
A QueryRecord.PartialResult is a partial query record that contains
recorded costs for a query operation.
|
| QueryRecord.PartialResult.ExplainStep |
A QueryRecord.ExplainStep is a
QueryRecord.PartialResult.RecordableStep that provides
the ability to record the estimated cost of evaluating a filter as
part of a query operation. |
| QueryRecord.PartialResult.IndexLookupRecord |
An IndexLookupRecord holds the recorded information about an index
lookup performed during filter evaluation as part of a query
record.
|
| QueryRecord.PartialResult.RecordableStep |
A QueryRecord.RecordableStep is a
step that provides the
ability to record the cost of evaluating a filter as part of a
query operation. |
| QueryRecord.PartialResult.Step |
A QueryRecord.Step carries the recorded cost of evaluating a filter
as part of a query operation.
|
| QueryRecord.PartialResult.TraceStep |
A QueryRecord.TraceStep is a
QueryRecord.PartialResult.RecordableStep that provides the
ability to record the information associated with the actual cost
of evaluating a filter as part of a query operation. |
| ResourceRegistry |
A
ResourceRegistry is a registry and owner of strongly typed and
explicitly named resources. |
| ResourceRegistry.ResourceLifecycleObserver<R> |
The
ResourceRegistry.ResourceLifecycleObserver interface defines lifecycle handlers
for resources registered with a ResourceRegistry. |
| ResourceResolver |
A
ResourceResolver provides a mechanism to lookup and resolve
optionally named, strongly typed resources. |
| SegmentedConcurrentMap.ContentionObserver |
ContentionObserver is used to observe the contention lock-related actions
performed on the concurrent map.
|
| SegmentedHashMap.EntryAction |
An EntryAction encapsulates a logical action to be executed in the
context of a key (that may or may not exist in the map).
|
| SegmentedHashMap.IterableEntryAction |
IterableEntryAction is an EntryAction that is suitable for applying to
all keys in a map.
|
| Service |
A Service is a Controllable that emits service lifecycle events.
|
| ServiceListener |
The listener interface for receiving ServiceEvents.
|
| Sizable |
The Sizable interface is implemented by types that are capable of calculating
the memory footprint of an instance.
|
| Streamer<T> |
Enables traversal of elements in the underlying data set using either
Iterator, Spliterator or a Stream, while allowing
implementors to provide additional metadata, such as the size and other
characteristics of the underlying data set. |
| SynchronousListener<K,V> |
A tag interface indicating that a listener implementation has to receive
the event notifications synchronously on the corresponding service's thread.
|
| ThreadFactory |
Factory interface for Thread creation.
|
| TransactionMap |
ConcurrentMap with additional transaction support.
|
| TransactionMap.Validator |
A callback interface used by TransactionMap implementations.
|
| ValueExtractor<T,E> |
ValueExtractor is used to both extract values (for example, for sorting
or filtering) from an object, and to provide an identity for that extraction.
|
| ValueManipulator<T,V> |
ValueManipulator represents a composition of
ValueExtractor and
ValueUpdater implementations. |
| ValueUpdater<T,U> |
ValueUpdater is used to update an object's state.
|
| Versionable<T extends Comparable<? super T>> |
An interface for versionable data.
|
| Class | Description |
|---|---|
| AbstractByteSequence |
A simple base class for ByteSequence implementations.
|
| AbstractByteSequence.AggregateByteSequence |
A naive ByteSequence that glues two ByteSequence instances together.
|
| AbstractByteSequence.PartialByteSequence |
A naive ByteSequence that represents a portion of another ByteSequence.
|
| AbstractKeyBasedMap<K,V> |
AbstractKeyBasedMap is a base class for Map implementations.
|
| AbstractKeyBasedMap.DeferredCacheEvent<K,V> |
A DeferredCacheEvent is a
CacheEvent object that defers the loading
of the old value. |
| AbstractKeySetBasedMap<K,V> |
AbstractKeySetBasedMap is an extension to the AbstractKeyBasedMap that
has a full awareness of the set of keys upon which the Map is based.
|
| AbstractLongArray<V> |
An implementation of portions of the LongArray interface.
|
| AbstractMapListener |
A base class that simplifies the implementation of a MapListener,
particularly inner classes that only implement one or two of the
three event methods.
|
| AbstractSafeLongArray<V> |
An abstract base class for thread-safe
LongArrays which are protected by lock(s). |
| AbstractScript |
AbstractScriptBase is the base class for script based processing.
|
| AbstractSparseArray<V> |
A data structure resembling an array indexed by long values, stored as an
AVL tree.
|
| AbstractSparseArray.Node<V> |
An AVL tree node.
|
| AbstractStableIterator | Deprecated
As of Coherence 12.1.2, replaced by
AbstractStableIterator |
| Aggregators |
Simple Aggregator DSL.
|
| AnyEvent |
An AnyEvent is an event used when no specific event implementation fits
and it is not worth making one.
|
| AsynchronousAgent<T> |
Base class for asynchronous operations that provides a simple implementation
of the
Future interface. |
| Base |
Base class for providing standard functionality.
|
| Base.LoggingWriter |
Inner class for over-riding the destination of log(), out() and err()
calls.
|
| Base.StackFrame |
A class that provides "stack frame" information from a line of a stack
trace.
|
| Binary |
A thread-safe immutable binary object.
|
| BinaryLongMap.SimpleMapImpl |
A java.util.Map<Binary, Long> implementation.
|
| BinaryRadixTree |
A BinaryRadixTree is a memory-optimized radix tree (aka a Patricia trie)
that is intended to efficiently store a mapping from Binary values to long
values.
|
| BinaryWriteBuffer |
a WriteBuffer implementation whose primary purpose is to be used to create
Binary objects.
|
| BitHelper |
A collection of methods for bit-based operations.
|
| BuilderHelper |
Provides a collection of helper methods for working with
Builders. |
| CacheCollator |
Implements a collator which caches its keys.
|
| ChainedCollection<E> |
An unmodifiable Collection that provides access to many collections in the
given order.
|
| ChainedEnumerator |
Provide an enumerator which enumerates the contents of multiple
enumerators.
|
| ChainedMap |
Chains two maps into one virtual map.
|
| ChainedResourceResolver |
A
ChainedResourceResolver is a ResourceResolver that
chains together one or more other ResourceResolvers, those of which
will be queried (in the order in which they are added to the ChainedResourceResolver)
when attempting to resolve a resource. |
| CircularArrayList |
Resizable-array implementation of the List interface.
|
| ClassFilter |
Filter which discards all objects that are not of a certain class.
|
| ClassHelper |
This abstract class contains dynamic (reflect-based) class, method, and
field manipulation methods.
|
| CollectionHelper | Deprecated
As of Coherence 12.1.2
|
| CompositeKey<P,S> |
Key class that consists of a primary and secondary component.
|
| ConditionalIndex |
ConditionalIndex is a
MapIndex implementation that uses an associated
filter to evaluate whether or not an entry should be indexed. |
| ConverterCollections |
A collection of Collection implementation classes that use the Converter
interface to convert the items stored in underlying collection objects.
|
| ConverterCollections.AbstractConverterEntry<FK,TK,FV,TV> |
An abstract Map Entry that lazily converts the key and value.
|
| ConverterCollections.ConverterCacheEntry |
A ConfigurableCacheMap.Entry that lazily converts the key and value.
|
| ConverterCollections.ConverterCacheEvent |
A Converter CacheEvent views an underlying CacheEvent through a set of
key and value Converters.
|
| ConverterCollections.ConverterCacheListener |
A converter MapListener that converts events of the underlying
MapListener for the underlying NamedCache.
|
| ConverterCollections.ConverterCacheMap<FK,TK,FV,TV> |
A Converter CacheMap views an underlying CacheMap through a set of key
and value Converters.
|
| ConverterCollections.ConverterCollection<F,T> |
A Converter Collection views an underlying Collection through a
Converter.
|
| ConverterCollections.ConverterComparator<F,T> |
A Comparator that Converts the elements before
comparing them.
|
| ConverterCollections.ConverterConcurrentMap<FK,TK,FV,TV> |
A Converter ConcurrentMap views an underlying ConcurrentMap through a
set of key and value Converters.
|
| ConverterCollections.ConverterEntry<FK,TK,FV,TV> |
A Map Entry that lazily converts the key and value.
|
| ConverterCollections.ConverterEntrySet<FK,TK,FV,TV> |
A Converter Entry Set views an underlying Entry Set through a set of
key and value Converters.
|
| ConverterCollections.ConverterEnumerator<F,T> |
Provide an implementation of an enumerator which converts each of the
items which it enumerates.
|
| ConverterCollections.ConverterHolder<F,T> |
A Holder that converts the element before returning them.
|
| ConverterCollections.ConverterInvocableMap<FK,TK,FV,TV> |
A Converter InvocableMap views an underlying InvocableMap through a
set of key and value Converters.
|
| ConverterCollections.ConverterList<F,T> |
A Converter List views an underlying List through a Converter.
|
| ConverterCollections.ConverterListIterator<F,T> |
A Converter ListIterator views an underlying ListIterator through a
Converter.
|
| ConverterCollections.ConverterLongArray<F,T> |
ConverterLongArray converts the value of the LongArray from its raw form
(type
F) to the desired from (type T). |
| ConverterCollections.ConverterMap<FK,TK,FV,TV> |
A Converter Map views an underlying Map through a set of key and value
Converters.
|
| ConverterCollections.ConverterMapEvent |
A ConverterMapEvent views an underlying MapEvent through a set of key and
value Converters.
|
| ConverterCollections.ConverterMapListener |
A converter MapListener that converts events of the underlying
MapListener for the underlying map.
|
| ConverterCollections.ConverterNamedCache<FK,TK,FV,TV> |
A Converter NamedCache views an underlying NamedCache through a set of
key and value Converters.
|
| ConverterCollections.ConverterObservableMap<FK,TK,FV,TV> |
A Converter ObservableMap views an underlying ObservableMap through a
set of key and value Converters.
|
| ConverterCollections.ConverterQueryMap<FK,TK,FV,TV> |
A Converter QueryMap views an underlying QueryMap through a set of key
and value Converters.
|
| ConverterCollections.ConverterSet<F,T> |
A Converter Set views an underlying Set through a Converter.
|
| ConverterCollections.ConverterSortedMap<FK,TK,FV,TV> |
A Converter SortedMap views an underlying SortedMap through a set of
key and value Converters.
|
| ConverterCollections.ConverterSortedSet<F,T> |
A Converter SortedSet views an underlying SortedSet through a
Converter.
|
| ConverterEnumerator | Deprecated
As of Coherence 12.1.2, replaced by
ConverterCollections.ConverterEnumerator |
| CopyOnWriteLongArray<V> |
A thread-safe variant of
LongArray in which all mutating operations
(e.g. |
| CopyOnWriteLongArray.UnmodifiableIterator<V> |
Unmodifiable view of a LongArray.Iterator.
|
| CopyOnWriteMap<K,V> |
A thread-safe variant of
Map in which all mutating operations
(e.g. |
| Daemon |
A abstract Daemon thread handler.
|
| DaemonThreadFactory |
DaemonThreadFactory is a ThreadFactory which produces daemon threads.
|
| DeltaSet |
Implements a set which is based on another set, which is assumed to be
immutable.
|
| Dequeue |
Represents a double-ended queue (dequeue) of objects.
|
| EntrySetMap |
A trivial Map implementation that is based on a specified set of entries.
|
| EnumerationIterator<E> |
Provide a implementation of an Iterator based on data from an Enumeration.
|
| ExternalizableHelper |
Helpers for the Serializable, Externalizable and the ExternalizableLite
interface.
|
| ExternalizableHelper.DecoratedMultiBufferReadBuffer |
DecoratedMultiBufferReadBuffer is a MultiBufferWriteBuffer that
represents a binary "decorated" value, and allows a more
optimized
ExternalizableHelper.getUndecorated(ReadBuffer) operation. |
| ExternalizableHelper.DefaultObjectStreamFactory |
Default ObjectStreamFactory implementation.
|
| ExternalizableHelper.FormatAwareCompressor |
A DeltaCompressor wrapper implementation that removes/replaces the
serialization format byte (FMT_EXT) before/after delegating to the
underlying compressor.
|
| ExternalizableHelper.IntDecoratedObject |
Integer decorated object.
|
| ExternalizableHelper.ShieldedDataOutputStream |
An OutputStream that implements DataOutput that delegates all
operations other than flush and close to an underlying object that
implements DataOutput.
|
| ExternalizableHelper.ShieldedInputStream |
An InputStream that delegates all operations other than close to an
underlying InputStream.
|
| ExternalizableHelper.ShieldedObjectOutputStream |
An OutputStream that implements ObjectOutput that delegates all
operations other than flush and close to an underlying object that
implements ObjectOutput.
|
| ExternalizableHelper.ShieldedOutputStream |
An OutputStream that delegates all operations other than flush and
close to an underlying OutputStream.
|
| ExternalizableHelper.SimpleXmlBeanClassCache |
An implementation XmlBeanClassCache that uses a pre-defined list of
XmlBean implementations.
|
| ExternalizableHelper.Stats |
Serialization statistics for a given user type.
|
| Extractors |
Simple Extractor DSL.
|
| FilterEnumerator |
Provide a generic implementation of an enumerator which can enumerate
items based on an inclusion test.
|
| Filters |
Simple Filter DSL.
|
| ForwardOnlyMapIndex |
ForwardOnlyMapIndex is a
MapIndex implementation that unlike the
SimpleMapIndex maintains only a forward index and not the inverse index. |
| HashHelper |
This abstract class contains helper functions for
calculating hash code values for any group of
java intrinsics.
|
| ImmutableArrayList |
Implementation of the Collection Framework interface "List" in a read-
only fashion on top of an array data structure.
|
| ImmutableMultiList |
Implementation of the List interface in a read-only fashion based on a
collection of arrays.
|
| InflatableCollection |
A Collection implementation which optimizes memory consumption for
collections that often contain just a single value.
|
| InflatableList |
A List specialization of InflatableCollection.
|
| InflatableSet |
A Set specialization of InflatableCollection.
|
| InvocableMapHelper |
Helper methods for InvocableMap implementations and Filter related
evaluation.
|
| InvocableMapHelper.IndexAdapter |
MapListener implementation that routes the map events into the
corresponding MapIndex calls.
|
| InvocableMapHelper.RoutingBinaryEntry |
BinaryEntry wrapper that routes the getValue()/getBinaryValue()
calls onto getOriginalValue()/getOriginalBinaryValue().
|
| InvocableMapHelper.RoutingMapTriggerEntry |
MapTrigger.Entry wrapper that routes the getValue() call onto
getOriginalValue().
|
| InvocableMapHelper.SimpleEntry<K,V> |
Simple implementation of the InvocableMap.Entry interface.
|
| IteratorEnumerator |
Provide a implementation of an enumerator based on data from an Iterator.
|
| KeyValueArrayMap |
KeyValueArrayMap is a Map implementation backed by an array of keys, and an
array of the associated values.
|
| Listeners |
Provide a simple, efficient, and thread-safe implementation of a list
of event listeners.
|
| ListMap<K,V> |
As of Coherence 3.2, the ListMap simply extends Java's own LinkedHashMap,
which became available in JDK 1.4.
|
| LiteMap<K,V> |
An implementation of java.util.Map that is optimal (in terms of both size
and speed) for very small sets of data but still works excellently with
large sets of data.
|
| LiteSet<E> |
An implementation of java.util.Set that is optimal (in terms of both size
and speed) for very small sets of data but still works excellently with
large sets of data.
|
| MapEvent<K,V> |
An event which indicates that the content of a map has changed:
an entry has been added
an entry has been removed
an entry has been changed
A MapEvent object is sent as an argument to the MapListener interface
methods.
|
| MapListenerSupport |
This class provides support for advanced MapListener functionality.
|
| MapListenerSupport.FilterEvent |
An extension of the CacheEvent which may carry no values (old or new), but
instead holds on an array of Filter objects being the "cause" of the event.
|
| MapListenerSupport.WrapperListener<K,V> |
A base class for various wrapper listener classes.
|
| MapListenerSupport.WrapperPrimingListener |
A wrapper class that turns the specified MapListener into
a priming listener.
|
| MapListenerSupport.WrapperSynchronousListener<K,V> |
A wrapper class that turns the specified MapListener into
a synchronous listener.
|
| MapSet |
An ExternalizableLite implementation of java.util.Set that uses an
underlying Map object to store its data in, just as the Java HashSet
implementation uses an underlying HashMap for its element storage.
|
| MapTriggerListener |
MapTriggerListener is a special purpose MapListener implementation that is
used to register a
MapTrigger on a corresponding ObservableMap. |
| MultiBinaryLongMap |
A data structure that represents a series of BinaryLongMap instances.
|
| MultiBinaryLongMap.AbstractDelegateBinaryLongMap |
Abstract base class for BinaryLongMap implementations that delegate the
key and value storage to the MultiBinaryLongMap.
|
| MultiBinaryLongMap.ChainedLock |
A ChainedLock is a
Lock implementation that represents a composition
of two component locks, parent and child. |
| MultiBinaryLongMap.DelegatingBinaryLongMap |
An implementation of BinaryLongMap that uses another BinaryLongMap to
store its keys and one index of a LongStorage to store its values.
|
| MultiBinaryLongMap.LongStorage |
An internal data structure for managing elastic storage of
multi-dimensional data; basically, it is a two-dimensional array of
rows and columns that can be grown in either dimension, but is
optimized specifically for the addition and removal of rows.
|
| MultiBinaryLongMap.MaskedBinaryLongMap |
MaskedBinaryLongMap is a BinaryLongMap which represents a mapping from a
Binary to a fixed-bit-width numeric value (though exposed as a long
datatype), based on an underlying BinaryLongMap.
|
| MultiBinaryLongMap.MaskedLongMapHolder |
MaskedLongMapHolder is used to produce
MultiBinaryLongMap.MaskedBinaryLongMap
instances backed by a shared BinaryLongMap. |
| MultiBinaryLongMap.SafeBinaryLongMap |
The SafeBinaryLongMap is a BinaryLongMap implementation that wraps an
underlying BinaryLongMap in order to add thread safety.
|
| MultiBinaryLongMap.SafeEntry |
SafeEntry is an immutable
BinaryLongMap.Entry implementation that
exposes the logical contents of an underlying Entry in a way that is
safe from mutations or being held as a reference. |
| MultiBinaryLongMap.WrapperBinaryLongMap |
The WrapperBinaryLongMap is a BinaryLongMap implementation that wraps
an underlying BinaryLongMap.
|
| MultiplexingMapListener<K,V> |
A base class that simplifies the implementation of a MapListener by
multiplexing all events into a single listener method.
|
| NullFilter |
Filter which discards null references.
|
| NullImplementation |
A collection of classes that do nothing.
|
| NullImplementation.NullActionPolicy |
An implementation of an ActionPolicy that allows all actions.
|
| NullImplementation.NullAddressProvider |
Null implementation of
AddressProvider. |
| NullImplementation.NullBackingMapManagerContext |
An implementation of BackingMapManagerContext that does nothing.
|
| NullImplementation.NullCacheStore |
An implementation of an CacheStore that does nothing.
|
| NullImplementation.NullCollector<V> |
A
Collector implementation that does nothing. |
| NullImplementation.NullContinuation<R> |
A Continuation that does nothing.
|
| NullImplementation.NullConverter |
A Converter that does nothing.
|
| NullImplementation.NullDeltaCompressor |
An implementation of a DeltaCompressor that does nothing and always
returns the new stream.
|
| NullImplementation.NullEntryProcessor |
An implementation of an EntryProcessor that does nothing and returns
Boolean.TRUE as a result of execution.
|
| NullImplementation.NullEnumerator |
An empty enumerator.
|
| NullImplementation.NullMap |
A Map that contains nothing and does nothing.
|
| NullImplementation.NullObservableMap |
An immutable ObservableMap which contains nothing.
|
| NullImplementation.NullOutputStream |
An OutputStream that does basically nothing.
|
| NullImplementation.NullPartitionAssignmentStrategy |
An implementation of
PartitionAssignmentStrategy that does nothing. |
| NullImplementation.NullPersistenceEnvironment<R> |
A
PersistenceEnvironment that does nothing. |
| NullImplementation.NullPersistenceManager<R> |
A
PersistenceManager that does nothing. |
| NullImplementation.NullPersistentStore<R> |
A
PersistentStore that does as little as possible. |
| NullImplementation.NullPofContext |
An implementation of PofContext that does nothing.
|
| NullImplementation.NullPofHandler |
An implementation of PofHandler that does nothing.
|
| NullImplementation.NullReader |
A reader that does basically nothing.
|
| NullImplementation.NullResourceRegistry |
A
ResourceRegistry implementation that does nothing. |
| NullImplementation.NullSet |
An immutable set which contains nothing.
|
| NullImplementation.NullValueExtractor |
A ValueExtractor that always results in the passed-in value.
|
| NullImplementation.NullWriter |
A writer that does basically nothing.
|
| ObservableHashMap<K,V> |
An ObservableMap implementation that extends the SafeHashMap.
|
| OpenHashMap<K,V> |
An implementation of
Map that is optimized for memory
footprint. |
| OpenHashSet<E> |
An implementation of
Set that is optimized for memory
footprint. |
| PagedIterator |
PagedIterator is an Iterator implementation based on a concept of a page
Advancer - a pluggable component that knows how to supply a next page of
objects to iterate through.
|
| PrimitiveSparseArray |
A data structure resembling a long array indexed by long values.
|
| PrimitiveSparseArray.PrimitiveNode |
Node mapping long key to Object value.
|
| Processors |
Simple
InvocableMap.EntryProcessor DSL. |
| QueryHelper |
QueryHelper is a utility class that provides a set of factory methods
used for building instances of
Filter or
ValueExtractor. |
| ReadHeavyLongArray<V> |
A thread-safe LongArray implementation for read heavy workloads but which is also efficient with frequent and/or
bursty writes.
|
| RecyclingLinkedList |
Extends SafeLinkedList and adds recycling of Node objects.
|
| ResourceResolverHelper |
Provides helpful methods for working with
ResourceResolvers. |
| RestrictedCollections |
A collection of Collection implementation classes that limit the data type.
|
| RestrictedCollections.RestrictedCollection |
A restricted Collection that requires its contents to be of a
specified class.
|
| RestrictedCollections.RestrictedEntrySet |
A restricted Collection that requires its contents to be of a
specified class.
|
| RestrictedCollections.RestrictedList |
A restricted List that requires its contents to be of a
specified class.
|
| RestrictedCollections.RestrictedListIterator |
A restricted ListIterator that requires its contents to be of a
specified class.
|
| RestrictedCollections.RestrictedMap |
A restricted Map that requires its keys and values to be of
specified classes.
|
| RestrictedCollections.RestrictedSet |
A restricted Set that requires its contents to be of a
specified class.
|
| RestrictedCollections.RestrictedSortedMap |
A restricted SortedMap that requires its keys and values to be of
specified classes.
|
| RestrictedCollections.RestrictedSortedSet |
A restricted Set that requires its contents to be of a
specified class.
|
| SafeClock |
SafeClock maintains a "safe" time in milliseconds.
|
| SafeHashMap<K,V> |
An implementation of java.util.Map that is synchronized, but minimally so.
|
| SafeHashMap.Entry<K,V> |
A map entry (key-value pair).
|
| SafeHashSet |
An implementation of java.util.Set that is synchronized, but minimally so.
|
| SafeLinkedList |
Implementation of the Collection Framework interface "List" using a linked
list algorithm.
|
| SafeLinkedList.Node |
A Node in the List.
|
| SafeLongArray<V> |
A thread-safe variant of
LongArray in which is protected by a ReentrantLock. |
| SafeSortedMap |
Implementation of a
SortedMap extending ConcurrentSkipListMap
to support null keys and null values. |
| SafeSortedMap.EntrySet |
Entry set delegation of the super map implementation.
|
| SafeSortedMap.KeySet |
Key set delegation of the super map implementation.
|
| SafeSortedMap.Null | |
| SafeSortedMap.NullableEntry |
Map.Entry implementation that supports null key/value placeholders.
|
| SafeSortedMap.SubMap |
SubMap delegation to manage
SafeSortedMap.NULL in entry key and/or value. |
| SafeSortedMap.Values |
Values delegation of the super map implementation.
|
| SegmentedConcurrentMap |
An implementation of SegmentedHashMap that also implements the ConcurrentMap
interface.
|
| SegmentedConcurrentMap.SizeAction |
Action support for size().
|
| SegmentedHashMap |
An implementation of java.util.Map that is optimized for heavy concurrent use.
|
| SegmentedHashMap.ContainsValueAction |
Action support for containsValue().
|
| SegmentedHashMap.Entry |
A map entry (key-value pair).
|
| SegmentedHashMap.EntryActionAdapter |
EntryActionAdapter is a convenience class that provides default
implementations for the EntryAction and IterableEntryAction interface
methods.
|
| SegmentedHashMap.Segment |
Segment metadata.
|
| SegmentedHashSet |
An implementation of java.util.Set that is optimized for heavy concurrent
use.
|
| ServiceEvent |
An event which indicates that a Service state has changed:
a service is starting
a service has started
a service is stopping
a service has stopped
A ServiceEvent object is sent as an argument to the ServiceListener
interface methods.
|
| SetMap<K,V> | |
| SimpleEnumerator<E> |
Provide a generic implementation of an array enumerator.
|
| SimpleHolder<V> |
General purpose container that can be used as an accumulator for any
reference type.
|
| SimpleLongArray |
An implementation of LongArray that stores values in an array, thus is
actually an "IntArray".
|
| SimpleMapEntry<K,V> |
A map entry (key-value pair).
|
| SimpleMapIndex |
SimpleMapIndex is a MapIndex implementation used to correlate property values
extracted from resource map entries with corresponding keys using what is
commonly known as an Inverted Index algorithm.
|
| SimpleMapIndex.IndexCalculator |
A stateful
calculator
used to calculate the cost of a homogeneous index (holding all values of a
single type). |
| SimpleQueryRecord |
Simple QueryRecord implementation.
|
| SimpleQueryRecord.PartialResult |
Simple QueryRecord.PartialResult implementation.
|
| SimpleQueryRecord.PartialResult.IndexLookupRecord |
Simple QueryRecord.PartialResult.IndexLookupRecord implementation.
|
| SimpleQueryRecord.PartialResult.Step |
Simple QueryRecord.PartialResult.Step implementation.
|
| SimpleQueryRecordReporter |
Simple query record reporter used to obtain a string representation of
QueryRecord object. |
| SimpleResourceRegistry |
A
SimpleResourceRegistry is a basic implementation of a ResourceRegistry. |
| SimpleResourceResolver |
A simple implementation of a
ResourceResolver. |
| SimpleStack |
A LIFO (last in, first out) unbounded stack of objects.
|
| SimpleStreamer<T> |
Simple implementation of a
Streamer. |
| SortedBag<E> |
SortedBag is a
multiset or bag implementation that supports sorted traversal
of the contained elements and is optimized for insertions and removals.
|
| SortedEnumerator |
Sorts the contents of the passed enumerator then enumerates those contents.
|
| SparseArray<V> |
A data structure resembling an Object array indexed by long values.
|
| SparseArray.ObjectNode<V> |
Node mapping long key to Object value.
|
| StringTable |
Like a hash table, but built specifically for strings.
|
| SubList<T> |
Implements a list which is based on another list, represents a sub-list of the underlying list.
|
| SubSet<E> |
Implements a set which is based on another set, which is assumed to be
immutable.
|
| TaskDaemon |
A Daemon thread handler that asynchronously executes Runnable tasks, either
at a scheduled time or "as soon as possible".
|
| ThreadGate<R> |
A thin extension of
ThreadGate. |
| ThreadGateLite<R> |
ThreadGateLite is a Gate implementation built around the
ReentrantReadWriteLock. |
| ThreadGateLite.Bar |
Bar represents the state of the
bars placed on this gate. |
| ThreadLocalObject |
This class provides an implementation of thread local storage.
|
| Tree |
A thread-safe balanced binary search tree.
|
| UID |
A UID is a 128-bit identifier that is almost guaranteed to be unique.
|
| Unsafe |
A collection of "back-door" utilities and helpers used internally.
|
| UUID |
A UUID is a 256-bit identifier that, if it is generated, is statistically
guaranteed to be unique.
|
| VersionHelper |
A utility class for working with Coherence versions.
|
| WrapperCollections |
A collection of abstract Collection implementation classes for wrapping
Collection types.
|
| WrapperCollections.AbstractWrapperCollection<E> |
Collection implementation which delegates all calls to another Collection.
|
| WrapperCollections.AbstractWrapperEntry<K,V> |
Map.Entry implementation which delegates all calls to another Map.Entry.
|
| WrapperCollections.AbstractWrapperIterator<E> |
Iterator implementation which delegates all calls to another Iterator.
|
| WrapperCollections.AbstractWrapperList<E> |
List implementation which delegates all calls to another List.
|
| WrapperCollections.AbstractWrapperLongArray<V> |
Abstract wrapper implementation for LongArrays.
|
| WrapperCollections.AbstractWrapperMap<K,V> |
Map implementation which delegates all calls to another Map.
|
| WrapperCollections.AbstractWrapperSet<E> |
Set implementation which delegates all calls to another Set.
|
| WrapperCollections.AbstractWrapperSortedSet<E> |
SortedSet implementation which delegates all calls to another SortedSet.
|
| WrapperCollections.ConcurrentWrapperCollection<E> |
Collection implementation which uses a ReadWriteLock to manage
concurrent access to an underlying Collection.
|
| WrapperCollections.ConcurrentWrapperEntry<K,V> |
Map Entry implementation which uses a ReadWriteLock to manage concurrent
access to an underlying Map Entry.
|
| WrapperCollections.ConcurrentWrapperEntrySet<K,V> |
Map Entry Set implementation which uses a ReadWriteLock to manage
concurrent access to the underlying Entry objects.
|
| WrapperCollections.ConcurrentWrapperMap<K,V> |
Map implementation which uses a ReadWriteLock to manage concurrent
access to an underlying Map.
|
| WrapperCollections.ConcurrentWrapperSet<E> |
Set implementation which uses a ReadWriteLock to manage concurrent
access to an underlying Set.
|
| WrapperConcurrentMap<K,V> |
A simple implementation of ConcurrentMap interface built as a
wrapper around any Map implementation.
|
| WrapperConcurrentMap.Lock |
A lock object.
|
| WrapperObservableMap<K,V> |
A simple implementation of ObservableMap interface built as a wrapper
around any Map implementation.
|
| WrapperReentrantGate |
A Gate implementation that allows for 2^31 reentrant enter calls by a single
thread.
|
| Enum | Description |
|---|---|
| RegistrationBehavior |
A RegistrationBehavior is used by numerous registries for the
purpose of specifying the required behavior when registering an artifact.
|
| SimpleMapIndex.IndexCalculator.CalculatorState |
The CalculatorState identifies the method used by the calculator to
calculate the cost of a key or a value type.
|
| Exception | Description |
|---|---|
| AssertionException |
An AssertionException is thrown when an assertion fails.
|
| FilterBuildingException |
FilterBuildingException is the RuntimeException thrown by the
QueryHelper when building a Filter. |
| MapNotFoundException |
An exception to indicate that a required map does not exist.
|
| ScriptException |
Represents an exception of some sort has occurred while loading or
executing scripts.
|
| WrapperException |
A WrapperException wraps a Throwable object as a RuntimeException.
|