CompositeFuture (Vert.x Stack

All Superinterfaces:

AsyncResult<CompositeFuture>, Future<CompositeFuture>
```
public interface 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.

Author:

Julien Viet

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static <T1,T2> CompositeFuture`	`all(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
`static <T1,T2,T3> CompositeFuture`	`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `all(Future, Future)` but with 3 futures.
`static <T1,T2,T3,T4> CompositeFuture`	`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `all(Future, Future)` but with 4 futures.
`static <T1,T2,T3,T4,T5> CompositeFuture`	`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `all(Future, Future)` but with 5 futures.
`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)` Like `all(Future, Future)` but with 6 futures.
`static CompositeFuture`	`all(List<Future> futures)` Like `all(Future, Future)` but with a list of futures.
`static <T1,T2> CompositeFuture`	`any(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when any futures is succeeded, failed when all futures are failed.
`static <T1,T2,T3> CompositeFuture`	`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `any(Future, Future)` but with 3 futures.
`static <T1,T2,T3,T4> CompositeFuture`	`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `any(Future, Future)` but with 4 futures.
`static <T1,T2,T3,T4,T5> CompositeFuture`	`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `any(Future, Future)` but with 5 futures.
`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)` Like `any(Future, Future)` but with 6 futures.
`static CompositeFuture`	`any(List<Future> futures)` Like `any(Future, Future)` but with a list of futures.
`Throwable`	`cause(int index)` Returns a cause of a wrapped future
`default List<Throwable>`	`causes()`
`boolean`	`failed(int index)` Returns true if a wrapped future is failed
`boolean`	`isComplete(int index)` Returns true if a wrapped future is completed
`static <T1,T2> CompositeFuture`	`join(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
`static <T1,T2,T3> CompositeFuture`	`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `join(Future, Future)` but with 3 futures.
`static <T1,T2,T3,T4> CompositeFuture`	`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `join(Future, Future)` but with 4 futures.
`static <T1,T2,T3,T4,T5> CompositeFuture`	`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `join(Future, Future)` but with 5 futures.
`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)` Like `join(Future, Future)` but with 6 futures.
`static CompositeFuture`	`join(List<Future> futures)` Like `join(Future, Future)` but with a list of futures.
`default <T> List<T>`	`list()`
`CompositeFuture`	`onComplete(Handler<AsyncResult<CompositeFuture>> handler)` Add a handler to be notified of the result.
`default CompositeFuture`	`onFailure(Handler<Throwable> handler)` Add a handler to be notified of the failed result.
`default CompositeFuture`	`onSuccess(Handler<CompositeFuture> handler)` Add a handler to be notified of the succeeded result.
`<T> T`	`resultAt(int index)` Returns the result of a wrapped future
`int`	`size()`
`boolean`	`succeeded(int index)` Returns true if a wrapped future is succeeded

Methods inherited from interface io.vertx.core.Future
cause, compose, compose, eventually, failed, failedFuture, failedFuture, flatMap, fromCompletionStage, fromCompletionStage, future, isComplete, map, map, mapEmpty, otherwise, otherwise, otherwiseEmpty, recover, result, succeeded, succeededFuture, succeededFuture, toCompletionStage, transform

Method Detail

all
```
static <T1,T2> CompositeFuture all(Future<T1> f1,
                                   Future<T2> f2)
```
Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
The returned future fails as soon as one of f1 or f2 fails.

Parameters:

f1 - future

f2 - future

Returns:

the composite future

all

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

Like all(Future, Future) but with 3 futures.

all

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

Like all(Future, Future) but with 4 futures.

all

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

Like all(Future, Future) but with 5 futures.

all

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)

Like all(Future, Future) but with 6 futures.

all
```
static CompositeFuture all(List<Future> futures)
```
Like all(Future, Future) but with a list of futures.
When the list is empty, the returned future will be already completed.

any
```
static <T1,T2> CompositeFuture any(Future<T1> f1,
                                   Future<T2> f2)
```
Return a composite future, succeeded when any futures is succeeded, failed when all futures are failed.
The returned future succeeds as soon as one of f1 or f2 succeeds.

Parameters:

f1 - future

f2 - future

Returns:

the composite future

any

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

Like any(Future, Future) but with 3 futures.

any

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

Like any(Future, Future) but with 4 futures.

any

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

Like any(Future, Future) but with 5 futures.

any

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)

Like any(Future, Future) but with 6 futures.

any
```
static CompositeFuture any(List<Future> futures)
```
Like any(Future, Future) but with a list of futures.
When the list is empty, the returned future will be already completed.

join
```
static <T1,T2> CompositeFuture join(Future<T1> f1,
                                    Future<T2> f2)
```
Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
It always wait until all its futures are completed and will not fail as soon as one of f1 or f2 fails.

Parameters:

f1 - future

f2 - future

Returns:

the composite future

join

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

Like join(Future, Future) but with 3 futures.

join

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

Like join(Future, Future) but with 4 futures.

join

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

Like join(Future, Future) but with 5 futures.

join

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)

Like join(Future, Future) but with 6 futures.

join
```
static CompositeFuture join(List<Future> futures)
```
Like join(Future, Future) but with a list of futures.
When the list is empty, the returned future will be already completed.

onComplete
```
CompositeFuture onComplete(Handler<AsyncResult<CompositeFuture>> handler)
```
Description copied from interface: Future

Add a handler to be notified of the result.

Specified by:

onComplete in interface Future<CompositeFuture>

Parameters:

handler - the handler that will be called with the result

Returns:

a reference to this, so it can be used fluently

onSuccess
```
default CompositeFuture onSuccess(Handler<CompositeFuture> handler)
```
Description copied from interface: Future

Add a handler to be notified of the succeeded result.

Specified by:

onSuccess in interface 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
```
default CompositeFuture onFailure(Handler<Throwable> handler)
```
Description copied from interface: Future

Add a handler to be notified of the failed result.

Specified by:

onFailure in interface 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

cause
```
Throwable cause(int index)
```
Returns a cause of a wrapped future

Parameters:

index - the wrapped future index

succeeded
```
boolean succeeded(int index)
```
Returns true if a wrapped future is succeeded

Parameters:

index - the wrapped future index

failed
```
boolean failed(int index)
```
Returns true if a wrapped future is failed

Parameters:

index - the wrapped future index

isComplete
```
boolean isComplete(int index)
```
Returns true if a wrapped future is completed

Parameters:

index - the wrapped future index

resultAt
```
<T> T resultAt(int index)
```
Returns the result of a wrapped future

Parameters:

index - the wrapped future index

size
```
int size()
```
Returns:

the number of wrapped future

list
```
default <T> List<T> list()
```
Returns:

a list of the current completed values. If one future is not yet resolved or is failed, null will be used

causes
```
default List<Throwable> causes()
```
Returns:

a list of all the eventual failure causes. If no future failed, returns a list of null values.

Interface CompositeFuture

Method Summary

Methods inherited from interface io.vertx.core.Future

Method Detail

all

all

all

all

all

all

any

any

any

any

any

any

join

join

join

join

join

join

onComplete

onSuccess

onFailure

cause

succeeded

failed

isComplete

resultAt

size

list

causes