io.vertx.rxjava.core

## Class CompositeFuture

- java.lang.Object
- - io.vertx.rxjava.core.Future<CompositeFuture>
  - - io.vertx.rxjava.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.

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

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static TypeArg<CompositeFuture>` | `__TYPE_ARG`

    - ### Fields inherited from class io.vertx.rxjava.core.Future

      `__typeArg_0`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `CompositeFuture(CompositeFuture delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static CompositeFuture` | `all(List<Future> futures)` Like `all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static CompositeFuture` | `any(List<Future> futures)` Like `any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with a list of futures.
    `Throwable` | `cause(int index)` Returns a cause of a wrapped future
    `void` | `complete()` Set this instance as result.
    `void` | `complete(CompositeFuture result)` Set the result.
    `Handler<AsyncResult<CompositeFuture>>` | `completer()`
    `<U> Future<U>` | `compose(java.util.function.Function<CompositeFuture,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | `compose(Handler<CompositeFuture> handler, Future<U> next)` Compose this future with a provided `next` future.
    `boolean` | `failed(int index)` Returns true if a wrapped future is failed
    `CompositeFuture` | `getDelegate()`
    `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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` 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(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static CompositeFuture` | `join(List<Future> futures)` Like `join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with a list of futures.
    `<U> Future<U>` | `map(java.util.function.Function<CompositeFuture,U> mapper)` Apply a `mapper` function on this future.
    `static CompositeFuture` | `newInstance(CompositeFuture arg)`
    `Future<CompositeFuture>` | `otherwise(CompositeFuture value)` Map the failure of a future to a specific `value`.
    `Future<CompositeFuture>` | `otherwise(java.util.function.Function<Throwable,CompositeFuture> mapper)` Apply a `mapper` function on this future.
    `Future<CompositeFuture>` | `otherwiseEmpty()` Map the failure of a future to `null`.
    `Future<CompositeFuture>` | `recover(java.util.function.Function<Throwable,Future<CompositeFuture>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `CompositeFuture` | `result()` The result of the operation.
    `<T> T` | `resultAt(int index)` Returns the result of a wrapped future
    `rx.Single<CompositeFuture>` | `rxSetHandler()` Set a handler for the result.
    `CompositeFuture` | `setHandler(Handler<AsyncResult<CompositeFuture>> handler)` Set a handler for the result.
    `rx.Observable<CompositeFuture>` | `setHandlerObservable()` Deprecated.
    `int` | `size()`
    `boolean` | `succeeded(int index)` Returns true if a wrapped future is succeeded
    `boolean` | `tryComplete()` Try to set this instance as result.
    `boolean` | `tryComplete(CompositeFuture result)` Set the failure.

    - ### Methods inherited from class io.vertx.rxjava.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, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final TypeArg<CompositeFuture> __TYPE_ARG

  - ### Constructor Detail

    - #### CompositeFuture

          public CompositeFuture(CompositeFuture delegate)

  - ### Method Detail

    - #### getDelegate

          public CompositeFuture getDelegate()

      Overrides:
        `getDelegate` in class `Future<CompositeFuture>`

    - #### complete

          public void complete(CompositeFuture result)

      Set the result. Any handler will be called, if there is one, and the future will be marked as completed.
      Overrides:
        `complete` in class `Future<CompositeFuture>`
      Parameters:
        `result` - the result

    - #### tryComplete

          public boolean tryComplete(CompositeFuture result)

      Set the failure. Any handler will be called, if there is one, and the future will be marked as completed.
      Overrides:
        `tryComplete` in class `Future<CompositeFuture>`
      Parameters:
        `result` - the result
      Returns:
        false when the future is already completed

    - #### result

          public CompositeFuture result()

      The result of the operation. This will be null if the operation failed.
      Overrides:
        `result` in class `Future<CompositeFuture>`
      Returns:
        the result or null if the operation failed.

    - #### compose

          public <U> Future<U> compose(Handler<CompositeFuture> handler,
                                       Future<U> next)

      Compose this future with a provided `next` future.

      When this (the one on which `compose` is called) future succeeds, the `handler` will be called with the completed value, this handler should complete the next future.

      If the `handler` throws an exception, the returned future will be failed with this exception.

      When this future fails, the failure will be propagated to the `next` future and the `handler` will not be called.

      Overrides:
        `compose` in class `Future<CompositeFuture>`
      Parameters:
        `handler` - the handler
        `next` - the next future
      Returns:
        the next future, used for chaining

    - #### compose

          public <U> Future<U> compose(java.util.function.Function<CompositeFuture,Future<U>> mapper)

      Compose this future with a `mapper` function.

      When this future (the one on which `compose` is called) succeeds, the `mapper` will be called with the completed value and this mapper returns another future object. This returned future completion will complete the future returned by this method call.

      If the `mapper` throws an exception, the returned future will be failed with this exception.

      When this future fails, the failure will be propagated to the returned future and the `mapper` will not be called.

      Overrides:
        `compose` in class `Future<CompositeFuture>`
      Parameters:
        `mapper` - the mapper function
      Returns:
        the composed future

    - #### map

          public <U> Future<U> map(java.util.function.Function<CompositeFuture,U> mapper)

      Apply a `mapper` function on this future.

      When this future succeeds, the `mapper` will be called with the completed value and this mapper returns a value. This value will complete the future returned by this method call.

      If the `mapper` throws an exception, the returned future will be failed with this exception.

      When this future fails, the failure will be propagated to the returned future and the `mapper` will not be called.

      Overrides:
        `map` in class `Future<CompositeFuture>`
      Parameters:
        `mapper` - the mapper function
      Returns:
        the mapped future

    - #### completer

          public Handler<AsyncResult<CompositeFuture>> completer()

      Overrides:
        `completer` in class `Future<CompositeFuture>`
      Returns:
        an handler completing this future

    - #### recover

          public Future<CompositeFuture> recover(java.util.function.Function<Throwable,Future<CompositeFuture>> mapper)

      Handles a failure of this Future by returning the result of another Future. If the mapper fails, then the returned future will be failed with this failure.
      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(java.util.function.Function<Throwable,CompositeFuture> mapper)

      Apply a `mapper` function on this future.

      When this future fails, the `mapper` will be called with the completed value and this mapper returns a value. This value will complete the future returned by this method call.

      If the `mapper` throws an exception, the returned future will be failed with this exception.

      When this future succeeds, the result will be propagated to the returned future and the `mapper` will not be called.

      Overrides:
        `otherwise` in class `Future<CompositeFuture>`
      Parameters:
        `mapper` - the mapper function
      Returns:
        the mapped future

    - #### otherwise

          public Future<CompositeFuture> otherwise(CompositeFuture value)

      Map the failure of a future to a specific `value`.

      When this future fails, this `value` will complete the future returned by this method call.

      When this future succeeds, the result will be propagated to the returned future.

      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()

      Map the failure of a future to `null`.

      This is a convenience for `future.otherwise((T) null)`.

      When this future fails, the `null` value will complete the future returned by this method call.

      When this future succeeds, the result will be propagated to the returned future.

      Overrides:
        `otherwiseEmpty` in class `Future<CompositeFuture>`
      Returns:
        the mapped future

    - #### all

          public 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

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

      Like `all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
      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)

      Like `all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
      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)

      Like `all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
      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)

      Like `all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
      Parameters:
        `f1` -
        `f2` -
        `f3` -
        `f4` -
        `f5` -
        `f6` -
      Returns:

    - #### all

          public static CompositeFuture all(List<Future> futures)

      Like `all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with a list of futures.

      When the list is empty, the returned future will be already completed.

      Parameters:
        `futures` -
      Returns:

    - #### any

          public 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

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

      Like `any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
      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)

      Like `any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
      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)

      Like `any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
      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)

      Like `any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
      Parameters:
        `f1` -
        `f2` -
        `f3` -
        `f4` -
        `f5` -
        `f6` -
      Returns:

    - #### any

          public static CompositeFuture any(List<Future> futures)

      Like `any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with a list of futures.

      When the list is empty, the returned future will be already completed.

      Parameters:
        `futures` -
      Returns:

    - #### join

          public 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

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

      Like `join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
      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)

      Like `join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
      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)

      Like `join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
      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)

      Like `join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
      Parameters:
        `f1` -
        `f2` -
        `f3` -
        `f4` -
        `f5` -
        `f6` -
      Returns:

    - #### join

          public static CompositeFuture join(List<Future> futures)

      Like `join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with a list of futures.

      When the list is empty, the returned future will be already completed.

      Parameters:
        `futures` -
      Returns:

    - #### setHandler

          public CompositeFuture setHandler(Handler<AsyncResult<CompositeFuture>> handler)

      Description copied from class: `Future`
      Set a handler for the result.

      If the future has already been completed it will be called immediately. Otherwise it will be called when the future is completed.

      Overrides:
        `setHandler` in class `Future<CompositeFuture>`
      Parameters:
        `handler` - the Handler that will be called with the result
      Returns:
        a reference to this, so it can be used fluently

    - #### setHandlerObservable

          @Deprecated
          public rx.Observable<CompositeFuture> setHandlerObservable()

      Deprecated.
      Description copied from class: `Future`
      Set a handler for the result.

      If the future has already been completed it will be called immediately. Otherwise it will be called when the future is completed.

      Overrides:
        `setHandlerObservable` in class `Future<CompositeFuture>`
      Returns:

    - #### rxSetHandler

          public rx.Single<CompositeFuture> rxSetHandler()

      Description copied from class: `Future`
      Set a handler for the result.

      If the future has already been completed it will be called immediately. Otherwise it will be called when the future is completed.

      Overrides:
        `rxSetHandler` in class `Future<CompositeFuture>`
      Returns:

    - #### complete

          public void complete()

      Set this instance as result. Any handler will be called, if there is one, and the future will be marked as completed.
      Overrides:
        `complete` in class `Future<CompositeFuture>`

    - #### tryComplete

          public 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.
      Overrides:
        `tryComplete` in class `Future<CompositeFuture>`
      Returns:
        false when the future is already completed

    - #### cause

          public Throwable cause(int index)

      Returns a cause of a wrapped future
      Parameters:
        `index` - the wrapped future index
      Returns:

    - #### succeeded

          public boolean succeeded(int index)

      Returns true if a wrapped future is succeeded
      Parameters:
        `index` - the wrapped future index
      Returns:

    - #### failed

          public boolean failed(int index)

      Returns true if a wrapped future is failed
      Parameters:
        `index` - the wrapped future index
      Returns:

    - #### isComplete

          public boolean isComplete(int index)

      Returns true if a wrapped future is completed
      Parameters:
        `index` - the wrapped future index
      Returns:

    - #### resultAt

          public <T> T resultAt(int index)

      Returns the result of a wrapped future
      Parameters:
        `index` - the wrapped future index
      Returns:

    - #### size

          public int size()

      Returns:
        the number of wrapped future

    - #### newInstance

          public static CompositeFuture newInstance(CompositeFuture arg)

Copyright © 2017. All rights reserved.