Package io.vertx.mutiny.core

Class CompositeFuture

java.lang.Object

io.vertx.mutiny.core.Future<CompositeFuture>

io.vertx.mutiny.core.CompositeFuture

public class CompositeFuture
extends Future<CompositeFuture>

The composite future wraps a list of futures, it is useful when several futures needs to be coordinated. The handlers set for the coordinated futures are overridden by the handler of the composite future.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields

Modifier and Type	Field	Description
static TypeArg<CompositeFuture>	__TYPE_ARG

Fields inherited from class io.vertx.mutiny.core.Future

__typeArg_0

Constructor Summary

Constructors

Constructor	Description
CompositeFuture(io.vertx.core.CompositeFuture delegate)

Method Summary

Modifier and Type	Method	Description
static <T1,T2> CompositeFuture	all(Future<T1> f1, Future<T2> f2)
static <T1,T2,T3> CompositeFuture	all(Future<T1> f1, Future<T2> f2, Future<T3> f3)
static <T1,T2,T3,T4> CompositeFuture	all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)
static <T1,T2,T3,T4,T5> CompositeFuture	all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)
static <T1,T2,T3,T4,T5,T6> CompositeFuture	all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)
static CompositeFuture	all(List<Future> futures)
static <T1,T2> CompositeFuture	any(Future<T1> f1, Future<T2> f2)
static <T1,T2,T3> CompositeFuture	any(Future<T1> f1, Future<T2> f2, Future<T3> f3)
static <T1,T2,T3,T4> CompositeFuture	any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)
static <T1,T2,T3,T4,T5> CompositeFuture	any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)
static <T1,T2,T3,T4,T5,T6> CompositeFuture	any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)
static CompositeFuture	any(List<Future> futures)
Throwable	cause(int index)
void	complete()
void	complete(CompositeFuture result)	Deprecated.
io.vertx.core.Handler<io.vertx.core.AsyncResult<CompositeFuture>>	completer()	Deprecated.
<U> Future<U>	compose(Function<CompositeFuture,Future<U>> mapper)
<U> Future<U>	compose(Function<CompositeFuture,Future<U>> successMapper, Function<Throwable,Future<U>> failureMapper)
boolean	equals(Object o)
boolean	failed(int index)
<U> Future<U>	flatMap(Function<CompositeFuture,Future<U>> mapper)
io.vertx.core.CompositeFuture	getDelegate()
int	hashCode()
boolean	isComplete(int index)
static <T1,T2> CompositeFuture	join(Future<T1> f1, Future<T2> f2)
static <T1,T2,T3> CompositeFuture	join(Future<T1> f1, Future<T2> f2, Future<T3> f3)
static <T1,T2,T3,T4> CompositeFuture	join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)
static <T1,T2,T3,T4,T5> CompositeFuture	join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)
static <T1,T2,T3,T4,T5,T6> CompositeFuture	join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)
static CompositeFuture	join(List<Future> futures)
<U> Future<U>	map(Function<CompositeFuture,U> mapper)
static CompositeFuture	newInstance(io.vertx.core.CompositeFuture arg)
io.smallrye.mutiny.Uni<CompositeFuture>	onComplete()	Add a handler to be notified of the result.
CompositeFuture	onCompleteAndAwait()	Blocking variant of Future.onComplete().
CompositeFuture	onFailure(Consumer<Throwable> handler)
CompositeFuture	onSuccess(Consumer<CompositeFuture> handler)
Future<CompositeFuture>	otherwise(CompositeFuture value)
Future<CompositeFuture>	otherwise(Function<Throwable,CompositeFuture> mapper)
Future<CompositeFuture>	otherwiseEmpty()
Future<CompositeFuture>	recover(Function<Throwable,Future<CompositeFuture>> mapper)
CompositeFuture	result()
<T> T	resultAt(int index)
io.smallrye.mutiny.Uni<CompositeFuture>	setHandler()	Deprecated.
CompositeFuture	setHandlerAndAwait()	Deprecated.
int	size()
boolean	succeeded(int index)
String	toString()
boolean	tryComplete()
boolean	tryComplete(CompositeFuture result)	Deprecated.

Methods inherited from class io.vertx.mutiny.core.Future

cause, fail, fail, failed, failedFuture, failedFuture, future, future, isComplete, map, mapEmpty, newInstance, newInstance, succeeded, succeededFuture, succeededFuture, tryFail, tryFail

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

public static final TypeArg<CompositeFuture> __TYPE_ARG

Constructor Detail

CompositeFuture

public CompositeFuture(io.vertx.core.CompositeFuture delegate)

Method Detail

getDelegate

public io.vertx.core.CompositeFuture getDelegate()

Overrides:

getDelegate in class Future<CompositeFuture>

toString

public String toString()

Overrides:

toString in class Future<CompositeFuture>

equals

public boolean equals(Object o)

Overrides:

equals in class Future<CompositeFuture>

hashCode

public int hashCode()

Overrides:

hashCode in class Future<CompositeFuture>

complete

@Deprecated
public void complete(CompositeFuture result)

Deprecated.

Overrides:

complete in class Future<CompositeFuture>

Parameters:

result - the result

tryComplete

@Deprecated
public boolean tryComplete(CompositeFuture result)

Deprecated.

Overrides:

tryComplete in class Future<CompositeFuture>

Parameters:

result - the result

Returns:

false when the future is already completed

result

public CompositeFuture result()

Overrides:

result in class Future<CompositeFuture>

Returns:

the result or null if the operation failed.

flatMap

public <U> Future<U> flatMap(Function<CompositeFuture,Future<U>> mapper)

Overrides:

flatMap in class Future<CompositeFuture>

Parameters:

mapper -

Returns:

compose

public <U> Future<U> compose(Function<CompositeFuture,Future<U>> mapper)

Overrides:

compose in class Future<CompositeFuture>

Parameters:

mapper - the mapper function

Returns:

the composed future

compose

public <U> Future<U> compose(Function<CompositeFuture,Future<U>> successMapper,
                             Function<Throwable,Future<U>> failureMapper)

Overrides:

compose in class Future<CompositeFuture>

Parameters:

successMapper - the function mapping the success

failureMapper - the function mapping the failure

Returns:

the composed future

map

public <U> Future<U> map(Function<CompositeFuture,U> mapper)

Overrides:

map in class Future<CompositeFuture>

Parameters:

mapper - the mapper function

Returns:

the mapped future

completer

@Deprecated
public io.vertx.core.Handler<io.vertx.core.AsyncResult<CompositeFuture>> completer()

Deprecated.

Overrides:

completer in class Future<CompositeFuture>

Returns:

an handler completing this future

recover

public Future<CompositeFuture> recover(Function<Throwable,Future<CompositeFuture>> mapper)

Overrides:

recover in class Future<CompositeFuture>

Parameters:

mapper - A function which takes the exception of a failure and returns a new future.

Returns:

A recovered future

otherwise

public Future<CompositeFuture> otherwise(Function<Throwable,CompositeFuture> mapper)

Overrides:

otherwise in class Future<CompositeFuture>

Parameters:

mapper - the mapper function

Returns:

the mapped future

otherwise

public Future<CompositeFuture> otherwise(CompositeFuture value)

Overrides:

otherwise in class Future<CompositeFuture>

Parameters:

value - the value that eventually completes the mapped future

Returns:

the mapped future

otherwiseEmpty

public Future<CompositeFuture> otherwiseEmpty()

Overrides:

otherwiseEmpty in class Future<CompositeFuture>

Returns:

the mapped future

all

public static <T1,T2> CompositeFuture all(Future<T1> f1,
                                                Future<T2> f2)

Parameters:

f1 - future

f2 - future

Returns:

the composite future

all

public static <T1,T2,T3> CompositeFuture all(Future<T1> f1,
                                                         Future<T2> f2,
                                                         Future<T3> f3)

Parameters:

f1 -

f2 -

f3 -

Returns:

all

public static <T1,T2,T3,T4> CompositeFuture all(Future<T1> f1,
                                                                  Future<T2> f2,
                                                                  Future<T3> f3,
                                                                  Future<T4> f4)

Parameters:

f1 -

f2 -

f3 -

f4 -

Returns:

all

public static <T1,T2,T3,T4,T5> CompositeFuture all(Future<T1> f1,
                                                                           Future<T2> f2,
                                                                           Future<T3> f3,
                                                                           Future<T4> f4,
                                                                           Future<T5> f5)

Parameters:

f1 -

f2 -

f3 -

f4 -

f5 -

Returns:

all

public static <T1,T2,T3,T4,T5,T6> CompositeFuture all(Future<T1> f1,
                                                                                    Future<T2> f2,
                                                                                    Future<T3> f3,
                                                                                    Future<T4> f4,
                                                                                    Future<T5> f5,
                                                                                    Future<T6> f6)

Parameters:

f1 -

f2 -

f3 -

f4 -

f5 -

f6 -

Returns:

all

public static CompositeFuture all(List<Future> futures)

Parameters:

futures -

Returns:

any

public static <T1,T2> CompositeFuture any(Future<T1> f1,
                                                Future<T2> f2)

Parameters:

f1 - future

f2 - future

Returns:

the composite future

any

public static <T1,T2,T3> CompositeFuture any(Future<T1> f1,
                                                         Future<T2> f2,
                                                         Future<T3> f3)

Parameters:

f1 -

f2 -

f3 -

Returns:

any

public static <T1,T2,T3,T4> CompositeFuture any(Future<T1> f1,
                                                                  Future<T2> f2,
                                                                  Future<T3> f3,
                                                                  Future<T4> f4)

Parameters:

f1 -

f2 -

f3 -

f4 -

Returns:

any

public static <T1,T2,T3,T4,T5> CompositeFuture any(Future<T1> f1,
                                                                           Future<T2> f2,
                                                                           Future<T3> f3,
                                                                           Future<T4> f4,
                                                                           Future<T5> f5)

Parameters:

f1 -

f2 -

f3 -

f4 -

f5 -

Returns:

any

public static <T1,T2,T3,T4,T5,T6> CompositeFuture any(Future<T1> f1,
                                                                                    Future<T2> f2,
                                                                                    Future<T3> f3,
                                                                                    Future<T4> f4,
                                                                                    Future<T5> f5,
                                                                                    Future<T6> f6)

Parameters:

f1 -

f2 -

f3 -

f4 -

f5 -

f6 -

Returns:

any

public static CompositeFuture any(List<Future> futures)

Parameters:

futures -

Returns:

join

public static <T1,T2> CompositeFuture join(Future<T1> f1,
                                                 Future<T2> f2)

Parameters:

f1 - future

f2 - future

Returns:

the composite future

join

public static <T1,T2,T3> CompositeFuture join(Future<T1> f1,
                                                          Future<T2> f2,
                                                          Future<T3> f3)

Parameters:

f1 -

f2 -

f3 -

Returns:

join

public static <T1,T2,T3,T4> CompositeFuture join(Future<T1> f1,
                                                                   Future<T2> f2,
                                                                   Future<T3> f3,
                                                                   Future<T4> f4)

Parameters:

f1 -

f2 -

f3 -

f4 -

Returns:

join

public static <T1,T2,T3,T4,T5> CompositeFuture join(Future<T1> f1,
                                                                            Future<T2> f2,
                                                                            Future<T3> f3,
                                                                            Future<T4> f4,
                                                                            Future<T5> f5)

Parameters:

f1 -

f2 -

f3 -

f4 -

f5 -

Returns:

join

public static <T1,T2,T3,T4,T5,T6> CompositeFuture join(Future<T1> f1,
                                                                                     Future<T2> f2,
                                                                                     Future<T3> f3,
                                                                                     Future<T4> f4,
                                                                                     Future<T5> f5,
                                                                                     Future<T6> f6)

Parameters:

f1 -

f2 -

f3 -

f4 -

f5 -

f6 -

Returns:

join

public static CompositeFuture join(List<Future> futures)

Parameters:

futures -

Returns:

setHandler

@Deprecated
public io.smallrye.mutiny.Uni<CompositeFuture> setHandler()

Deprecated.

Description copied from class: Future

Like Future.onComplete().

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Overrides:

setHandler in class Future<CompositeFuture>

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

setHandlerAndAwait

@Deprecated
public CompositeFuture setHandlerAndAwait()

Deprecated.

Description copied from class: Future

Blocking variant of Future.setHandler().

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Overrides:

setHandlerAndAwait in class Future<CompositeFuture>

Returns:

the T instance produced by the operation

onComplete

public io.smallrye.mutiny.Uni<CompositeFuture> onComplete()

Description copied from class: Future

Add a handler to be notified of the result.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Overrides:

onComplete in class Future<CompositeFuture>

Returns:

a reference to this, so it can be used fluently

onCompleteAndAwait

public CompositeFuture onCompleteAndAwait()

Description copied from class: Future

Blocking variant of Future.onComplete().

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Overrides:

onCompleteAndAwait in class Future<CompositeFuture>

Returns:

a reference to this, so it can be used fluently

onSuccess

public CompositeFuture onSuccess(Consumer<CompositeFuture> handler)

Overrides:

onSuccess in class Future<CompositeFuture>

Parameters:

handler - the handler that will be called with the succeeded result

Returns:

a reference to this, so it can be used fluently

onFailure

public CompositeFuture onFailure(Consumer<Throwable> handler)

Overrides:

onFailure in class Future<CompositeFuture>

Parameters:

handler - the handler that will be called with the failed result

Returns:

a reference to this, so it can be used fluently

complete

public void complete()

Overrides:

complete in class Future<CompositeFuture>

tryComplete

public boolean tryComplete()

Overrides:

tryComplete in class Future<CompositeFuture>

Returns:

false when the future is already completed

cause

public Throwable cause(int index)

Parameters:

index - the wrapped future index

Returns:

succeeded

public boolean succeeded(int index)

Parameters:

index - the wrapped future index

Returns:

failed

public boolean failed(int index)

Parameters:

index - the wrapped future index

Returns:

isComplete

public boolean isComplete(int index)

Parameters:

index - the wrapped future index

Returns:

resultAt

public <T> T resultAt(int index)

Parameters:

index - the wrapped future index

Returns:

size

public int size()

Returns:

the number of wrapped future

newInstance

public static CompositeFuture newInstance(io.vertx.core.CompositeFuture arg)