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.

- `Anything`
  - `Object`
    - `Basic` ...and other supertypes
      - `Future`
        - `CompositeFuture`

- `CompositeFuture`
  - `Future`
    - `Basic`
      - `Identifiable`
      - `Object`
        - `Anything`

no subtypes hierarchy

Initializer
`CompositeFuture(CompositeFuture unknown)`

Inherited Attributes
Attributes inherited from: `Object` `hash`, `string`

Methods
`cause` | `shared default Throwable cause(Integer index)` Returns a cause of a wrapped future Parameters: `index` the wrapped future index
`complete` | `shared actual default void complete()` Set this instance as result. Any handler will be called, if there is one, and the future will be marked as completed. Refines `Future.complete`
`complete` | `shared actual default void complete(CompositeFuture result)` Set the result. Any handler will be called, if there is one, and the future will be marked as completed. Parameters: `result` the result
`completer` | `shared actual default Anything(Throwable|CompositeFuture) completer()` Refines `Future.completer`
`compose` | `shared actual default Future<U?> compose<U>(Future<U?>(CompositeFuture) 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. Parameters: `mapper` the mapper function Refines `Future.compose`
`compose` | `shared actual default Future<U?> compose<U>(Anything(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. Parameters: `handler` the handler `next` the next future Refines `Future.compose`
`failed` | `shared default Boolean failed(Integer index)` Returns true if a wrapped future is failed Parameters: `index` the wrapped future index
`isComplete` | `shared default Boolean isComplete(Integer index)` Returns true if a wrapped future is completed Parameters: `index` the wrapped future index
`map` | `shared actual default Future<U?> map<U>(U?(CompositeFuture) 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. Parameters: `mapper` the mapper function Refines `Future.map`
`otherwise` | `shared actual default 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. Parameters: `value` the value that eventually completes the mapped future
`otherwise` | `shared actual default Future<CompositeFuture> otherwise(CompositeFuture(Throwable) 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. Parameters: `mapper` the mapper function Refines `Future.otherwise`
`otherwiseEmpty` | `shared actual default 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. Refines `Future.otherwiseEmpty`
`recover` | `shared actual default Future<CompositeFuture> recover(Future<CompositeFuture>(Throwable) 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. Parameters: `mapper` A function which takes the exception of a failure and returns a new future. Refines `Future.recover`
`result` | `shared actual default CompositeFuture result()` The result of the operation. This will be null if the operation failed. Refines `Future.result`
`resultAt` | `shared default T? resultAt<T>(Integer index)` Returns the result of a wrapped future Parameters: `index` the wrapped future index
`setHandler` | `shared actual default CompositeFuture setHandler(Anything(Throwable|CompositeFuture) handler)` 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. Refines `Future.setHandler`
`size` | `shared default Integer size()`
`succeeded` | `shared default Boolean succeeded(Integer index)` Returns true if a wrapped future is succeeded Parameters: `index` the wrapped future index
`tryComplete` | `shared actual default 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. Refines `Future.tryComplete`
`tryComplete` | `shared actual default Boolean tryComplete(CompositeFuture result)` Set the failure. Any handler will be called, if there is one, and the future will be marked as completed. Parameters: `result` the result

Inherited Methods
Methods inherited from: `Future<T>` `cause()`, `complete()`, `completer()`, `compose()`, `fail()`, `failed()`, `isComplete()`, `map()`, `mapEmpty()`, `otherwise()`, `otherwiseEmpty()`, `recover()`, `result()`, `setHandler()`, `succeeded()`, `tryComplete()`, `tryFail()`
Methods inherited from: `Object` `equals`