Package org.hibernate.search.util.common.impl

Class Futures

java.lang.Object

org.hibernate.search.util.common.impl.Futures

public final class Futures
extends Object

Method Summary

Modifier and Type	Method	Description
static <T> BiConsumer<T,Throwable>	copyHandler(CompletableFuture<T> copyFuture)	Creates a future handler that will copy the state of the handled future to the given future.
static <T> CompletableFuture<T>	create(Supplier<CompletableFuture<T>> initiator)	Create a CompletableFuture using the given supplier.
static CompletableFuture<?>	firstFailureOrAllOf(List<CompletableFuture<?>> allFutures)
static Throwable	getThrowableNow(CompletableFuture<?> future)
static <T> BiConsumer<T,Throwable>	handler(BiConsumer<T,Throwable> delegate)	Creates a future handler that will delegate to the given BiConsumer after having unwrapped the throwable passed as input if it is a CompletionException.
static <T, R> BiFunction<T,Throwable,R>	handler(BiFunction<T,Throwable,R> delegate)	Creates a future handler that will delegate to the given BiFunction after having unwrapped the throwable passed as input if it is a CompletionException.
static <T> Function<Throwable,T>	handler(Function<Throwable,T> delegate)	Creates a future handler that will delegate to the given Function after having unwrapped the throwable passed as input if it is a CompletionException.
static CompletableFuture<Void>	runAsync(Runnable runnable, ExecutorService executor)	Similar to CompletableFuture.runAsync(Runnable, Executor), but calling CompletableFuture.cancel(boolean) on the returned future actually has an effect and may interrupt the thread.
static <T, R> Function<T,CompletionStage<R>>	safeComposer(Function<? super T,? extends CompletionStage<R>> delegate)	Creates a composition function that will delegate to the given Function but will catch any exception during composition to return a future completed exceptionally.
static <T> T	unwrappedExceptionGet(Future<T> future)	Call CompletableFuture.get() and unwrap any ExecutionException, expecting the exception to be a RuntimeException.
static <T> T	unwrappedExceptionJoin(CompletableFuture<T> future)	Call CompletableFuture.join() and unwrap any CompletionException, expecting the exception to be a RuntimeException.
static <T> CompletableFuture<T>	whenCompleteExecute(CompletableFuture<?> self, Supplier<? extends CompletionStage<T>> action)	Compose the given future with another as soon as it's complete, regardless of errors, and return a completable future that will take errors of both parent futures into account (using Throwable.addSuppressed(Throwable) if need be).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details

create

public static <T> CompletableFuture<T> create(Supplier<CompletableFuture<T>> initiator)

Create a CompletableFuture using the given supplier.

This method is guaranteed to never throw any exception: any exception thrown by the given supplier will instead complete the resulting future exceptionally.

This is useful in particular if you want to handle errors during the CompletableFuture creation the same way as errors thrown during post-processing operations (for instance operations passed to CompletableFuture.thenApply(Function)).

Parameters:

initiator - A supplier that will initiate (synchronously) the asynchronous operation.

Returns:

A CompletableFuture wrapping the result of both the initiation and execution of the operation.

handler

public static <T> Function<Throwable,T> handler(Function<Throwable,T> delegate)

Creates a future handler that will delegate to the given Function after having unwrapped the throwable passed as input if it is a CompletionException.

This method is meant to be used in conjunction with CompletableFuture.exceptionally(Function).

Parameters:

delegate - The exception function to delegate to

Returns:

The new, delegating exception function.

handler

public static <T,
R> BiFunction<T,Throwable,R> handler(BiFunction<T,Throwable,R> delegate)

Creates a future handler that will delegate to the given BiFunction after having unwrapped the throwable passed as input if it is a CompletionException.

This method is meant to be used in conjunction with CompletableFuture.handle(BiFunction).

Parameters:

delegate - The handler to delegate to

Returns:

The new, delegating handler.

handler

public static <T> BiConsumer<T,Throwable> handler(BiConsumer<T,Throwable> delegate)

Creates a future handler that will delegate to the given BiConsumer after having unwrapped the throwable passed as input if it is a CompletionException.

This method is meant to be used in conjunction with CompletableFuture.whenComplete(BiConsumer).

Parameters:

delegate - The handler to delegate to

Returns:

The new, delegating handler.

copyHandler

public static <T> BiConsumer<T,Throwable> copyHandler(CompletableFuture<T> copyFuture)

Creates a future handler that will copy the state of the handled future to the given future.

This method is meant to be used in conjunction with CompletableFuture.whenComplete(BiConsumer).

Parameters:

copyFuture - The future to copy to

Returns:

the copy handler

safeComposer

public static <T,
R> Function<T,CompletionStage<R>> safeComposer(Function<? super T,? extends CompletionStage<R>> delegate)

Creates a composition function that will delegate to the given Function but will catch any exception during composition to return a future completed exceptionally.

This method is meant to be used in conjunction with CompletableFuture.thenCompose(Function). It is useful in particular when you want to apply the same error handling to the composition function and to the resulting future.

Parameters:

delegate - The composition function to delegate to.

Returns:

The new, delegating composition function .

whenCompleteExecute

public static <T> CompletableFuture<T> whenCompleteExecute(CompletableFuture<?> self,
 Supplier<? extends CompletionStage<T>> action)

Compose the given future with another as soon as it's complete, regardless of errors, and return a completable future that will take errors of both parent futures into account (using Throwable.addSuppressed(Throwable) if need be).

Parameters:

self - The future to wait for before launching the next one

action - the composition consumer

Returns:

A completable future that will be complete once self finished executing and action and its resulting future finished executing.

unwrappedExceptionJoin

@SuppressForbiddenApis(reason="Safer wrapper")
public static <T> T unwrappedExceptionJoin(CompletableFuture<T> future)

Call CompletableFuture.join() and unwrap any CompletionException, expecting the exception to be a RuntimeException.

Type Parameters:

T - The type of result the future will return.

Parameters:

future - The future to join on.

Returns:

The result returned by the future.

Throws:

RuntimeException - If the future fails.

unwrappedExceptionGet

public static <T> T unwrappedExceptionGet(Future<T> future)
                                   throws InterruptedException

Call CompletableFuture.get() and unwrap any ExecutionException, expecting the exception to be a RuntimeException.

Type Parameters:

T - The type of result the future will return.

Parameters:

future - The future to join on.

Returns:

The result returned by the future.

Throws:

RuntimeException - If the future fails.

InterruptedException - If the thread is interrupted.

runAsync

public static CompletableFuture<Void> runAsync(Runnable runnable,
 ExecutorService executor)

Similar to CompletableFuture.runAsync(Runnable, Executor), but calling CompletableFuture.cancel(boolean) on the returned future actually has an effect and may interrupt the thread.

This is mainly useful when the task to execute includes blocking calls, which is usually not the case when dealing with CompletableFuture.

Parameters:

runnable - the task to submit

executor - an executor to submit the task to

Returns:

a CompletableFuture that will complete once the given runnable has finished executing, potentially with an exception.

Throws:

RejectedExecutionException - if the task cannot be scheduled for execution.

NullPointerException - if the task is null.

getThrowableNow

public static Throwable getThrowableNow(CompletableFuture<?> future)

firstFailureOrAllOf

public static CompletableFuture<?> firstFailureOrAllOf(List<CompletableFuture<?>> allFutures)

Returns:

a CompletableFuture that will complete either when one of the future completes exceptionally, or when all futures complete successfully, whichever happens first.