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.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `CompositeFuture(CompositeFuture delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete 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(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
    `Object` | `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 completed when all the futures are completed.
    `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)`
    `CompositeFuture` | `result()` The result of the operation.
    `<T> T` | `resultAt(int index)` Returns the result of a wrapped future
    `CompositeFuture` | `setHandler(Handler<AsyncResult<CompositeFuture>> handler)` Set a handler for the result.
    `Observable<CompositeFuture>` | `setHandlerObservable()` Set a handler for the result.
    `int` | `size()`
    `boolean` | `succeeded(int index)` Returns true if a wrapped future is succeeded

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

      `cause, complete, fail, fail, failed, failedFuture, future, isComplete, map, newInstance, succeeded, succeededFuture, succeededFuture`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### CompositeFuture

          public CompositeFuture(CompositeFuture delegate)

  - ### Method Detail

    - #### getDelegate

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

    - #### 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

    - #### 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 completed when all the futures are completed.

      Succeeded when all futures are succeeded, failed when any future is failed.
      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

          public Observable<CompositeFuture> setHandlerObservable()

      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:

    - #### 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 © 2016. All rights reserved.