All Classes

Class	Description
AbstractCollectable<T,R,O extends AbstractOrchestration<T,?>>	A base implementation of a Task.Collectable and Task.Completable.
AbstractCollector<T,R>	An abstract Task.Collector.
AbstractExecutorBuilder<T>	Base ParameterizedBuilder fpr named executors.
AbstractExecutorProcessor<T extends ParameterizedBuilder<NamedExecutorService>>	Base class for ElementProcessors producing NamedExecutorService instances.
AbstractExecutorWithFactoryBuilder<T>	Base ParameterizedBuilder for named executors that support thread factories.
AbstractOrchestration<T,C extends TaskExecutorService>	A base implementation of a Task.Orchestration.
AbstractTaskCoordinator<T>	A base implementation of a Task.Coordinator.
AnyFutureSubscriber<T>	A FutureSubscriber which notifies a monitor object when the task completes or fails.
AsyncAtomicBoolean	A boolean value that may be updated atomically.
AsyncAtomicInteger	A int value that may be updated atomically.
AsyncAtomicLong	A long value that may be updated atomically.
AsyncAtomicMarkableReference<V>	An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.
AsyncAtomicReference<V>	An object reference that may be updated atomically.
AsyncAtomicStampedReference<V>	An AtomicStampedReference maintains an object reference along with an integer "stamp", that can be updated atomically.
AsyncLocalAtomicBoolean	Local implementation of AsyncAtomicBoolean interface, that simply wraps java.util.concurrent.atomic.AtomicBoolean instance and returns an already completed future from each method.
AsyncLocalAtomicInteger	Local implementation of AsyncAtomicInteger interface, that simply wraps java.util.concurrent.atomic.AtomicInteger instance and returns an already completed future from each method.
AsyncLocalAtomicLong	Local implementation of AsyncAtomicLong interface, that simply wraps java.util.concurrent.atomic.AtomicLong instance and returns an already completed future from each method.
AsyncLocalAtomicMarkableReference<V>	Local implementation of AsyncAtomicMarkableReference interface, that simply wraps java.util.concurrent.atomic.AtomicMarkableReference instance and returns an already completed future from each method.
AsyncLocalAtomicReference<V>	Local implementation of AsyncAtomicReference interface, that simply wraps java.util.concurrent.atomic.AtomicReference instance and returns an already completed future from each method.
AsyncLocalAtomicStampedReference<V>	Local implementation of AsyncAtomicStampedReference interface, that simply wraps java.util.concurrent.atomic.AtomicStampedReference instance and returns an already completed future from each method.
AsyncRemoteAtomicBoolean	The remote implementation of AsyncAtomicBoolean, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicInteger	The remote implementation of AsyncAtomicInteger, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicLong	The remote implementation of AsyncAtomicLong, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicMarkableReference<V>	The remote implementation of AsyncAtomicMarkableReference, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicReference<V>	The remote implementation of AsyncAtomicReference, backed by a Coherence NamedMap entry.
AsyncRemoteAtomicStampedReference<V>	The remote implementation of AsyncAtomicStampedReference, backed by a Coherence NamedMap entry.
AtomicBoolean	A boolean value that may be updated atomically.
AtomicBoolean.Serializer	POF serializer implementation.
AtomicEnum<T extends Enum<T>>	An Enum value that may be updated atomically.
AtomicInteger	An int value that may be updated atomically.
AtomicInteger.Serializer	POF serializer implementation.
AtomicLong	A long value that may be updated atomically.
AtomicLong.Serializer	POF serializer implementation.
AtomicMarkableReference<V>	An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.
AtomicMarkableReference.Serializer<V>	POF serializer implementation.
AtomicReference<V>	An object reference that may be updated atomically.
AtomicReference.Serializer<V>	POF serializer implementation.
Atomics	Factory methods for various atomic value implementations.
Atomics.SerializableAtomicMarkableReference<V>	Extension to AtomicMarkableReference to allow Java serialization.
Atomics.SerializableAtomicStampedReference<V>	Extension to AtomicStampedReference to allow Java serialization.
AtomicStampedReference<V>	An AtomicStampedReference maintains an object reference along with an integer "stamp", that can be updated atomically.
AtomicStampedReference.Serializer<V>	POF serializer implementation.
BiPredicates	Helper methods for Remote.BiPredicates.
BiPredicates.AllResultsBiPredicate<T>	A Remote.BiPredicate that is satisfied only when all provided results satisfy another Remote.Predicate.
BiPredicates.AnyResultBiPredicate<T>	A Remote.BiPredicate that is satisfied when one or more of the provided results satisfies another Remote.Predicate.
BiPredicates.NeverBiPredicate	A BiPredicates.NeverBiPredicate returns false for all values provided to the BiPredicate.test(Object, Object) method.
CachedBuilder	A ParameterizedBuilder for constructing a NamedExecutorService wrapper that will construct a cached thread pool.
CachedProcessor	An ElementProcessor for cached elements.
CallableTask<T>	A Task that calls a Callable.
Cause	An enumeration to represent the possible causes of backing map events.
Cleaner	This Cleaner is triggered by members leaving the service or partitions arriving at this member, and is used to release locks and semaphore permits held by the departed members.
ClusteredAssignment	Represents the state of a Task assignment to a registered Executor.
ClusteredAssignment.AssignmentProcessor	An InvocableMap.EntryProcessor which updates an assignment due to an assignment ExecutionPlan.Action.
ClusteredAssignment.SetStateProcessor	An InvocableMap.EntryProcessor to compare and set the state of a ClusteredAssignment, returning the previous state.
ClusteredAssignment.State	The current state of the assignment.
ClusteredExecutorInfo	A Coherence-based implementation of a TaskExecutorService.ExecutorInfo.
ClusteredExecutorInfo.ClosingContinuation	A ComposableContinuation to close a ClusteredExecutorInfo, including cleaning up assigned Tasks.
ClusteredExecutorInfo.ClosingGracefullyContinuation	A ComposableContinuation to gracefully close a ClusteredExecutorInfo, allowing already assigned Tasks to complete.
ClusteredExecutorInfo.JoiningContinuation	A ComposableContinuation to commence orchestrating a new Executor with existing Tasks.
ClusteredExecutorInfo.RemoveContinuation	A ComposableContinuation to remove a ClusteredExecutorInfo.
ClusteredExecutorInfo.SetStateProcessor	An InvocableMap.EntryProcessor to compare and set the state of a ClusteredExecutorInfo, returning the previous state.
ClusteredExecutorInfo.TouchProcessor	An InvocableMap.EntryProcessor to update the last update timestamp of a ClusteredExecutorInfo.
ClusteredExecutorInfo.TouchRunnable	A Runnable to asynchronously touch.
ClusteredExecutorInfo.UpdateInfoProcessor	An InvocableMap.EntryProcessor to update the state of an TaskExecutorService.ExecutorInfo.
ClusteredExecutorInfo.UpdateInfoRunnable	A Runnable to asynchronously update the state of ClusteredExecutorInfo using the information based on the current Runtime.
ClusteredExecutorService	An Oracle Coherence based TaskExecutorService.
ClusteredExecutorService.CESRunnableFuture<V>	CESRunnableFuture is a holder for the Callable or Runnable which will be executed by ClusteredExecutorService.execute(Remote.Runnable).
ClusteredExecutorService.State	Enumeration representing possible state transitions of the ClusteredExecutorService.
ClusteredOrchestration<T>	A clustered implementation of a Task.Orchestration.
ClusteredProperties	A clustered implementation of a Task.Properties.
ClusteredProperties.PropertyKey	Property key.
ClusteredProperties.PropertyValue	Property value.
ClusteredRegistration	A cluster-based implementation of an TaskExecutorService.Registration.
ClusteredTaskCoordinator<T>	An implementation of a Task.Coordinator for Coherence-based implementation.
ClusteredTaskInterceptor	A ClusteredTaskManager event interceptor that orders the incoming tasks and put them in pending state when the orchestrated tasks reaches given capacity.
ClusteredTaskInterceptor.SequenceComparator	Comparator used to compare sequence number.
ClusteredTaskInterceptor.SetTaskStateProcessor	An InvocableMap.EntryProcessor to compare and set the state of a ClusteredTaskManager, returning the previous state.
ClusteredTaskManager<T,A,R>	Manages the definition and current state of an individual Task being orchestrated by an TaskExecutorService.
ClusteredTaskManager.ChainedProcessor	A ClusteredTaskManager.ChainedProcessor executes zero or more contained InvocableMap.EntryProcessors in sequence against a single InvocableMap.Entry as a single transaction.
ClusteredTaskManager.NotifyExecutionStrategyProcessor	An InvocableMap.EntryProcessor to notify the Task that an event has occurred which requires the ExecutionStrategy to be re-evaluated.
ClusteredTaskManager.OptimizeExecutionPlanProcessor	An InvocableMap.EntryProcessor to optimize the ExecutionPlan for a Task.
ClusteredTaskManager.SetActionProcessor	An InvocableMap.EntryProcessor to compare and set the action of a ExecutionPlan for a given Executor.
ClusteredTaskManager.State	The state of the ClusteredTaskManager.
ClusteredTaskManager.TerminateProcessor	An InvocableMap.EntryProcessor to terminate a running Task.
ClusteredTaskManager.UpdateCollectedResultProcessor<T>	An PortableAbstractProcessor to update the collected result for a Task.
ClusteredTaskManager.UpdateContributedResultProcessor	An InvocableMap.EntryProcessor to update a contributed Result for a specific Executor, returning true if the update was successful, false otherwise.
ClusteredTaskManager.UpdateExecutionPlanProcessor	An InvocableMap.EntryProcessor to update the ExecutionPlan for a Task after the ExecutionStrategy has been evaluated.
ClusterMember	An TaskExecutorService.Registration.Option specifying whether an Executor is running on a Coherence cluster member.
ClusterMemberAware	A ClusterMemberAware object is aware of its cluster Member wishes to receive Member lifecycle events.
ComposableContinuation	This extension allows composition of Continuations.
ConcurrentConfiguration	A simple holder for the parsing result of an coherence-concurrent configuration artifacts.
ConcurrentServicesSessionConfiguration
ConcurrentServicesSessionConfiguration.ConcurrentServicesSessionProvider	The custom Atomics session provider.
ConditionalCollector<T,A,R>	A Task.Collector that conditionally collects values based on the available result.
ContinuationService<T>	A service for tracking, composing and executing ComposableContinuations.
Count	A qualifier annotation used when injecting Coherence resource to specify the latch count.
Count.Literal	An annotation literal for the Count annotation.
CountDownLatch
CountDownLatchProducer	CDI producers for LocalCountDownLatch and RemoteCountDownLatch instances.
CronPattern	A UNIX crontab-like pattern is a string split in five space separated parts.
CronPattern.ValueParser	Definition for a value parser.
CronTask<T>	A Task that can run repeatedly at scheduled time, like a crontab job.
Debugging	An Task.Option to turn on the Debugging of a Task.
Description	An TaskExecutorService.Registration.Option to specify the Description of a registered ExecutorService.
ExclusiveLockHolder	A data structure that encapsulates server-side exclusive locking logic.
ExclusiveLockHolder.RemoveLocks	An EntryProcessor that will remove locks for the provided member ID, or all the locks for the members that are not in the cluster any longer (if the specified member ID is null).
ExecutionPlan	Defines proposed ExecutionPlan.Actions for assigning a Task to zero or more Executors for execution.
ExecutionPlan.Action	A proposed ExecutionPlan.Action for an Executor.
ExecutionStrategy	Analyzes current runtime information to define an ExecutionPlan for executing a Task with available Executors.
ExecutionStrategy.EvaluationRationale	A rationale for evaluating an ExecutionStrategy.
ExecutionStrategyBuilder	A builder of ExecutionStrategys.
ExecutorMBean	ExecutorMBean provides a monitor interface for the Executor statistics.
ExecutorTrace	Utility class used to trace executor processors, subscribers, and tasks.
FilteringIterable<T>	An Iterable that filters elements produced by another Iterable based on a specified Remote.Predicate.
FilteringIterator<T>	A FilteringIterator that filters elements in another Iterator based on a specified Remote.Predicate.
FixedBuilder	A ParameterizedBuilder for constructing a NamedExecutorService wrapper that will construct a fixed thread pool executor.
FixedProcessor	An ElementProcessor for fixed elements.
FutureSubscriber<T>	A Task.Subscriber that also implements Future.
LatchCounter	A data structure that holds state related to countdown latch.
Latches	Factory methods for various distributed countdown latch implementations.
Leased	A Leased object is one that supports tracking of last use and automated cleanup upon expiry.
LifecycleEventInterceptor	A LifecycleEvent interceptor to automatically activate and deactivate a local ExecutorService for executing tasks.
LiveObject	A LiveObject is a Cache Entry Value that responds to Coherence Cache Events occurring on itself.
LiveObjectEventInterceptor	The LiveObjectEventInterceptor is the EventInterceptor that forwards Events to objects implements LiveObject.
LiveObjectEventInterceptor.ExpiredProcessor	An InvocableMap.EntryProcessor to notify a Leased that it has expired.
LiveObjectEventInterceptor.MemberAwareProcessor	An InvocableMap.EntryProcessor to notify a ClusterMemberAware of a MemberEvent.
LocalAtomicBoolean	Local implementation of AtomicBoolean interface, that simply wraps java.util.concurrent.atomic.AtomicBoolean instance.
LocalAtomicInteger	Local implementation of AtomicInteger interface, that simply wraps java.util.concurrent.atomic.AtomicInteger instance.
LocalAtomicLong	Local implementation of AtomicLong interface, that simply wraps java.util.concurrent.atomic.AtomicLong instance.
LocalAtomicMarkableReference<V>	Local implementation of AtomicMarkableReference interface, that simply wraps java.util.concurrent.atomic.AtomicMarkableReference instance.
LocalAtomicReference<V>	Local implementation of AtomicReference interface, that simply wraps java.util.concurrent.atomic.AtomicReference instance.
LocalAtomicStampedReference<V>	Local implementation of AtomicStampedReference interface, that simply wraps java.util.concurrent.atomic.AtomicStampedReference instance.
LocalCountDownLatch	Local implementation of CountDownLatch interface, that simply wraps java.util.concurrent.CountDownLatch instance.
LocalOnlyProcessor	An InvocableMap.EntryProcessor that invokes another InvocableMap.EntryProcessor only on Map.Entrys that are located in the process that created the LocalOnlyProcessor.
LocalSemaphore	Local implementation of Semaphore interface, that simply wraps java.util.concurrent.Semaphore instance.
LockOwner	The identity of a lock owner, represented by the UID of the member, and the ID of a thread holding or attempting to acquire the lock.
Locks	Factory methods for various local and remote lock implementations.
Member	An TaskExecutorService.Registration.Option defining a Coherence Member.
MutableExecutionPlan	A mutable implementation of ExecutionPlan.
Name	An TaskExecutorService.Registration.Option to specify the Name of a registered ExecutorService.
NamedExecutorService	A holder for a named ExecutorService.
NamespaceHandler	NamespaceHandler for processing coherence-concurrent-related artifacts defined in a Coherence configuration file.
OptionsByType<T>	A mutable collection of zero or more values, typically called an options, internally arranged as a map, keyed by the concrete type of each option in the collection.
OptionsByType.Default	Defines how an OptionsByType collection may automatically determine a suitable default value for a specific class of option at runtime when the said option does not exist in an OptionsByType collection.
OptionsByType.EmptyOptionsByType<T>	An optimized OptionsByType implementation for representing empty OptionsByType.
PermitAcquirer	The identity of a acquirer, represented by the UID of the member, and the ID of a thread holding or attempting to acquire permit.
Permits	A qualifier annotation used when injecting Coherence resource to specify the permits count.
Permits.Literal	An annotation literal for the Permits annotation.
PortableAbstractProcessor	A portable AbstractProcessor. a convenience interface for implementations having no properties to serialize.
PortablePredicate<T>	Represents a portable Remote.Predicate (boolean-valued function) with a single argument; a convenience interface for an implementation with no properties that require serialization.
Predicates	Helper methods for Remote.Predicates.
Predicates.AlwaysPredicate	An Predicates.AlwaysPredicate returns true for any value provided to the Predicate.test(Object) method.
Predicates.EqualToPredicate<T>	A Remote.Predicate to compare a value using Object.equals(Object).
Predicates.IsValuePredicate<T>	An Predicates.IsValuePredicate returns true when a provided Result.isValue().
Predicates.NegatePredicate<T>	A Remote.Predicate that negates the result of another Remote.Predicate.
Predicates.NeverPredicate	An Predicates.NeverPredicate returns false for any value provided to the Predicate.test(Object) method.
Predicates.NullValuePredicate	An Predicates.NullValuePredicate returns true for any value provided to the Predicate.test(Object) method that is null.
Predicates.OptionPredicate	A Remote.Predicate to determine if an TaskExecutorService.ExecutorInfo has a specific TaskExecutorService.Registration.Option.
Predicates.RolePredicate	A Remote.Predicate for matching the name of a Role.
Predicates.ThrowablePredicate<T>	An Predicates.ThrowablePredicate returns true when a provided Result.isThrowable().
ReadWriteLockHolder	A data structure that encapsulates server-side read/write locking logic.
ReadWriteLockHolder.RemoveLocks	An EntryProcessor that will remove locks for the provided member ID, or all the locks for the members that are not in the cluster any longer (if the specified member ID is null).
RecordingSubscriber<T>	A Task.Subscriber that records iteration with a Task.Coordinator.
RecoveringTask	A Task that runs for at least a specified Duration, returning the resuming / recovering status when completed.
RemoteAtomicBoolean	The remote implementation of AtomicBoolean, backed by a Coherence NamedMap entry.
RemoteAtomicInteger	The remote implementation of AtomicInteger, backed by a Coherence NamedMap entry.
RemoteAtomicLong	The remote implementation of AtomicLong, backed by a Coherence NamedMap entry.
RemoteAtomicMarkableReference<V>	The remote implementation of AtomicMarkableReference, backed by a Coherence NamedMap entry.
RemoteAtomicReference<V>	The remote implementation of AtomicReference, backed by a Coherence NamedMap entry.
RemoteAtomicStampedReference<V>	The remote implementation of AtomicStampedReference, backed by a Coherence NamedMap entry.
RemoteCountDownLatch	A distributed count down latch with the same basic behavior and semantics as the Java CountDownLatch class, but uses the NamedCache to support for synchronization aid that allows one or more threads across multiple cluster members to wait until a set of operations being performed in other threads/members completes.
RemoteExecutor	A RemoteExecutor allows submitting and/or scheduling runnables and callables for execution within a Coherence cluster.
RemoteExecutorProducer	CDI producers for RemoteExecutor
RemoteLock	A reentrant mutual exclusion distributed Lock with the same basic behavior and semantics as the implicit monitor lock accessed using synchronized methods and statements, and the ReentrantLock class, but with support for access synchronization across multiple cluster members.
RemoteReadWriteLock	An implementation of ReadWriteLock supporting similar semantics to ReentrantReadWriteLock, but with support for access synchronization across multiple cluster members.
RemoteReadWriteLock.ReadLock	The lock returned by method RemoteReadWriteLock.readLock().
RemoteReadWriteLock.WriteLock	The lock returned by method RemoteReadWriteLock.writeLock().
RemoteSemaphore	A distributed counting semaphore.
Result<T>	An immutable container representing an intermediate or final result produced by executing a Task, typically by an individual Executor, including no result, a specific value or a Throwable.
Role	An TaskExecutorService.Registration.Option to specify the Role of an Executor when it is registered.
RunnableTask	A Task that calls a Runnable.
RunnableWithResultTask<T>	A Task that calls a runnable.
ScheduledCallableTask<T>	A Task that executes a Callable at scheduled time.
ScheduledRunnableTask	A Task that calls a Runnable at scheduled time.
Semaphore
SemaphoreProducer	CDI producer for LocalSemaphore and RemoteSemaphore instances.
Semaphores	Factory methods for local and remote semaphore implementations.
SemaphoreStatus	A data structure that encapsulates server-side semaphore logic.
SemaphoreStatus.RemovePermits	An EntryProcessor that will remove acquired permits for the provided member ID, or all the permits for the members that are not in the cluster any longer.
SingleBuilder	A ParameterizedBuilder for constructing a NamedExecutorService wrapper that will construct a fixed thread pool executor.
SingleProcessor	An ElementProcessor for single elements.
StandardExecutionStrategy	An ExecutionStrategy that creates ExecutionPlans for executing a Task on a number of available Executors that satisfy a specified Remote.Predicate.
Storage	An TaskExecutorService.Registration.Option to specify whether an Executor is running on a storage enabled Coherence server.
SystemOutSubscriber<T>	A Task.Subscriber that logs interactions to the System.out.
Task<T>	A task that may take a long time to execute, may be executed by multiple Executors, may generate intermediate results, and may yield for later execution.
Task.Collectable<T,R>	Provides the mechanism to submit, orchestrate and collect results from a Task defined as part of an Task.Orchestration, including the creation of a Task.Coordinator to subscribe to results, manage and interact with an orchestrated Task.
Task.Collector<T,A,R>	A mutable reduction operation that accumulates results into a mutable result container, optionally transforming the accumulated result into a final representation after all results have been processed.
Task.Completable<T,R>	A Task.Collectable that supports performing operations when a Task orchestration is complete.
Task.CompletionRunnable<T>	A runnable to be called upon task completion.
Task.Context<T>	Provides contextual information for a Task as it is executed, including the ability to access and update intermediate results for the Executor executing the said Task.
Task.Coordinator<T>	A publisher of collected Task results that additionally permits coordination of the submitted Task.
Task.Option	An option for configuring Task orchestration.
Task.Orchestration<T>	Defines information concerning the orchestration of a Task across a set of Executors for a given TaskExecutorService.
Task.Properties	Define an interface to allow states sharing between the task executors.
Task.SubscribedOrchestration<T>	Defines the subset of Task.Orchestration methods which are permitted after Task.SubscribedOrchestration.subscribe(Subscriber) is called.
Task.Subscriber<T>	A receiver of items produced by a Task.Coordinator.
Task.Subscription<T>	Represents a subscription a Task.Subscriber has made to a Task.Coordinator, allowing control and termination of the Task.Subscription.
Task.Yield	An exception signalling the execution of a Task by an Executor is to be suspended and resumed at some later point in time, typically by the same Executor.
TaskCollectors	Static helper methods to create Task.Collectors.
TaskCollectors.CountCollector<T>	A Task.Collector that counts the number of results are present.
TaskCollectors.FirstOfCollector<T>	A Task.Collector to collect any (the first provided) available result.
TaskCollectors.LastOfCollector<T>	A Task.Collector that collects and returns the last contributed result.
TaskCollectors.ListOfCollector<T>	A Task.Collector that collects and returns all contributed results that are values as a List.
TaskCollectors.SetOfCollector<T>	A Task.Collector that collects and returns all contributed results that are values as a Set.
TaskExecutorService	An ExecutorService that orchestrates execution of submitted executables, for example Runnables, Callables and Tasks, across zero or more registered ExecutorServices.
TaskExecutorService.ExecutorInfo	Provides access to the currently available information for a registered ExecutorService.
TaskExecutorService.ExecutorInfo.State	The state of an ExecutorService.
TaskExecutorService.Registration	Provides registration information about an ExecutorService registration.
TaskExecutorService.Registration.Option	An TaskExecutorService.Registration.Option for an ExecutorService when registered.
TaskProperties	A basic implementation of a Task.Properties.
ThreadFactoryBuilder	A ParameterizedBuilder for constructing a ThreadFactory.
ThreadFactoryProcessor	An ElementProcessor for thread-factory elements.
ValueTask<T>	A Task that provides a constant value as a result.
WorkStealingBuilder	A ParameterizedBuilder for constructing a NamedExecutorService wrapper that will construct a work stealing pool executor.
WorkStealingProcessor	An ElementProcessor for work-stealing elements.