java.lang.Object
- java.util.concurrent.CompletableFuture<T>
- - io.github.futures4j.ExtendedFuture<T>

Type Parameters:

T - the result type returned by this ExtendedFuture

All Implemented Interfaces:

CompletionStage<T>, Future<T>

Direct Known Subclasses:

Futures.CombinedFuture
```
public class ExtendedFuture<T>
extends CompletableFuture<T>
```
An enhanced version of CompletableFuture providing additional features:
- Interruptible Tasks: Allows task thread interruption via cancel(true). This behavior is controllable using asNonInterruptible() and withInterruptibleStages(boolean).
- Dependent Stage Cancellation: Enables dependent stages to cancel preceding stages, controllable via asCancellableByDependents(boolean).
- Checked Exceptions: Supports running tasks that throw checked exceptions, e.g., runAsync(ThrowingRunnable).
- Read-Only Views: Allows creating read-only views of a future using asReadOnly(ReadOnlyMode).
- Default Executor: Enables defining a default executor for this future and all subsequent stages via withDefaultExecutor(Executor) or ExtendedFuture.Builder.withDefaultExecutor(Executor).
- Convenience Methods: Offers additional methods such as completeWith(CompletableFuture), isSuccess(), isFailed(), getNowOptional(), getNowOrFallback(Object), getOptional(long, TimeUnit), getOrFallback(Object), and getOrFallback(Object, long, TimeUnit).
For more information on issues addressed by this class, refer to the following resources:
- https://stackoverflow.com/questions/25417881/canceling-a-completablefuture-chain
- https://stackoverflow.com/questions/36727820/cancellation-of-completablefuture-controlled-by-executorservice
- https://stackoverflow.com/questions/62106428/is-there-a-better-way-for-cancelling-a-chain-of-futures-in-java
and:
- https://stackoverflow.com/questions/29013831/how-to-interrupt-underlying-execution-of-completablefuture
- https://nurkiewicz.com/2015/03/completablefuture-cant-be-interrupted.html
- https://blog.tremblay.pro/2017/08/supply-async.html
Author:

Sebastian Thomschke

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`ExtendedFuture.Builder<V>`	A builder for constructing customized `ExtendedFuture` instances with specific configurations.
`static class`	`ExtendedFuture.ReadOnlyMode`	Modes for creating a read-only view of an `ExtendedFuture`.

Nested classes/interfaces inherited from class java.util.concurrent.CompletableFuture
CompletableFuture.AsynchronousCompletionTask

Field Summary

Fields
Modifier and Type	Field	Description
`protected boolean`	`cancellableByDependents`
`protected Collection<Future<?>>`	`cancellablePrecedingStages`
`protected Executor`	`defaultExecutor`
`protected boolean`	`interruptibleStages`

Constructor Summary

Constructors
Constructor Description

ExtendedFuture()
Creates a new ExtendedFuture with default settings.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`ExtendedFuture<@Nullable Void>`	`acceptEither(CompletionStage<? extends T> other, ThrowingConsumer<? super T,?> action)`
`ExtendedFuture<@Nullable Void>`	`acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action)`
`ExtendedFuture<@Nullable Void>`	`acceptEitherAsync(CompletionStage<? extends T> other, ThrowingConsumer<? super T,?> action)`
`ExtendedFuture<@Nullable Void>`	`acceptEitherAsync(CompletionStage<? extends T> other, ThrowingConsumer<? super T,?> action, Executor executor)`
`ExtendedFuture<@Nullable Void>`	`acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action)`
`ExtendedFuture<@Nullable Void>`	`acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action, Executor executor)`
`ExtendedFuture<T>`	`addTo(Futures.Combiner<T> combiner)`	Adds this future to the given `Futures.Combiner`.
`ExtendedFuture<T>`	`addTo(Consumer<Future<T>> consumer)`	Passes this future to the given `Consumer`.
`static ExtendedFuture<@Nullable Void>`	`allOf(CompletableFuture<?>... cfs)`	Returns a new `ExtendedFuture` that completes when all of the given futures complete.
`static ExtendedFuture<@Nullable Object>`	`anyOf(CompletableFuture<?>... cfs)`	Returns a new `ExtendedFuture` that completes when any of the given futures complete.
`<U> ExtendedFuture<U>`	`applyToEither(CompletionStage<? extends T> other, ThrowingFunction<? super T,U,?> fn)`
`<U> ExtendedFuture<U>`	`applyToEither(CompletionStage<? extends T> other, Function<? super T,U> fn)`
`<U> ExtendedFuture<U>`	`applyToEitherAsync(CompletionStage<? extends T> other, ThrowingFunction<? super T,U,?> fn)`
`<U> ExtendedFuture<U>`	`applyToEitherAsync(CompletionStage<? extends T> other, ThrowingFunction<? super T,U,?> fn, Executor executor)`
`<U> ExtendedFuture<U>`	`applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T,U> fn)`
`<U> ExtendedFuture<U>`	`applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T,U> fn, Executor executor)`
`ExtendedFuture<T>`	`asCancellableByDependents(boolean isCancellableByDependents)`	Returns an `ExtendedFuture` that shares the result with this future but allows control over whether cancellation of dependent stages cancels this future.
`ExtendedFuture<T>`	`asNonInterruptible()`	Returns an `ExtendedFuture` that shares the result with this future but ensures that this future cannot be interrupted, i.e., calling `cancel(true)` will not result in a thread interruption.
`ExtendedFuture<T>`	`asReadOnly(ExtendedFuture.ReadOnlyMode readOnlyMode)`	Creates a read-only view of this `ExtendedFuture`.
`static <V> ExtendedFuture.Builder<V>`	`builder(Class<V> targetType)`	Creates a new `ExtendedFuture.Builder` for constructing an `ExtendedFuture`.
`boolean`	`cancel(boolean mayInterruptIfRunning)`
`boolean`	`complete(T value)`	Completes this future with the given value if not already completed.
`ExtendedFuture<T>`	`completeAsync(ThrowingSupplier<? extends T,?> supplier)`	Completes this future with the result of the given throwing supplier function, running it asynchronously using the default executor.
`ExtendedFuture<T>`	`completeAsync(ThrowingSupplier<? extends T,?> supplier, Executor executor)`	Completes this future with the result of the given throwing supplier function, running it asynchronously using the specified executor.
`ExtendedFuture<T>`	`completeAsync(Supplier<? extends T> supplier)`	Completes this future with the result of the given supplier function, running it asynchronously using the default executor.
`ExtendedFuture<T>`	`completeAsync(Supplier<? extends T> supplier, Executor executor)`	Completes this future with the result of the given supplier function, running it asynchronously using the specified executor.
`static <V> ExtendedFuture<V>`	`completedFuture(V value)`	Returns a completed `ExtendedFuture` with the given value.
`boolean`	`completeExceptionally(Throwable ex)`	Completes this future exceptionally with the given exception if not already completed.
`ExtendedFuture<T>`	`completeOnTimeout(T value, long timeout, TimeUnit unit)`
`ExtendedFuture<T>`	`completeWith(CompletableFuture<? extends T> future)`	Completes this `ExtendedFuture` when the provided `CompletableFuture` finishes, with either its result or its exception.
`ExtendedFuture<T>`	`copy()`
`Executor`	`defaultExecutor()`
`ExtendedFuture<T>`	`exceptionally(ThrowingFunction<Throwable,? extends T,?> fn)`
`ExtendedFuture<T>`	`exceptionally(Function<Throwable,? extends T> fn)`
`ExtendedFuture<T>`	`exceptionallyAsync(ThrowingFunction<Throwable,? extends T,?> fn)`
`ExtendedFuture<T>`	`exceptionallyAsync(ThrowingFunction<Throwable,? extends T,?> fn, Executor executor)`
`ExtendedFuture<T>`	`exceptionallyAsync(Function<Throwable,? extends T> fn)`	This method emulates the `CompletableFuture`'s exceptionallyAsync method introduced in Java 12.
`ExtendedFuture<T>`	`exceptionallyAsync(Function<Throwable,? extends T> fn, Executor executor)`	This method emulates the `CompletableFuture`'s exceptionallyAsync method introduced in Java 12.
`ExtendedFuture<T>`	`exceptionallyCompose(ThrowingFunction<Throwable,? extends CompletionStage<T>,?> fn)`
`ExtendedFuture<T>`	`exceptionallyCompose(Function<Throwable,? extends CompletionStage<T>> fn)`	This method emulates the `CompletableFuture`'s exceptionallyCompose method introduced in Java 12.
`ExtendedFuture<T>`	`exceptionallyComposeAsync(ThrowingFunction<Throwable,? extends CompletionStage<T>,?> fn)`
`ExtendedFuture<T>`	`exceptionallyComposeAsync(ThrowingFunction<Throwable,? extends CompletionStage<T>,?> fn, Executor executor)`
`ExtendedFuture<T>`	`exceptionallyComposeAsync(Function<Throwable,? extends CompletionStage<T>> fn)`	This method emulates the `CompletableFuture`'s exceptionallyComposeAsync method introduced in Java 12.
`ExtendedFuture<T>`	`exceptionallyComposeAsync(Function<Throwable,? extends CompletionStage<T>> fn, Executor executor)`	This method emulates the `CompletableFuture`'s exceptionallyComposeAsync method introduced in Java 12.
`Throwable`	`exceptionNow()`	This method emulates the `CompletableFuture`'s exceptionNow method introduced in Java 19.
`static <V> ExtendedFuture<V>`	`failedFuture(Throwable ex)`	Returns a completed `ExtendedFuture` that has completed exceptionally with the given exception.
`ExtendedFuture<T>`	`forwardCancellation(@Nullable Future<?> to)`	Propagates the cancellation of this `ExtendedFuture` to another `Future`.
`ExtendedFuture<T>`	`forwardCancellation(Future<?> @Nullable ... to)`	Propagates the cancellation of this `ExtendedFuture` to other `Future`s.
`ExtendedFuture<T>`	`forwardCancellationTo(@Nullable Collection<? extends @Nullable Future<?>> to)`	Propagates the cancellation of this `ExtendedFuture` to other `Future`s.
`static <V> ExtendedFuture<V>`	`from(CompletableFuture<V> source)`	Wraps a given `CompletableFuture` into an `ExtendedFuture`.
`Optional<T>`	`getNowOptional()`	Returns the result of this future if it is already completed wrapped in an `Optional`, or an empty `Optional` if the future is incomplete, cancelled or failed.
`T`	`getNowOrComputeFallback(BiFunction<Future<T>,@Nullable Exception,T> fallbackComputer)`	Returns the result of this future if it is already completed, or the value provided by `fallbackComputer` if the future is incomplete, cancelled or failed.
`T`	`getNowOrComputeFallback(Function<@Nullable Exception,T> fallbackComputer)`	Returns the result of this future if it is already completed, or the value provided by `fallbackComputer` if the future is incomplete, cancelled or failed.
`T`	`getNowOrFallback(T fallback)`	Returns the result of this future if it is already completed, or the specified `fallback` if the future is incomplete, cancelled or failed.
`Optional<T>`	`getOptional()`	Attempts to retrieve the result this future within the specified timeout.
`Optional<T>`	`getOptional(long timeout, TimeUnit unit)`	Attempts to retrieve the result this future within the specified timeout.
`T`	`getOrComputeFallback(BiFunction<Future<T>,@Nullable Exception,T> fallbackComputer)`	Attempts to retrieve the result of this future.
`T`	`getOrComputeFallback(BiFunction<Future<T>,@Nullable Exception,T> fallbackComputer, long timeout, TimeUnit unit)`	Attempts to retrieve the result of this future within the specified timeout.
`T`	`getOrComputeFallback(Function<@Nullable Exception,T> fallbackComputer)`	Attempts to retrieve the result of this future.
`T`	`getOrComputeFallback(Function<@Nullable Exception,T> fallbackComputer, long timeout, TimeUnit unit)`	Attempts to retrieve the result of this future within the specified timeout.
`T`	`getOrFallback(T fallback)`	Attempts to retrieve the result of this future.
`T`	`getOrFallback(T fallback, long timeout, TimeUnit unit)`	Attempts to retrieve the result of this future within the specified timeout.
`<U> ExtendedFuture<U>`	`handle(BiFunction<? super T,@Nullable Throwable,? extends U> fn)`
`<U> ExtendedFuture<U>`	`handleAsync(BiFunction<? super T,@Nullable Throwable,? extends U> fn)`
`<U> ExtendedFuture<U>`	`handleAsync(BiFunction<? super T,@Nullable Throwable,? extends U> fn, Executor executor)`
`boolean`	`isCancellableByDependents()`	Returns `true` if this future is cancellable by its dependent stages.
`boolean`	`isFailed()`	Returns `true` if this `ExtendedFuture` was completed exceptionally, excluding cancellation.
`boolean`	`isIncomplete()`	Returns `true` if this future is incomplete.
`boolean`	`isInterruptible()`	Returns `true` if this future is interruptible, i.e., `cancel(true)` will result in thread interruption.
`boolean`	`isInterruptibleStages()`	Returns `true` if new stages created from this future are interruptible.
`boolean`	`isReadOnly()`	Returns `true` if this future cannot be completed programmatically through methods like `cancel(boolean)` or `complete(Object)`.
`boolean`	`isSuccess()`	Returns `true` if this future completed normally.
`<V> ExtendedFuture<V>`	`newIncompleteFuture()`
`T`	`resultNow()`	This method emulates the `CompletableFuture`'s resultNow method introduced in Java 19.
`ExtendedFuture<@Nullable Void>`	`runAfterBoth(CompletionStage<?> other, ThrowingRunnable<?> action)`
`ExtendedFuture<@Nullable Void>`	`runAfterBoth(CompletionStage<?> other, Runnable action)`
`ExtendedFuture<@Nullable Void>`	`runAfterBothAsync(CompletionStage<?> other, ThrowingRunnable<?> action)`
`ExtendedFuture<@Nullable Void>`	`runAfterBothAsync(CompletionStage<?> other, ThrowingRunnable<?> action, Executor executor)`
`ExtendedFuture<@Nullable Void>`	`runAfterBothAsync(CompletionStage<?> other, Runnable action)`
`ExtendedFuture<@Nullable Void>`	`runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor)`
`ExtendedFuture<@Nullable Void>`	`runAfterEither(CompletionStage<?> other, ThrowingRunnable<?> action)`
`ExtendedFuture<@Nullable Void>`	`runAfterEither(CompletionStage<?> other, Runnable action)`
`ExtendedFuture<@Nullable Void>`	`runAfterEitherAsync(CompletionStage<?> other, ThrowingRunnable<?> action)`
`ExtendedFuture<@Nullable Void>`	`runAfterEitherAsync(CompletionStage<?> other, ThrowingRunnable<?> action, Executor executor)`
`ExtendedFuture<@Nullable Void>`	`runAfterEitherAsync(CompletionStage<?> other, Runnable action)`
`ExtendedFuture<@Nullable Void>`	`runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor)`
`static ExtendedFuture<@Nullable Void>`	`runAsync(ThrowingRunnable<?> runnable)`	Returns an `ExtendedFuture` that runs the given throwing runnable asynchronously.
`static ExtendedFuture<@Nullable Void>`	`runAsync(ThrowingRunnable<?> runnable, Executor executor)`	Returns an `ExtendedFuture` that runs the given throwing runnable asynchronously using the provided executor.
`static ExtendedFuture<@Nullable Void>`	`runAsync(Runnable runnable)`	Returns an `ExtendedFuture` that runs the given runnable asynchronously.
`static ExtendedFuture<@Nullable Void>`	`runAsync(Runnable runnable, Executor executor)`	Returns an `ExtendedFuture` that runs the given runnable asynchronously using the provided executor.
`static ExtendedFuture<@Nullable Void>`	`runAsyncWithDefaultExecutor(ThrowingRunnable<?> runnable, Executor defaultExecutor)`	Returns an `ExtendedFuture` with a specified default executor that runs the given throwing runnable asynchronously.
`static <V> ExtendedFuture<V>`	`supplyAsync(ThrowingSupplier<V,?> supplier)`	Returns an `ExtendedFuture` that runs the given throwing supplier asynchronously.
`static <V> ExtendedFuture<V>`	`supplyAsync(ThrowingSupplier<V,?> supplier, Executor executor)`	Returns an `ExtendedFuture` that runs the given throwing supplier asynchronously using the provided executor.
`static <V> ExtendedFuture<V>`	`supplyAsync(Supplier<V> supplier)`	Returns an `ExtendedFuture` that runs the given supplier asynchronously.
`static <V> ExtendedFuture<V>`	`supplyAsync(Supplier<V> supplier, Executor executor)`	Returns an `ExtendedFuture` that runs the given supplier asynchronously using the provided executor.
`static <V> ExtendedFuture<V>`	`supplyAsyncWithDefaultExecutor(ThrowingSupplier<V,?> supplier, Executor defaultExecutor)`	Returns an `ExtendedFuture` with a specified default executor that runs the given throwing supplier asynchronously.
`ExtendedFuture<@Nullable Void>`	`thenAccept(ThrowingConsumer<? super T,?> action)`
`ExtendedFuture<@Nullable Void>`	`thenAccept(Consumer<? super T> action)`
`ExtendedFuture<@Nullable Void>`	`thenAcceptAsync(ThrowingConsumer<? super T,?> action)`
`ExtendedFuture<@Nullable Void>`	`thenAcceptAsync(ThrowingConsumer<? super T,?> action, Executor executor)`
`ExtendedFuture<@Nullable Void>`	`thenAcceptAsync(Consumer<? super T> action)`
`ExtendedFuture<@Nullable Void>`	`thenAcceptAsync(Consumer<? super T> action, Executor executor)`
`<U> ExtendedFuture<@Nullable Void>`	`thenAcceptBoth(CompletionStage<? extends U> other, ThrowingBiConsumer<? super T,? super U,?> action)`
`<U> ExtendedFuture<@Nullable Void>`	`thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)`
`<U> ExtendedFuture<@Nullable Void>`	`thenAcceptBothAsync(CompletionStage<? extends U> other, ThrowingBiConsumer<? super T,? super U,?> action)`
`<U> ExtendedFuture<@Nullable Void>`	`thenAcceptBothAsync(CompletionStage<? extends U> other, ThrowingBiConsumer<? super T,? super U,?> action, Executor executor)`
`<U> ExtendedFuture<@Nullable Void>`	`thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)`
`<U> ExtendedFuture<@Nullable Void>`	`thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action, Executor executor)`
`<U> ExtendedFuture<U>`	`thenApply(ThrowingFunction<? super T,? extends U,?> fn)`
`<U> ExtendedFuture<U>`	`thenApply(Function<? super T,? extends U> fn)`
`<U> ExtendedFuture<U>`	`thenApplyAsync(ThrowingFunction<? super T,? extends U,?> fn)`
`<U> ExtendedFuture<U>`	`thenApplyAsync(ThrowingFunction<? super T,? extends U,?> fn, Executor executor)`
`<U> ExtendedFuture<U>`	`thenApplyAsync(Function<? super T,? extends U> fn)`
`<U> ExtendedFuture<U>`	`thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)`
`<U,V> ExtendedFuture<V>`	`thenCombine(CompletionStage<? extends U> other, ThrowingBiFunction<? super T,? super U,? extends V,?> fn)`
`<U,V> ExtendedFuture<V>`	`thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)`
`<U,V> ExtendedFuture<V>`	`thenCombineAsync(CompletionStage<? extends U> other, ThrowingBiFunction<? super T,? super U,? extends V,?> fn)`
`<U,V> ExtendedFuture<V>`	`thenCombineAsync(CompletionStage<? extends U> other, ThrowingBiFunction<? super T,? super U,? extends V,?> fn, Executor executor)`
`<U,V> ExtendedFuture<V>`	`thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)`
`<U,V> ExtendedFuture<V>`	`thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor)`
`<U> ExtendedFuture<U>`	`thenCompose(ThrowingFunction<? super T,? extends CompletionStage<U>,?> fn)`
`<U> ExtendedFuture<U>`	`thenCompose(Function<? super T,? extends CompletionStage<U>> fn)`
`<U> ExtendedFuture<U>`	`thenComposeAsync(ThrowingFunction<? super T,? extends CompletionStage<U>,?> fn)`
`<U> ExtendedFuture<U>`	`thenComposeAsync(ThrowingFunction<? super T,? extends CompletionStage<U>,?> fn, Executor executor)`
`<U> ExtendedFuture<U>`	`thenComposeAsync(Function<? super T,? extends CompletionStage<U>> fn)`
`<U> ExtendedFuture<U>`	`thenComposeAsync(Function<? super T,? extends CompletionStage<U>> fn, Executor executor)`
`ExtendedFuture<@Nullable Void>`	`thenRun(ThrowingRunnable<?> action)`
`ExtendedFuture<@Nullable Void>`	`thenRun(Runnable action)`
`ExtendedFuture<@Nullable Void>`	`thenRunAsync(ThrowingRunnable<?> action)`
`ExtendedFuture<@Nullable Void>`	`thenRunAsync(ThrowingRunnable<?> action, Executor executor)`
`ExtendedFuture<@Nullable Void>`	`thenRunAsync(Runnable action)`
`ExtendedFuture<@Nullable Void>`	`thenRunAsync(Runnable action, Executor executor)`
`ExtendedFuture<T>`	`whenComplete(ThrowingBiConsumer<? super @Nullable T,? super @Nullable Throwable,?> action)`
`ExtendedFuture<T>`	`whenComplete(BiConsumer<? super @Nullable T,? super @Nullable Throwable> action)`
`ExtendedFuture<T>`	`whenCompleteAsync(ThrowingBiConsumer<? super @Nullable T,? super @Nullable Throwable,?> action)`
`ExtendedFuture<T>`	`whenCompleteAsync(ThrowingBiConsumer<? super @Nullable T,? super @Nullable Throwable,?> action, Executor executor)`
`ExtendedFuture<T>`	`whenCompleteAsync(BiConsumer<? super @Nullable T,? super @Nullable Throwable> action)`
`ExtendedFuture<T>`	`whenCompleteAsync(BiConsumer<? super @Nullable T,? super @Nullable Throwable> action, Executor executor)`
`ExtendedFuture<T>`	`withDefaultExecutor(Executor defaultExecutor)`	Returns an `ExtendedFuture` that shares the result with this future, but with the specified `Executor` as the default for asynchronous operations of subsequent stages.
`ExtendedFuture<T>`	`withInterruptibleStages(boolean interruptibleStages)`	Returns an `ExtendedFuture` that shares the result with this future but with the specified behavior for new stages being interruptible or not.

Methods inherited from class java.util.concurrent.CompletableFuture
completedStage, delayedExecutor, delayedExecutor, failedStage, get, get, getNow, getNumberOfDependents, isCancelled, isCompletedExceptionally, isDone, join, minimalCompletionStage, obtrudeException, obtrudeValue, orTimeout, toCompletableFuture, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

cancellablePrecedingStages

protected final Collection<Future<?>> cancellablePrecedingStages

cancellableByDependents

protected final boolean cancellableByDependents

interruptibleStages

protected final boolean interruptibleStages

defaultExecutor

protected final Executor defaultExecutor

Constructor Detail
- ExtendedFuture
```
public ExtendedFuture()
```
  Creates a new ExtendedFuture with default settings.

Method Detail

allOf
```
public static ExtendedFuture<@Nullable Void> allOf(CompletableFuture<?>... cfs)
```
Returns a new ExtendedFuture that completes when all of the given futures complete.

Parameters:

cfs - the array of CompletableFuture instances

Returns:

an ExtendedFuture that completes when all given futures complete

See Also:

CompletableFuture.allOf(CompletableFuture...)

anyOf
```
public static ExtendedFuture<@Nullable Object> anyOf(CompletableFuture<?>... cfs)
```
Returns a new ExtendedFuture that completes when any of the given futures complete.

Parameters:

cfs - the array of CompletableFuture instances

Returns:

an ExtendedFuture that completes when any given future completes

See Also:

CompletableFuture.anyOf(CompletableFuture...)

builder
```
@NonNullByDefault({})
public static <V> ExtendedFuture.Builder<V> builder(Class<V> targetType)
```
Creates a new ExtendedFuture.Builder for constructing an ExtendedFuture.

Type Parameters:

V - the result type of the future

Returns:

a new ExtendedFuture.Builder instance

completedFuture
```
public static <V> ExtendedFuture<V> completedFuture(V value)
```
Returns a completed ExtendedFuture with the given value.

Type Parameters:

V - the result type of the future

Parameters:

value - the value to complete the future with

Returns:

a completed ExtendedFuture

failedFuture
```
public static <V> ExtendedFuture<V> failedFuture(Throwable ex)
```
Returns a completed ExtendedFuture that has completed exceptionally with the given exception.

Type Parameters:

V - the result type of the future

Parameters:

ex - the exception to complete the future with

Returns:

a completed ExtendedFuture that completed exceptionally

from
```
public static <V> ExtendedFuture<V> from(CompletableFuture<V> source)
```
Wraps a given CompletableFuture into an ExtendedFuture. If the given future is already an instance of ExtendedFuture with isCancellableByDependents() set to false, it is returned as-is.

Type Parameters:

V - the result type of the future

Parameters:

source - the CompletableFuture to wrap

Returns:

an ExtendedFuture wrapping the given future

runAsync
```
public static ExtendedFuture<@Nullable Void> runAsync(Runnable runnable)
```
Returns an ExtendedFuture that runs the given runnable asynchronously.

Parameters:

runnable - the Runnable to execute

Returns:

an ExtendedFuture representing the asynchronous computation

runAsync
```
public static ExtendedFuture<@Nullable Void> runAsync(Runnable runnable,
 Executor executor)
```
Returns an ExtendedFuture that runs the given runnable asynchronously using the provided executor.

Parameters:

runnable - the Runnable to execute

executor - the Executor to use for execution

Returns:

an ExtendedFuture representing the asynchronous computation

runAsync
```
public static ExtendedFuture<@Nullable Void> runAsync(ThrowingRunnable<?> runnable)
```
Returns an ExtendedFuture that runs the given throwing runnable asynchronously.

Parameters:

runnable - the ThrowingRunnable to execute

Returns:

an ExtendedFuture representing the asynchronous computation

runAsync
```
public static ExtendedFuture<@Nullable Void> runAsync(ThrowingRunnable<?> runnable,
 Executor executor)
```
Returns an ExtendedFuture that runs the given throwing runnable asynchronously using the provided executor.

Parameters:

runnable - the ThrowingRunnable to execute

executor - the Executor to use for execution

Returns:

an ExtendedFuture representing the asynchronous computation

runAsyncWithDefaultExecutor
```
public static ExtendedFuture<@Nullable Void> runAsyncWithDefaultExecutor(ThrowingRunnable<?> runnable,
 Executor defaultExecutor)
```
Returns an ExtendedFuture with a specified default executor that runs the given throwing runnable asynchronously.

Parameters:

runnable - the ThrowingRunnable to execute

defaultExecutor - the default Executor to use for execution

Returns:

an ExtendedFuture representing the asynchronous computation

supplyAsync
```
public static <V> ExtendedFuture<V> supplyAsync(Supplier<V> supplier)
```
Returns an ExtendedFuture that runs the given supplier asynchronously.

Type Parameters:

V - the result type of the future

Parameters:

supplier - the Supplier to execute

Returns:

an ExtendedFuture representing the asynchronous computation

supplyAsync
```
public static <V> ExtendedFuture<V> supplyAsync(Supplier<V> supplier,
 Executor executor)
```
Returns an ExtendedFuture that runs the given supplier asynchronously using the provided executor.

Type Parameters:

V - the result type of the future

Parameters:

supplier - the Supplier to execute

executor - the Executor to use for execution

Returns:

an ExtendedFuture representing the asynchronous computation

supplyAsync
```
public static <V> ExtendedFuture<V> supplyAsync(ThrowingSupplier<V,?> supplier)
```
Returns an ExtendedFuture that runs the given throwing supplier asynchronously.

Type Parameters:

V - the result type of the future

Parameters:

supplier - the ThrowingSupplier to execute

Returns:

an ExtendedFuture representing the asynchronous computation

supplyAsync
```
public static <V> ExtendedFuture<V> supplyAsync(ThrowingSupplier<V,?> supplier,
 Executor executor)
```
Returns an ExtendedFuture that runs the given throwing supplier asynchronously using the provided executor.

Type Parameters:

V - the result type of the future

Parameters:

supplier - the ThrowingSupplier to execute

executor - the Executor to use for execution

Returns:

an ExtendedFuture representing the asynchronous computation

supplyAsyncWithDefaultExecutor
```
public static <V> ExtendedFuture<V> supplyAsyncWithDefaultExecutor(ThrowingSupplier<V,?> supplier,
 Executor defaultExecutor)
```
Returns an ExtendedFuture with a specified default executor that runs the given throwing supplier asynchronously.

Type Parameters:

V - the result type of the future

Parameters:

supplier - the ThrowingSupplier to execute

defaultExecutor - the default Executor to use for execution

Returns:

an ExtendedFuture representing the asynchronous computation

acceptEither

public ExtendedFuture<@Nullable Void> acceptEither(CompletionStage<? extends T> other,
                                                   Consumer<? super T> action)

Specified by:: acceptEither in interface CompletionStage<T>
Overrides:: acceptEither in class CompletableFuture<T>

acceptEither

public ExtendedFuture<@Nullable Void> acceptEither(CompletionStage<? extends T> other,
                                                   ThrowingConsumer<? super T,?> action)

acceptEitherAsync

public ExtendedFuture<@Nullable Void> acceptEitherAsync(CompletionStage<? extends T> other,
                                                        Consumer<? super T> action)

Specified by:: acceptEitherAsync in interface CompletionStage<T>
Overrides:: acceptEitherAsync in class CompletableFuture<T>

acceptEitherAsync

public ExtendedFuture<@Nullable Void> acceptEitherAsync(CompletionStage<? extends T> other,
                                                        Consumer<? super T> action,
                                                        Executor executor)

Specified by:: acceptEitherAsync in interface CompletionStage<T>
Overrides:: acceptEitherAsync in class CompletableFuture<T>

acceptEitherAsync

public ExtendedFuture<@Nullable Void> acceptEitherAsync(CompletionStage<? extends T> other,
                                                        ThrowingConsumer<? super T,?> action)

acceptEitherAsync

public ExtendedFuture<@Nullable Void> acceptEitherAsync(CompletionStage<? extends T> other,
                                                        ThrowingConsumer<? super T,?> action,
                                                        Executor executor)

addTo
```
public ExtendedFuture<T> addTo(Consumer<Future<T>> consumer)
```
Passes this future to the given Consumer.

Parameters:

consumer - the consumer to which this future is added

Returns:

this ExtendedFuture instance for method chaining

addTo
```
public ExtendedFuture<T> addTo(Futures.Combiner<T> combiner)
```
Adds this future to the given Futures.Combiner.

Parameters:

combiner - the future combiner to which this future is added

Returns:

this ExtendedFuture instance for method chaining

applyToEither

public <U> ExtendedFuture<U> applyToEither(CompletionStage<? extends T> other,
                                           Function<? super T,U> fn)

Specified by:: applyToEither in interface CompletionStage<T>
Overrides:: applyToEither in class CompletableFuture<T>

applyToEither

public <U> ExtendedFuture<U> applyToEither(CompletionStage<? extends T> other,
                                           ThrowingFunction<? super T,U,?> fn)

applyToEitherAsync

public <U> ExtendedFuture<U> applyToEitherAsync(CompletionStage<? extends T> other,
                                                Function<? super T,U> fn)

Specified by:: applyToEitherAsync in interface CompletionStage<T>
Overrides:: applyToEitherAsync in class CompletableFuture<T>

applyToEitherAsync

public <U> ExtendedFuture<U> applyToEitherAsync(CompletionStage<? extends T> other,
                                                Function<? super T,U> fn,
                                                Executor executor)

Specified by:: applyToEitherAsync in interface CompletionStage<T>
Overrides:: applyToEitherAsync in class CompletableFuture<T>

applyToEitherAsync

public <U> ExtendedFuture<U> applyToEitherAsync(CompletionStage<? extends T> other,
                                                ThrowingFunction<? super T,U,?> fn)

applyToEitherAsync

public <U> ExtendedFuture<U> applyToEitherAsync(CompletionStage<? extends T> other,
                                                ThrowingFunction<? super T,U,?> fn,
                                                Executor executor)

asCancellableByDependents
```
public ExtendedFuture<T> asCancellableByDependents(boolean isCancellableByDependents)
```
Returns an ExtendedFuture that shares the result with this future but allows control over whether cancellation of dependent stages cancels this future.
If the requested cancellation behavior matches the current one, this instance is returned. Otherwise, a new ExtendedFuture is created with the updated behavior.
Any newly created dependent stages will inherit this cancellation behavior.

Parameters:

isCancellableByDependents - true if cancellation of a dependent stage should also cancel this future and its preceding stages; false if cancellation of dependent stages should not affect this future.

Returns:

a new ExtendedFuture with the specified cancellation behavior, or this instance if the behavior remains unchanged.

asNonInterruptible
```
public ExtendedFuture<T> asNonInterruptible()
```
Returns an ExtendedFuture that shares the result with this future but ensures that this future cannot be interrupted, i.e., calling cancel(true) will not result in a thread interruption.
If the future is already non-interruptible, this instance is returned.

Returns:

a new ExtendedFuture that is non-interruptible, or this instance if it is already non-interruptible.

asReadOnly
```
public ExtendedFuture<T> asReadOnly(ExtendedFuture.ReadOnlyMode readOnlyMode)
```
Creates a read-only view of this ExtendedFuture.
The returned future is backed by this future, allowing only read operations such as CompletableFuture.get(), CompletableFuture.join(), and other non-mutating methods. Any attempt to invoke mutating operations such as cancel(boolean), complete(Object), completeExceptionally(Throwable), or CompletableFuture.obtrudeValue(Object) will result in an UnsupportedOperationException or be silently ignored, depending on the specified ExtendedFuture.ReadOnlyMode.

Parameters:

readOnlyMode - the behavior when a mutating operation is attempted: ExtendedFuture.ReadOnlyMode.THROW_ON_MUTATION to throw UnsupportedOperationException, or ExtendedFuture.ReadOnlyMode.IGNORE_MUTATION to silently ignore mutation attempts.

Returns:

a read-only ExtendedFuture that is backed by the original future

cancel
```
public boolean cancel(boolean mayInterruptIfRunning)
```
If the preceding stage has isCancellableByDependents() set, the cancellation will also propagate to the preceding stage.

Specified by:

cancel in interface Future<T>

Overrides:

cancel in class CompletableFuture<T>

Parameters:

mayInterruptIfRunning - true if the thread executing this task should be interrupted (if the thread is known to the implementation); otherwise, in-progress tasks are allowed to complete.

Returns:

true if this task was successfully cancelled; false if the task could not be cancelled, typically because it has already completed.

complete
```
public boolean complete(T value)
```
Completes this future with the given value if not already completed.

Overrides:

complete in class CompletableFuture<T>

Parameters:

value - the value to complete this future with

Returns:

true if this invocation caused this future to transition to a completed state, otherwise false

completeAsync
```
public ExtendedFuture<T> completeAsync(Supplier<? extends T> supplier)
```
Completes this future with the result of the given supplier function, running it asynchronously using the default executor.

Overrides:

completeAsync in class CompletableFuture<T>

Parameters:

supplier - the supplier function to produce the completion value

Returns:

this ExtendedFuture for method chaining

completeAsync
```
public ExtendedFuture<T> completeAsync(Supplier<? extends T> supplier,
 Executor executor)
```
Completes this future with the result of the given supplier function, running it asynchronously using the specified executor.

Overrides:

completeAsync in class CompletableFuture<T>

Parameters:

supplier - the supplier function to produce the completion value

executor - the executor to use for asynchronous execution

Returns:

this ExtendedFuture for method chaining

completeAsync
```
public ExtendedFuture<T> completeAsync(ThrowingSupplier<? extends T,?> supplier)
```
Completes this future with the result of the given throwing supplier function, running it asynchronously using the default executor.

Parameters:

supplier - the throwing supplier function to produce the completion value

Returns:

this ExtendedFuture for method chaining

completeAsync
```
public ExtendedFuture<T> completeAsync(ThrowingSupplier<? extends T,?> supplier,
 Executor executor)
```
Completes this future with the result of the given throwing supplier function, running it asynchronously using the specified executor.

Parameters:

supplier - the throwing supplier function to produce the completion value

executor - the executor to use for asynchronous execution

Returns:

this ExtendedFuture for method chaining

completeExceptionally
```
public boolean completeExceptionally(Throwable ex)
```
Completes this future exceptionally with the given exception if not already completed.

Overrides:

completeExceptionally in class CompletableFuture<T>

Parameters:

ex - the exception to complete this future with

Returns:

true if this invocation caused this future to transition to a completed state, otherwise false

completeOnTimeout

public ExtendedFuture<T> completeOnTimeout(T value,
                                           long timeout,
                                           TimeUnit unit)

Overrides:: completeOnTimeout in class CompletableFuture<T>

completeWith
```
public ExtendedFuture<T> completeWith(CompletableFuture<? extends T> future)
```
Completes this ExtendedFuture when the provided CompletableFuture finishes, with either its result or its exception.

Parameters:

future - the CompletableFuture whose completion will trigger this future's completion

Returns:

this ExtendedFuture for chaining

copy
```
public ExtendedFuture<T> copy()
```
Overrides:

copy in class CompletableFuture<T>

defaultExecutor
```
public Executor defaultExecutor()
```
Overrides:

defaultExecutor in class CompletableFuture<T>

exceptionally
```
public ExtendedFuture<T> exceptionally(Function<Throwable,? extends T> fn)
```
Specified by:

exceptionally in interface CompletionStage<T>

Overrides:

exceptionally in class CompletableFuture<T>

exceptionally

public ExtendedFuture<T> exceptionally(ThrowingFunction<Throwable,? extends T,?> fn)

exceptionallyAsync
```
public ExtendedFuture<T> exceptionallyAsync(Function<Throwable,? extends T> fn)
```
This method emulates the CompletableFuture's exceptionallyAsync method introduced in Java 12.

exceptionallyAsync

public ExtendedFuture<T> exceptionallyAsync(Function<Throwable,? extends T> fn,
                                            Executor executor)

This method emulates the CompletableFuture's exceptionallyAsync method introduced in Java 12.

exceptionallyAsync

public ExtendedFuture<T> exceptionallyAsync(ThrowingFunction<Throwable,? extends T,?> fn)

exceptionallyAsync

public ExtendedFuture<T> exceptionallyAsync(ThrowingFunction<Throwable,? extends T,?> fn,
                                            Executor executor)

exceptionallyCompose
```
public ExtendedFuture<T> exceptionallyCompose(Function<Throwable,? extends CompletionStage<T>> fn)
```
This method emulates the CompletableFuture's exceptionallyCompose method introduced in Java 12.

exceptionallyCompose

public ExtendedFuture<T> exceptionallyCompose(ThrowingFunction<Throwable,? extends CompletionStage<T>,?> fn)

exceptionallyComposeAsync
```
public ExtendedFuture<T> exceptionallyComposeAsync(Function<Throwable,? extends CompletionStage<T>> fn)
```
This method emulates the CompletableFuture's exceptionallyComposeAsync method introduced in Java 12.

exceptionallyComposeAsync

public ExtendedFuture<T> exceptionallyComposeAsync(Function<Throwable,? extends CompletionStage<T>> fn,
                                                   Executor executor)

This method emulates the CompletableFuture's exceptionallyComposeAsync method introduced in Java 12.

exceptionallyComposeAsync

public ExtendedFuture<T> exceptionallyComposeAsync(ThrowingFunction<Throwable,? extends CompletionStage<T>,?> fn)

exceptionallyComposeAsync

public ExtendedFuture<T> exceptionallyComposeAsync(ThrowingFunction<Throwable,? extends CompletionStage<T>,?> fn,
                                                   Executor executor)

exceptionNow
```
public Throwable exceptionNow()
```
This method emulates the CompletableFuture's exceptionNow method introduced in Java 19.

Throws:

IllegalStateException - if the task has not yet completed, completed normally, or was cancelled

forwardCancellation
```
public ExtendedFuture<T> forwardCancellation(@Nullable Future<?> to)
```
Propagates the cancellation of this ExtendedFuture to another Future.
If this ExtendedFuture is cancelled, the to future will be cancelled too.

Parameters:

to - the Future instance that should be cancelled if this future is cancelled

Returns:

this ExtendedFuture for method chaining

forwardCancellation
```
public ExtendedFuture<T> forwardCancellation(@NonNullByDefault({})
 Future<?> @Nullable ... to)
```
Propagates the cancellation of this ExtendedFuture to other Futures.
If this ExtendedFuture is cancelled, all futures in the provided to array will be cancelled too.

Parameters:

to - the array of Future instances that should be cancelled if this future is cancelled

Returns:

this ExtendedFuture for method chaining

forwardCancellationTo
```
public ExtendedFuture<T> forwardCancellationTo(@Nullable Collection<? extends @Nullable Future<?>> to)
```
Propagates the cancellation of this ExtendedFuture to other Futures.
If this ExtendedFuture is cancelled, all futures in the provided to collection will be cancelled too.

Parameters:

to - the collection of Future instances that should be cancelled if this future is cancelled

Returns:

this ExtendedFuture for method chaining

getNowOptional
```
public Optional<T> getNowOptional()
```
Returns the result of this future if it is already completed wrapped in an Optional, or an empty Optional if the future is incomplete, cancelled or failed.

Returns:

an Optional containing the result of the future if completed normally, or an empty Optional otherwise

getNowOrComputeFallback
```
public T getNowOrComputeFallback(BiFunction<Future<T>,@Nullable Exception,T> fallbackComputer)
```
Returns the result of this future if it is already completed, or the value provided by fallbackComputer if the future is incomplete, cancelled or failed.

Returns:

the result of the future if completed normally, otherwise the value computed by fallbackComputer

getNowOrComputeFallback
```
public T getNowOrComputeFallback(Function<@Nullable Exception,T> fallbackComputer)
```
Returns the result of this future if it is already completed, or the value provided by fallbackComputer if the future is incomplete, cancelled or failed.

Returns:

the result of the future if completed normally, otherwise the value computed by fallbackComputer

getNowOrFallback
```
public T getNowOrFallback(T fallback)
```
Returns the result of this future if it is already completed, or the specified fallback if the future is incomplete, cancelled or failed.

Returns:

the result of the future if completed normally, otherwise fallback

getOptional
```
public Optional<T> getOptional()
```
Attempts to retrieve the result this future within the specified timeout.

Returns:

an Optional containing the result of the future if completed normally within the timeout, or an empty Optional otherwise

getOptional
```
public Optional<T> getOptional(long timeout,
 TimeUnit unit)
```
Attempts to retrieve the result this future within the specified timeout.

Returns:

an Optional containing the result of the future if completed normally within the timeout, or an empty Optional otherwise

getOrComputeFallback
```
public T getOrComputeFallback(BiFunction<Future<T>,@Nullable Exception,T> fallbackComputer)
```
Attempts to retrieve the result of this future.

Returns:

the result of the future if completed normally, otherwise the value computed by fallbackComputer

getOrComputeFallback

public T getOrComputeFallback(BiFunction<Future<T>,@Nullable Exception,T> fallbackComputer,
                              long timeout,
                              TimeUnit unit)

Attempts to retrieve the result of this future within the specified timeout.

Returns:: the result of the future if completed normally within given timeout, otherwise the value computed by fallbackComputer

getOrComputeFallback
```
public T getOrComputeFallback(Function<@Nullable Exception,T> fallbackComputer)
```
Attempts to retrieve the result of this future.

Returns:

the result of the future if completed normally, otherwise the value computed by fallbackComputer

getOrComputeFallback
```
public T getOrComputeFallback(Function<@Nullable Exception,T> fallbackComputer,
 long timeout,
 TimeUnit unit)
```
Attempts to retrieve the result of this future within the specified timeout.

Returns:

the result of the future if completed normally within given timeout, otherwise the value computed by fallbackComputer

getOrFallback
```
public T getOrFallback(T fallback)
```
Attempts to retrieve the result of this future.

Returns:

the result of the future if completed normally, otherwise fallback

getOrFallback
```
public T getOrFallback(T fallback,
                       long timeout,
                       TimeUnit unit)
```
Attempts to retrieve the result of this future within the specified timeout.

Returns:

the result of the future if completed normally within given timeout, otherwise fallback

handle

public <U> ExtendedFuture<U> handle(BiFunction<? super T,@Nullable Throwable,? extends U> fn)

Specified by:: handle in interface CompletionStage<T>
Overrides:: handle in class CompletableFuture<T>

handleAsync

public <U> ExtendedFuture<U> handleAsync(BiFunction<? super T,@Nullable Throwable,? extends U> fn)

Specified by:: handleAsync in interface CompletionStage<T>
Overrides:: handleAsync in class CompletableFuture<T>

handleAsync

public <U> ExtendedFuture<U> handleAsync(BiFunction<? super T,@Nullable Throwable,? extends U> fn,
                                         Executor executor)

Specified by:: handleAsync in interface CompletionStage<T>
Overrides:: handleAsync in class CompletableFuture<T>

isCancellableByDependents
```
public boolean isCancellableByDependents()
```
Returns true if this future is cancellable by its dependent stages. If true, cancellation of a dependent stage will also cancel this future and any preceding stages. If false, cancellation of dependent stages will not affect this future.

Returns:

true if this future is cancellable by dependents, false otherwise

isFailed
```
public boolean isFailed()
```
Returns true if this ExtendedFuture was completed exceptionally, excluding cancellation.

Returns:

true if the future completed exceptionally but was not cancelled

isIncomplete
```
public boolean isIncomplete()
```
Returns true if this future is incomplete.

Returns:

true if this future is incomplete, false otherwise

isInterruptible
```
public boolean isInterruptible()
```
Returns true if this future is interruptible, i.e., cancel(true) will result in thread interruption.

Returns:

true if this future is interruptible, false otherwise

isInterruptibleStages
```
public boolean isInterruptibleStages()
```
Returns true if new stages created from this future are interruptible.

Returns:

true if new stages are interruptible, false otherwise

isReadOnly
```
public boolean isReadOnly()
```
Returns true if this future cannot be completed programmatically through methods like cancel(boolean) or complete(Object).

Returns:

true if this future is read-only, false otherwise

isSuccess
```
public boolean isSuccess()
```
Returns true if this future completed normally.

Returns:

true if this future completed normally, false otherwise

newIncompleteFuture
```
public <V> ExtendedFuture<V> newIncompleteFuture()
```
Overrides:

newIncompleteFuture in class CompletableFuture<T>

resultNow
```
public T resultNow()
```
This method emulates the CompletableFuture's resultNow method introduced in Java 19.

Returns:

the computed result

Throws:

IllegalStateException - if the task has not yet completed or failed

runAfterBoth

public ExtendedFuture<@Nullable Void> runAfterBoth(CompletionStage<?> other,
                                                   Runnable action)

Specified by:: runAfterBoth in interface CompletionStage<T>
Overrides:: runAfterBoth in class CompletableFuture<T>

runAfterBoth

public ExtendedFuture<@Nullable Void> runAfterBoth(CompletionStage<?> other,
                                                   ThrowingRunnable<?> action)

runAfterBothAsync

public ExtendedFuture<@Nullable Void> runAfterBothAsync(CompletionStage<?> other,
                                                        Runnable action)

Specified by:: runAfterBothAsync in interface CompletionStage<T>
Overrides:: runAfterBothAsync in class CompletableFuture<T>

runAfterBothAsync

public ExtendedFuture<@Nullable Void> runAfterBothAsync(CompletionStage<?> other,
                                                        Runnable action,
                                                        Executor executor)

Specified by:: runAfterBothAsync in interface CompletionStage<T>
Overrides:: runAfterBothAsync in class CompletableFuture<T>

runAfterBothAsync

public ExtendedFuture<@Nullable Void> runAfterBothAsync(CompletionStage<?> other,
                                                        ThrowingRunnable<?> action)

runAfterBothAsync

public ExtendedFuture<@Nullable Void> runAfterBothAsync(CompletionStage<?> other,
                                                        ThrowingRunnable<?> action,
                                                        Executor executor)

runAfterEither

public ExtendedFuture<@Nullable Void> runAfterEither(CompletionStage<?> other,
                                                     Runnable action)

Specified by:: runAfterEither in interface CompletionStage<T>
Overrides:: runAfterEither in class CompletableFuture<T>

runAfterEither

public ExtendedFuture<@Nullable Void> runAfterEither(CompletionStage<?> other,
                                                     ThrowingRunnable<?> action)

runAfterEitherAsync

public ExtendedFuture<@Nullable Void> runAfterEitherAsync(CompletionStage<?> other,
                                                          Runnable action)

Specified by:: runAfterEitherAsync in interface CompletionStage<T>
Overrides:: runAfterEitherAsync in class CompletableFuture<T>

runAfterEitherAsync

public ExtendedFuture<@Nullable Void> runAfterEitherAsync(CompletionStage<?> other,
                                                          Runnable action,
                                                          Executor executor)

Specified by:: runAfterEitherAsync in interface CompletionStage<T>
Overrides:: runAfterEitherAsync in class CompletableFuture<T>

runAfterEitherAsync

public ExtendedFuture<@Nullable Void> runAfterEitherAsync(CompletionStage<?> other,
                                                          ThrowingRunnable<?> action)

runAfterEitherAsync

public ExtendedFuture<@Nullable Void> runAfterEitherAsync(CompletionStage<?> other,
                                                          ThrowingRunnable<?> action,
                                                          Executor executor)

thenAccept
```
public ExtendedFuture<@Nullable Void> thenAccept(Consumer<? super T> action)
```
Specified by:

thenAccept in interface CompletionStage<T>

Overrides:

thenAccept in class CompletableFuture<T>

thenAccept

public ExtendedFuture<@Nullable Void> thenAccept(ThrowingConsumer<? super T,?> action)

thenAcceptAsync
```
public ExtendedFuture<@Nullable Void> thenAcceptAsync(Consumer<? super T> action)
```
Specified by:

thenAcceptAsync in interface CompletionStage<T>

Overrides:

thenAcceptAsync in class CompletableFuture<T>

thenAcceptAsync

public ExtendedFuture<@Nullable Void> thenAcceptAsync(Consumer<? super T> action,
                                                      Executor executor)

Specified by:: thenAcceptAsync in interface CompletionStage<T>
Overrides:: thenAcceptAsync in class CompletableFuture<T>

thenAcceptAsync

public ExtendedFuture<@Nullable Void> thenAcceptAsync(ThrowingConsumer<? super T,?> action)

thenAcceptAsync

public ExtendedFuture<@Nullable Void> thenAcceptAsync(ThrowingConsumer<? super T,?> action,
                                                      Executor executor)

thenAcceptBoth

public <U> ExtendedFuture<@Nullable Void> thenAcceptBoth(CompletionStage<? extends U> other,
                                                         BiConsumer<? super T,? super U> action)

Specified by:: thenAcceptBoth in interface CompletionStage<T>
Overrides:: thenAcceptBoth in class CompletableFuture<T>

thenAcceptBoth

public <U> ExtendedFuture<@Nullable Void> thenAcceptBoth(CompletionStage<? extends U> other,
                                                         ThrowingBiConsumer<? super T,? super U,?> action)

thenAcceptBothAsync

public <U> ExtendedFuture<@Nullable Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
                                                              BiConsumer<? super T,? super U> action)

Specified by:: thenAcceptBothAsync in interface CompletionStage<T>
Overrides:: thenAcceptBothAsync in class CompletableFuture<T>

thenAcceptBothAsync

public <U> ExtendedFuture<@Nullable Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
                                                              BiConsumer<? super T,? super U> action,
                                                              Executor executor)

Specified by:: thenAcceptBothAsync in interface CompletionStage<T>
Overrides:: thenAcceptBothAsync in class CompletableFuture<T>

thenAcceptBothAsync

public <U> ExtendedFuture<@Nullable Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
                                                              ThrowingBiConsumer<? super T,? super U,?> action)

thenAcceptBothAsync

public <U> ExtendedFuture<@Nullable Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
                                                              ThrowingBiConsumer<? super T,? super U,?> action,
                                                              Executor executor)

thenApply
```
public  ExtendedFuture thenApply(Function<? super T,? extends U> fn)
```
Specified by:

thenApply in interface CompletionStage<T>

Overrides:

thenApply in class CompletableFuture<T>

thenApply

public <U> ExtendedFuture<U> thenApply(ThrowingFunction<? super T,? extends U,?> fn)

thenApplyAsync
```
public  ExtendedFuture thenApplyAsync(Function<? super T,? extends U> fn)
```
Specified by:

thenApplyAsync in interface CompletionStage<T>

Overrides:

thenApplyAsync in class CompletableFuture<T>

thenApplyAsync

public <U> ExtendedFuture<U> thenApplyAsync(Function<? super T,? extends U> fn,
                                            Executor executor)

Specified by:: thenApplyAsync in interface CompletionStage<T>
Overrides:: thenApplyAsync in class CompletableFuture<T>

thenApplyAsync

public <U> ExtendedFuture<U> thenApplyAsync(ThrowingFunction<? super T,? extends U,?> fn)

thenApplyAsync

public <U> ExtendedFuture<U> thenApplyAsync(ThrowingFunction<? super T,? extends U,?> fn,
                                            Executor executor)

thenCombine

public <U,V> ExtendedFuture<V> thenCombine(CompletionStage<? extends U> other,
                                                 BiFunction<? super T,? super U,? extends V> fn)

Specified by:: thenCombine in interface CompletionStage<T>
Overrides:: thenCombine in class CompletableFuture<T>

thenCombine

public <U,V> ExtendedFuture<V> thenCombine(CompletionStage<? extends U> other,
                                                 ThrowingBiFunction<? super T,? super U,? extends V,?> fn)

thenCombineAsync

public <U,V> ExtendedFuture<V> thenCombineAsync(CompletionStage<? extends U> other,
                                                      BiFunction<? super T,? super U,? extends V> fn)

Specified by:: thenCombineAsync in interface CompletionStage<T>
Overrides:: thenCombineAsync in class CompletableFuture<T>

thenCombineAsync

public <U,V> ExtendedFuture<V> thenCombineAsync(CompletionStage<? extends U> other,
                                                      BiFunction<? super T,? super U,? extends V> fn,
                                                      Executor executor)

Specified by:: thenCombineAsync in interface CompletionStage<T>
Overrides:: thenCombineAsync in class CompletableFuture<T>

thenCombineAsync

public <U,V> ExtendedFuture<V> thenCombineAsync(CompletionStage<? extends U> other,
                                                      ThrowingBiFunction<? super T,? super U,? extends V,?> fn)

thenCombineAsync

public <U,V> ExtendedFuture<V> thenCombineAsync(CompletionStage<? extends U> other,
                                                      ThrowingBiFunction<? super T,? super U,? extends V,?> fn,
                                                      Executor executor)

thenCompose
```
public  ExtendedFuture thenCompose(Function<? super T,? extends CompletionStage> fn)
```
Specified by:

thenCompose in interface CompletionStage<T>

Overrides:

thenCompose in class CompletableFuture<T>

thenCompose

public <U> ExtendedFuture<U> thenCompose(ThrowingFunction<? super T,? extends CompletionStage<U>,?> fn)

thenComposeAsync
```
public  ExtendedFuture thenComposeAsync(Function<? super T,? extends CompletionStage> fn)
```
Specified by:

thenComposeAsync in interface CompletionStage<T>

Overrides:

thenComposeAsync in class CompletableFuture<T>

thenComposeAsync

public <U> ExtendedFuture<U> thenComposeAsync(Function<? super T,? extends CompletionStage<U>> fn,
                                              Executor executor)

Specified by:: thenComposeAsync in interface CompletionStage<T>
Overrides:: thenComposeAsync in class CompletableFuture<T>

thenComposeAsync

public <U> ExtendedFuture<U> thenComposeAsync(ThrowingFunction<? super T,? extends CompletionStage<U>,?> fn)

thenComposeAsync

public <U> ExtendedFuture<U> thenComposeAsync(ThrowingFunction<? super T,? extends CompletionStage<U>,?> fn,
                                              Executor executor)

thenRun
```
public ExtendedFuture<@Nullable Void> thenRun(Runnable action)
```
Specified by:

thenRun in interface CompletionStage<T>

Overrides:

thenRun in class CompletableFuture<T>

thenRun

public ExtendedFuture<@Nullable Void> thenRun(ThrowingRunnable<?> action)

thenRunAsync
```
public ExtendedFuture<@Nullable Void> thenRunAsync(Runnable action)
```
Specified by:

thenRunAsync in interface CompletionStage<T>

Overrides:

thenRunAsync in class CompletableFuture<T>

thenRunAsync

public ExtendedFuture<@Nullable Void> thenRunAsync(Runnable action,
                                                   Executor executor)

Specified by:: thenRunAsync in interface CompletionStage<T>
Overrides:: thenRunAsync in class CompletableFuture<T>

thenRunAsync

public ExtendedFuture<@Nullable Void> thenRunAsync(ThrowingRunnable<?> action)

thenRunAsync

public ExtendedFuture<@Nullable Void> thenRunAsync(ThrowingRunnable<?> action,
                                                   Executor executor)

whenComplete

public ExtendedFuture<T> whenComplete(BiConsumer<? super @Nullable T,? super @Nullable Throwable> action)

Specified by:: whenComplete in interface CompletionStage<T>
Overrides:: whenComplete in class CompletableFuture<T>

whenComplete

public ExtendedFuture<T> whenComplete(ThrowingBiConsumer<? super @Nullable T,? super @Nullable Throwable,?> action)

whenCompleteAsync
```
public ExtendedFuture<T> whenCompleteAsync(BiConsumer<? super @Nullable T,? super @Nullable Throwable> action)
```
Specified by:

whenCompleteAsync in interface CompletionStage<T>

Overrides:

whenCompleteAsync in class CompletableFuture<T>

whenCompleteAsync

public ExtendedFuture<T> whenCompleteAsync(BiConsumer<? super @Nullable T,? super @Nullable Throwable> action,
                                           Executor executor)

Specified by:: whenCompleteAsync in interface CompletionStage<T>
Overrides:: whenCompleteAsync in class CompletableFuture<T>

whenCompleteAsync

public ExtendedFuture<T> whenCompleteAsync(ThrowingBiConsumer<? super @Nullable T,? super @Nullable Throwable,?> action)

whenCompleteAsync

public ExtendedFuture<T> whenCompleteAsync(ThrowingBiConsumer<? super @Nullable T,? super @Nullable Throwable,?> action,
                                           Executor executor)

withDefaultExecutor
```
public ExtendedFuture<T> withDefaultExecutor(Executor defaultExecutor)
```
Returns an ExtendedFuture that shares the result with this future, but with the specified Executor as the default for asynchronous operations of subsequent stages.

Parameters:

defaultExecutor - the default Executor for async tasks, must not be null

Returns:

a new ExtendedFuture with the specified executor, or this if the executor is unchanged

withInterruptibleStages
```
public ExtendedFuture<T> withInterruptibleStages(boolean interruptibleStages)
```
Returns an ExtendedFuture that shares the result with this future but with the specified behavior for new stages being interruptible or not.
If the requested interruptibility behavior matches the current one, this instance is returned.

Parameters:

interruptibleStages - true if new stages should be interruptible, false otherwise

Returns:

a new ExtendedFuture with the specified interruptibility behavior for new stages, or this instance if the behavior remains unchanged

Class ExtendedFuture<T>

Nested Class Summary

Nested classes/interfaces inherited from class java.util.concurrent.CompletableFuture

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.concurrent.CompletableFuture

Methods inherited from class java.lang.Object

Field Detail

cancellablePrecedingStages

cancellableByDependents

interruptibleStages

defaultExecutor

Constructor Detail

ExtendedFuture

Method Detail

allOf

anyOf

builder

completedFuture

failedFuture

from

runAsync

runAsync

runAsync

runAsync

runAsyncWithDefaultExecutor

supplyAsync

supplyAsync

supplyAsync

supplyAsync

supplyAsyncWithDefaultExecutor

acceptEither

acceptEither

acceptEitherAsync

acceptEitherAsync

acceptEitherAsync

acceptEitherAsync

addTo

addTo

applyToEither

applyToEither

applyToEitherAsync

applyToEitherAsync

applyToEitherAsync

applyToEitherAsync

asCancellableByDependents

asNonInterruptible

asReadOnly

cancel

complete

completeAsync

completeAsync

completeAsync

completeAsync

completeExceptionally

completeOnTimeout

completeWith

copy

defaultExecutor

exceptionally

exceptionally

exceptionallyAsync

exceptionallyAsync

exceptionallyAsync

exceptionallyAsync

exceptionallyCompose

exceptionallyCompose

exceptionallyComposeAsync

exceptionallyComposeAsync

exceptionallyComposeAsync

exceptionallyComposeAsync

exceptionNow

forwardCancellation

forwardCancellation

forwardCancellationTo

getNowOptional

getNowOrComputeFallback

getNowOrComputeFallback

getNowOrFallback