CompositeFuture (Vert.x Stack

All Superinterfaces:

AsyncResult<CompositeFuture>, Future<CompositeFuture>, Handler<AsyncResult<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

Field Summary
- Fields inherited from interface io.vertx.core.Future
  factory

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated 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
`void`	`complete()` Set this instance as result.
`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
`default CompositeFuture`	`setHandler(Handler<AsyncResult<CompositeFuture>> handler)` Deprecated.
`int`	`size()`
`boolean`	`succeeded(int index)` Returns true if a wrapped future is succeeded
`boolean`	`tryComplete()` Try to set this instance as result.

Methods inherited from interface io.vertx.core.Future
cause, complete, completer, compose, compose, compose, fail, fail, failed, failedFuture, failedFuture, flatMap, fromCompletionStage, fromCompletionStage, future, future, handle, isComplete, map, map, mapEmpty, otherwise, otherwise, otherwiseEmpty, recover, result, succeeded, succeededFuture, succeededFuture, toCompletionStage, tryComplete, tryFail, tryFail

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.

setHandler
```
@Deprecated
default CompositeFuture setHandler(Handler<AsyncResult<CompositeFuture>> handler)
```
Deprecated.

Description copied from interface: Future

Like Future.onComplete(Handler).

Specified by:

setHandler in interface Future<CompositeFuture>

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

complete
```
void complete()
```
Set this instance as result. Any handler will be called, if there is one, and the future will be marked as completed.

Specified by:

complete in interface Future<CompositeFuture>

tryComplete
```
boolean tryComplete()
```
Try to set this instance as result. When it happens, any handler will be called, if there is one, and the future will be marked as completed.

Specified by:

tryComplete in interface Future<CompositeFuture>

Returns:

false when the future is already completed

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

Interface CompositeFuture

Field Summary

Fields inherited from interface io.vertx.core.Future

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

setHandler

onComplete

onSuccess

onFailure

complete

tryComplete

cause

succeeded

failed

isComplete

resultAt

size

list