org.jspare.vertx.concurrent

Class VertxCompletableFuture<T>

java.lang.Object

java.util.concurrent.CompletableFuture<T>

org.jspare.vertx.concurrent.VertxCompletableFuture<T>

Type Parameters:

T - the expected type of result

All Implemented Interfaces:

CompletionStage<T>, Future<T>

public class VertxCompletableFuture<T>
extends CompletableFuture<T>
implements CompletionStage<T>

An implementation of CompletableFuture for Vert.x. It differs in the way to handle async calls:

* VertxCompletableFuture are attached to a Vert.x Context * All operator methods returns VertxCompletableFuture * async method not passing an Executor are executed on the attached Context * All non async method are executed on the current Thread (so not necessary on the attached Context

The class also offer bridges methods with Vert.x Future, and regular CompletableFuture.

Author:

Paulo Lima

Nested Class Summary

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

CompletableFuture.AsynchronousCompletionTask

Constructor Summary

Constructors

Constructor and Description
VertxCompletableFuture() Creates a new VertxCompletableFuture using the current Context.
VertxCompletableFuture(io.vertx.core.Context context) Creates an instance of VertxCompletableFuture, using the given Context.
VertxCompletableFuture(io.vertx.core.Vertx vertx) Creates an instance of VertxCompletableFuture, using the current Vert.x context or create a new one.

Method Summary

Modifier and Type	Method and Description
VertxCompletableFuture<Void>	acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action)
VertxCompletableFuture<Void>	acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action)
VertxCompletableFuture<Void>	acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action, Executor executor)
static VertxCompletableFuture<Void>	allOf(io.vertx.core.Context context, CompletableFuture<?>... futures) Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete.
static VertxCompletableFuture<Void>	allOf(io.vertx.core.Vertx vertx, CompletableFuture<?>... futures) Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete.
static VertxCompletableFuture<Object>	anyOf(io.vertx.core.Context context, CompletableFuture<?>... futures) Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result.
static VertxCompletableFuture<Object>	anyOf(io.vertx.core.Vertx vertx, CompletableFuture<?>... futures) Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result.
<U> VertxCompletableFuture<U>	applyToEither(CompletionStage<? extends T> other, Function<? super T,U> fn)
<U> VertxCompletableFuture<U>	applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T,U> fn)
<U> VertxCompletableFuture<U>	applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T,U> fn, Executor executor)
io.vertx.core.Context	context()
static <T> VertxCompletableFuture<T>	from(io.vertx.core.Context context, CompletableFuture<T> future) Creates a VertxCompletableFuture from the given Context and CompletableFuture.
static <T> VertxCompletableFuture<T>	from(io.vertx.core.Context context, io.vertx.core.Future<T> future) Creates a new VertxCompletableFuture from the given Context instance and given Future.
static <T> VertxCompletableFuture<T>	from(io.vertx.core.Vertx vertx, CompletableFuture<T> future) Creates a new VertxCompletableFuture from the given Vertx instance and given CompletableFuture.
static <T> VertxCompletableFuture<T>	from(io.vertx.core.Vertx vertx, io.vertx.core.Future<T> future) Creates a new VertxCompletableFuture from the given Context instance and given Future.
<U> VertxCompletableFuture<U>	handle(BiFunction<? super T,Throwable,? extends U> fn)
<U> VertxCompletableFuture<U>	handleAsync(BiFunction<? super T,Throwable,? extends U> fn)
<U> VertxCompletableFuture<U>	handleAsync(BiFunction<? super T,Throwable,? extends U> fn, Executor executor)
VertxCompletableFuture<Void>	runAfterBoth(CompletionStage<?> other, Runnable action)
VertxCompletableFuture<Void>	runAfterBothAsync(CompletionStage<?> other, Runnable action)
VertxCompletableFuture<Void>	runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor)
VertxCompletableFuture<Void>	runAfterEither(CompletionStage<?> other, Runnable action)
VertxCompletableFuture<Void>	runAfterEitherAsync(CompletionStage<?> other, Runnable action)
VertxCompletableFuture<Void>	runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor)
static VertxCompletableFuture<Void>	runAsync(io.vertx.core.Context context, Runnable runnable) Returns a new CompletableFuture that is asynchronously completed by a task running in the current Vert.x Context after it runs the given action.
static VertxCompletableFuture<Void>	runAsync(io.vertx.core.Vertx vertx, Runnable runnable) Returns a new CompletableFuture that is asynchronously completed by a task running in the current Vert.x Context after it runs the given action.
static VertxCompletableFuture<Void>	runBlockingAsync(io.vertx.core.Context context, Runnable runnable) Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of Vert.x This method is different from CompletableFuture.runAsync(Runnable) as it does not use a fork join executor, but the worker thread pool.
static VertxCompletableFuture<Void>	runBlockingAsync(io.vertx.core.Vertx vertx, Runnable runnable) Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of Vert.x This method is different from CompletableFuture.runAsync(Runnable) as it does not use a fork join executor, but the worker thread pool.
static <T> VertxCompletableFuture<T>	supplyAsync(io.vertx.core.Context context, Supplier<T> supplier) Returns a new CompletableFuture that is asynchronously completed by a task running in the current Vert.x Context with the value obtained by calling the given Supplier.
static <T> VertxCompletableFuture<T>	supplyAsync(io.vertx.core.Vertx vertx, Supplier<T> supplier) Returns a new CompletableFuture that is asynchronously completed by a task running in the current Vert.x Context with the value obtained by calling the given Supplier.
static <T> VertxCompletableFuture<T>	supplyBlockingAsync(io.vertx.core.Context context, Supplier<T> supplier) Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of Vert.x This method is different from CompletableFuture.supplyAsync(Supplier) as it does not use a fork join executor, but the worker thread pool.
static <T> VertxCompletableFuture<T>	supplyBlockingAsync(io.vertx.core.Vertx vertx, Supplier<T> supplier) Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of Vert.x This method is different from CompletableFuture.supplyAsync(Supplier) as it does not use a fork join executor, but the worker thread pool.
VertxCompletableFuture<Void>	thenAccept(Consumer<? super T> action)
VertxCompletableFuture<Void>	thenAcceptAsync(Consumer<? super T> action)
VertxCompletableFuture<Void>	thenAcceptAsync(Consumer<? super T> action, Executor executor)
<U> VertxCompletableFuture<Void>	thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)
<U> VertxCompletableFuture<Void>	thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)
<U> VertxCompletableFuture<Void>	thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action, Executor executor)
<U> VertxCompletableFuture<U>	thenApply(Function<? super T,? extends U> fn)
<U> VertxCompletableFuture<U>	thenApplyAsync(Function<? super T,? extends U> fn)
<U> VertxCompletableFuture<U>	thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)
<U,V> VertxCompletableFuture<V>	thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)
<U,V> VertxCompletableFuture<V>	thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)
<U,V> VertxCompletableFuture<V>	thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor)
<U> VertxCompletableFuture<U>	thenCompose(Function<? super T,? extends CompletionStage<U>> fn)
<U> VertxCompletableFuture<U>	thenComposeAsync(Function<? super T,? extends CompletionStage<U>> fn)
<U> VertxCompletableFuture<U>	thenComposeAsync(Function<? super T,? extends CompletionStage<U>> fn, Executor executor)
VertxCompletableFuture<Void>	thenRun(Runnable action)
VertxCompletableFuture<Void>	thenRunAsync(Runnable action)
VertxCompletableFuture<Void>	thenRunAsync(Runnable action, Executor executor)
VertxCompletableFuture<T>	toCompletableFuture()
io.vertx.core.Future<T>	toFuture() Creates a new Future object completed / failed when the current VertxCompletableFuture is completed successfully or not.
static <T> io.vertx.core.Future<T>	toFuture(CompletableFuture<T> future) Creates a Vert.x Future from the given CompletableFuture (that can be a VertxCompletableFuture).
VertxCompletableFuture<T>	whenComplete(BiConsumer<? super T,? super Throwable> action)
VertxCompletableFuture<T>	whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
VertxCompletableFuture<T>	whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)
VertxCompletableFuture<T>	withContext() Creates a new VertxCompletableFuture using the current context.
VertxCompletableFuture<T>	withContext(io.vertx.core.Context context) Creates a new VertxCompletableFuture using the given context.
VertxCompletableFuture<T>	withContext(io.vertx.core.Vertx vertx) Creates a new VertxCompletableFuture using the current context or creates a new one.

Methods inherited from class java.util.concurrent.CompletableFuture

allOf, anyOf, cancel, complete, completedFuture, completeExceptionally, exceptionally, get, get, getNow, getNumberOfDependents, isCancelled, isCompletedExceptionally, isDone, join, obtrudeException, obtrudeValue, runAsync, runAsync, supplyAsync, supplyAsync, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.concurrent.CompletionStage

exceptionally

Constructor Detail

VertxCompletableFuture

public VertxCompletableFuture()

Creates a new VertxCompletableFuture using the current Context. This method must be used from a Vert.x thread, or fails.

VertxCompletableFuture

public VertxCompletableFuture(io.vertx.core.Context context)

Creates an instance of VertxCompletableFuture, using the given Context.

Parameters:

context - the context

VertxCompletableFuture

public VertxCompletableFuture(io.vertx.core.Vertx vertx)

Creates an instance of VertxCompletableFuture, using the current Vert.x context or create a new one.

Parameters:

vertx - the Vert.x instance

Method Detail

allOf

public static VertxCompletableFuture<Void> allOf(io.vertx.core.Context context,
                                                 CompletableFuture<?>... futures)

Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete. If any of the given CompletableFutures complete exceptionally, then the returned CompletableFuture also does so, with a CompletionException holding this exception as its cause. Otherwise, the results, if any, of the given CompletableFutures are not reflected in the returned CompletableFuture, but may be obtained by inspecting them individually. If no CompletableFutures are provided, returns a CompletableFuture completed with the value null.

Among the applications of this method is to await completion of a set of independent CompletableFutures before continuing a program, as in: CompletableFuture.allOf(c1, c2, c3).join();.

Unlike the original CompletableFuture.allOf(CompletableFuture[]) this method invokes the dependent stages into the Vert.x context.

Parameters:

context - the context

futures - the CompletableFutures

Returns:

a new CompletableFuture that is completed when all of the given CompletableFutures complete

Throws:

NullPointerException - if the array or any of its elements are null

allOf

public static VertxCompletableFuture<Void> allOf(io.vertx.core.Vertx vertx,
                                                 CompletableFuture<?>... futures)

Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete. If any of the given CompletableFutures complete exceptionally, then the returned CompletableFuture also does so, with a CompletionException holding this exception as its cause. Otherwise, the results, if any, of the given CompletableFutures are not reflected in the returned CompletableFuture, but may be obtained by inspecting them individually. If no CompletableFutures are provided, returns a CompletableFuture completed with the value null.

Among the applications of this method is to await completion of a set of independent CompletableFutures before continuing a program, as in: CompletableFuture.allOf(c1, c2, c3).join();.

Unlike the original CompletableFuture.allOf(CompletableFuture[]) this method invokes the dependent stages into the Vert.x context.

Parameters:

vertx - the Vert.x instance to retrieve the context

futures - the CompletableFutures

Returns:

a new CompletableFuture that is completed when all of the given CompletableFutures complete

Throws:

NullPointerException - if the array or any of its elements are null

anyOf

public static VertxCompletableFuture<Object> anyOf(io.vertx.core.Context context,
                                                   CompletableFuture<?>... futures)

Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result. Otherwise, if it completed exceptionally, the returned CompletableFuture also does so, with a CompletionException holding this exception as its cause. If no CompletableFutures are provided, returns an incomplete CompletableFuture.

Unlike the original CompletableFuture.allOf(CompletableFuture[]) this method invokes the dependent stages into the Vert.x context.

Parameters:

context - the context

futures - the CompletableFutures

Returns:

a new CompletableFuture that is completed with the result or exception of any of the given CompletableFutures when one completes

Throws:

NullPointerException - if the array or any of its elements are null

anyOf

public static VertxCompletableFuture<Object> anyOf(io.vertx.core.Vertx vertx,
                                                   CompletableFuture<?>... futures)

Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result. Otherwise, if it completed exceptionally, the returned CompletableFuture also does so, with a CompletionException holding this exception as its cause. If no CompletableFutures are provided, returns an incomplete CompletableFuture.

Unlike the original CompletableFuture.allOf(CompletableFuture[]) this method invokes the dependent stages into the Vert.x context.

Parameters:

vertx - the Vert.x instance to retrieve the context

futures - the CompletableFutures

Returns:

a new CompletableFuture that is completed with the result or exception of any of the given CompletableFutures when one completes

Throws:

NullPointerException - if the array or any of its elements are null

from

public static <T> VertxCompletableFuture<T> from(io.vertx.core.Context context,
                                                 CompletableFuture<T> future)

Creates a VertxCompletableFuture from the given Context and CompletableFuture.

The created VertxCompletableFuture is completed successfully or not when the given future completes successfully or not. The completion is called on the given Context, immediately if it is already executing on the right context, asynchronously if not.

Type Parameters:

T - the type of result

Parameters:

context - the context

future - the future

Returns:

the creation VertxCompletableFuture

from

public static <T> VertxCompletableFuture<T> from(io.vertx.core.Context context,
                                                 io.vertx.core.Future<T> future)

Creates a new VertxCompletableFuture from the given Context instance and given Future. The returned future uses the current Vert.x context, or creates a new one.

The created VertxCompletableFuture is completed successfully or not when the given future completes successfully or not. The created VertxCompletableFuture is completed successfully or not when the given future completes successfully or not. The completion is called on the given Context, immediately if it is already executing on the right context, asynchronously if not.

Type Parameters:

T - the type of the result

Parameters:

context - the context

future - the Vert.x future

Returns:

the new VertxCompletableFuture

from

public static <T> VertxCompletableFuture<T> from(io.vertx.core.Vertx vertx,
                                                 CompletableFuture<T> future)

Creates a new VertxCompletableFuture from the given Vertx instance and given CompletableFuture. The returned future uses the current Vert.x context, or creates a new one.

The created VertxCompletableFuture is completed successfully or not when the given completable future completes successfully or not.

Type Parameters:

T - the type of the result

Parameters:

vertx - the Vert.x instance

future - the future

Returns:

the new VertxCompletableFuture

from

public static <T> VertxCompletableFuture<T> from(io.vertx.core.Vertx vertx,
                                                 io.vertx.core.Future<T> future)

Creates a new VertxCompletableFuture from the given Context instance and given Future. The returned future uses the current Vert.x context, or creates a new one.

The created VertxCompletableFuture is completed successfully or not when the given future completes successfully or not.

Type Parameters:

T - the type of the result

Parameters:

vertx - the Vert.x instance

future - the Vert.x future

Returns:

the new VertxCompletableFuture

runAsync

public static VertxCompletableFuture<Void> runAsync(io.vertx.core.Context context,
                                                    Runnable runnable)

Returns a new CompletableFuture that is asynchronously completed by a task running in the current Vert.x Context after it runs the given action.

This method is different from CompletableFuture.runAsync(Runnable) as it does not use a fork join executor, but use the Vert.x context.

Parameters:

context - the context

runnable - the action to run before completing the returned CompletableFuture

Returns:

the new CompletableFuture

runAsync

public static VertxCompletableFuture<Void> runAsync(io.vertx.core.Vertx vertx,
                                                    Runnable runnable)

Returns a new CompletableFuture that is asynchronously completed by a task running in the current Vert.x Context after it runs the given action.

This method is different from CompletableFuture.supplyAsync(Supplier) as it does not use a fork join executor, but use the Vert.x context.

Parameters:

vertx - the Vert.x instance

runnable - the action to run before completing the returned CompletableFuture

Returns:

the new CompletableFuture

runBlockingAsync

public static VertxCompletableFuture<Void> runBlockingAsync(io.vertx.core.Context context,
                                                            Runnable runnable)

Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of Vert.x

This method is different from CompletableFuture.runAsync(Runnable) as it does not use a fork join executor, but the worker thread pool.

Parameters:

context - the Vert.x context

runnable - the action, when its execution completes, it completes the returned CompletableFuture. If the execution throws an exception, the returned CompletableFuture is completed exceptionally.

Returns:

the new CompletableFuture

runBlockingAsync

public static VertxCompletableFuture<Void> runBlockingAsync(io.vertx.core.Vertx vertx,
                                                            Runnable runnable)

Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of Vert.x

This method is different from CompletableFuture.runAsync(Runnable) as it does not use a fork join executor, but the worker thread pool.

Parameters:

vertx - the Vert.x instance

runnable - the action, when its execution completes, it completes the returned CompletableFuture. If the execution throws an exception, the returned CompletableFuture is completed exceptionally.

Returns:

the new CompletableFuture

supplyAsync

public static <T> VertxCompletableFuture<T> supplyAsync(io.vertx.core.Context context,
                                                        Supplier<T> supplier)

Returns a new CompletableFuture that is asynchronously completed by a task running in the current Vert.x Context with the value obtained by calling the given Supplier.

This method is different from CompletableFuture.supplyAsync(Supplier) as it does not use a fork join executor, but use the Vert.x context.

Type Parameters:

T - the function's return type

Parameters:

context - the context in which the supplier is executed.

supplier - a function returning the value to be used to complete the returned CompletableFuture

Returns:

the new CompletableFuture

supplyAsync

public static <T> VertxCompletableFuture<T> supplyAsync(io.vertx.core.Vertx vertx,
                                                        Supplier<T> supplier)

Returns a new CompletableFuture that is asynchronously completed by a task running in the current Vert.x Context with the value obtained by calling the given Supplier.

This method is different from CompletableFuture.supplyAsync(Supplier) as it does not use a fork join executor, but use the Vert.x context.

Type Parameters:

T - the function's return type

Parameters:

vertx - the Vert.x instance

supplier - a function returning the value to be used to complete the returned CompletableFuture

Returns:

the new CompletableFuture

supplyBlockingAsync

public static <T> VertxCompletableFuture<T> supplyBlockingAsync(io.vertx.core.Context context,
                                                                Supplier<T> supplier)

Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of Vert.x

This method is different from CompletableFuture.supplyAsync(Supplier) as it does not use a fork join executor, but the worker thread pool.

Type Parameters:

T - the function's return type

Parameters:

context - the context in which the supplier is executed.

supplier - a function returning the value to be used to complete the returned CompletableFuture

Returns:

the new CompletableFuture

supplyBlockingAsync

public static <T> VertxCompletableFuture<T> supplyBlockingAsync(io.vertx.core.Vertx vertx,
                                                                Supplier<T> supplier)

Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of Vert.x

This method is different from CompletableFuture.supplyAsync(Supplier) as it does not use a fork join executor, but the worker thread pool.

Type Parameters:

T - the function's return type

Parameters:

vertx - the Vert.x instance

supplier - a function returning the value to be used to complete the returned CompletableFuture

Returns:

the new CompletableFuture

toFuture

public static <T> io.vertx.core.Future<T> toFuture(CompletableFuture<T> future)

Creates a Vert.x Future from the given CompletableFuture (that can be a VertxCompletableFuture).

Type Parameters:

T - the type of the result

Parameters:

future - the future

Returns:

the Vert.x future completed or failed when the given CompletableFuture completes or fails.

acceptEither

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

Specified by:

acceptEither in interface CompletionStage<T>

Overrides:

acceptEither in class CompletableFuture<T>

acceptEitherAsync

public VertxCompletableFuture<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 VertxCompletableFuture<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>

applyToEither

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

Specified by:

applyToEither in interface CompletionStage<T>

Overrides:

applyToEither in class CompletableFuture<T>

applyToEitherAsync

public <U> VertxCompletableFuture<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> VertxCompletableFuture<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>

context

public io.vertx.core.Context context()

Returns:

the context associated with the current VertxCompletableFuture.

handle

public <U> VertxCompletableFuture<U> handle(BiFunction<? super T,Throwable,? extends U> fn)

Specified by:

handle in interface CompletionStage<T>

Overrides:

handle in class CompletableFuture<T>

handleAsync

public <U> VertxCompletableFuture<U> handleAsync(BiFunction<? super T,Throwable,? extends U> fn)

Specified by:

handleAsync in interface CompletionStage<T>

Overrides:

handleAsync in class CompletableFuture<T>

handleAsync

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

Specified by:

handleAsync in interface CompletionStage<T>

Overrides:

handleAsync in class CompletableFuture<T>

runAfterBoth

public VertxCompletableFuture<Void> runAfterBoth(CompletionStage<?> other,
                                                 Runnable action)

Specified by:

runAfterBoth in interface CompletionStage<T>

Overrides:

runAfterBoth in class CompletableFuture<T>

runAfterBothAsync

public VertxCompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,
                                                      Runnable action)

Specified by:

runAfterBothAsync in interface CompletionStage<T>

Overrides:

runAfterBothAsync in class CompletableFuture<T>

runAfterBothAsync

public VertxCompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,
                                                      Runnable action,
                                                      Executor executor)

Specified by:

runAfterBothAsync in interface CompletionStage<T>

Overrides:

runAfterBothAsync in class CompletableFuture<T>

runAfterEither

public VertxCompletableFuture<Void> runAfterEither(CompletionStage<?> other,
                                                   Runnable action)

Specified by:

runAfterEither in interface CompletionStage<T>

Overrides:

runAfterEither in class CompletableFuture<T>

runAfterEitherAsync

public VertxCompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,
                                                        Runnable action)

Specified by:

runAfterEitherAsync in interface CompletionStage<T>

Overrides:

runAfterEitherAsync in class CompletableFuture<T>

runAfterEitherAsync

public VertxCompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,
                                                        Runnable action,
                                                        Executor executor)

Specified by:

runAfterEitherAsync in interface CompletionStage<T>

Overrides:

runAfterEitherAsync in class CompletableFuture<T>

thenAccept

public VertxCompletableFuture<Void> thenAccept(Consumer<? super T> action)

Specified by:

thenAccept in interface CompletionStage<T>

Overrides:

thenAccept in class CompletableFuture<T>

thenAcceptAsync

public VertxCompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action)

Specified by:

thenAcceptAsync in interface CompletionStage<T>

Overrides:

thenAcceptAsync in class CompletableFuture<T>

thenAcceptAsync

public VertxCompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,
                                                    Executor executor)

Specified by:

thenAcceptAsync in interface CompletionStage<T>

Overrides:

thenAcceptAsync in class CompletableFuture<T>

thenAcceptBoth

public <U> VertxCompletableFuture<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>

thenAcceptBothAsync

public <U> VertxCompletableFuture<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> VertxCompletableFuture<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>

thenApply

public <U> VertxCompletableFuture<U> thenApply(Function<? super T,? extends U> fn)

Specified by:

thenApply in interface CompletionStage<T>

Overrides:

thenApply in class CompletableFuture<T>

thenApplyAsync

public <U> VertxCompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)

Specified by:

thenApplyAsync in interface CompletionStage<T>

Overrides:

thenApplyAsync in class CompletableFuture<T>

thenApplyAsync

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

Specified by:

thenApplyAsync in interface CompletionStage<T>

Overrides:

thenApplyAsync in class CompletableFuture<T>

thenCombine

public <U,V> VertxCompletableFuture<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>

thenCombineAsync

public <U,V> VertxCompletableFuture<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> VertxCompletableFuture<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>

thenCompose

public <U> VertxCompletableFuture<U> thenCompose(Function<? super T,? extends CompletionStage<U>> fn)

Specified by:

thenCompose in interface CompletionStage<T>

Overrides:

thenCompose in class CompletableFuture<T>

thenComposeAsync

public <U> VertxCompletableFuture<U> thenComposeAsync(Function<? super T,? extends CompletionStage<U>> fn)

Specified by:

thenComposeAsync in interface CompletionStage<T>

Overrides:

thenComposeAsync in class CompletableFuture<T>

thenComposeAsync

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

Specified by:

thenComposeAsync in interface CompletionStage<T>

Overrides:

thenComposeAsync in class CompletableFuture<T>

thenRun

public VertxCompletableFuture<Void> thenRun(Runnable action)

Specified by:

thenRun in interface CompletionStage<T>

Overrides:

thenRun in class CompletableFuture<T>

thenRunAsync

public VertxCompletableFuture<Void> thenRunAsync(Runnable action)

Specified by:

thenRunAsync in interface CompletionStage<T>

Overrides:

thenRunAsync in class CompletableFuture<T>

thenRunAsync

public VertxCompletableFuture<Void> thenRunAsync(Runnable action,
                                                 Executor executor)

Specified by:

thenRunAsync in interface CompletionStage<T>

Overrides:

thenRunAsync in class CompletableFuture<T>

toCompletableFuture

public VertxCompletableFuture<T> toCompletableFuture()

Specified by:

toCompletableFuture in interface CompletionStage<T>

Overrides:

toCompletableFuture in class CompletableFuture<T>

toFuture

public io.vertx.core.Future<T> toFuture()

Creates a new Future object completed / failed when the current VertxCompletableFuture is completed successfully or not.

Returns:

the Future.

whenComplete

public VertxCompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action)

Specified by:

whenComplete in interface CompletionStage<T>

Overrides:

whenComplete in class CompletableFuture<T>

whenCompleteAsync

public VertxCompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)

Specified by:

whenCompleteAsync in interface CompletionStage<T>

Overrides:

whenCompleteAsync in class CompletableFuture<T>

whenCompleteAsync

public VertxCompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action,
                                                   Executor executor)

Specified by:

whenCompleteAsync in interface CompletionStage<T>

Overrides:

whenCompleteAsync in class CompletableFuture<T>

withContext

public VertxCompletableFuture<T> withContext()

Creates a new VertxCompletableFuture using the current context. This method is used to switch between Vert.x contexts.

Returns:

the created VertxCompletableFuture

withContext

public VertxCompletableFuture<T> withContext(io.vertx.core.Context context)

Creates a new VertxCompletableFuture using the given context. This method is used to switch between Vert.x contexts.

Parameters:

context - the context

Returns:

the vertx completable future

withContext

public VertxCompletableFuture<T> withContext(io.vertx.core.Vertx vertx)

Creates a new VertxCompletableFuture using the current context or creates a new one. This method is used to switch between Vert.x contexts.

Parameters:

vertx - the vertx

Returns:

the vertx completable future