io.vertx.reactivex.ext.unit

## Class Completion<T>

- java.lang.Object
- - io.vertx.reactivex.ext.unit.Completion<T>

- Direct Known Subclasses:
    Async, TestCompletion

      public class Completion<T>
      extends Object

  A completion object that emits completion notifications either succeeded or failed.

  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 io.vertx.lang.rx.TypeArg<Completion>` | `__TYPE_ARG`
    `io.vertx.lang.rx.TypeArg<T>` | `__typeArg_0`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Completion(Completion delegate)`
    `Completion(Object delegate, io.vertx.lang.rx.TypeArg<T> typeArg_0)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `await()` Cause the current thread to wait until this completion completes. If the current thread is interrupted, an exception will be thrown.
    `void` | `await(long timeoutMillis)` Cause the current thread to wait until this completion completes with a configurable timeout. If completion times out or the current thread is interrupted, an exception will be thrown.
    `void` | `awaitSuccess()` Cause the current thread to wait until this completion completes and succeeds. If the current thread is interrupted or the suite fails, an exception will be thrown.
    `void` | `awaitSuccess(long timeoutMillis)` Cause the current thread to wait until this completion completes and succeeds with a configurable timeout. If completion times out or the current thread is interrupted or the suite fails, an exception will be thrown.
    `boolean` | `equals(Object o)`
    `Completion` | `getDelegate()`
    `void` | `handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `int` | `hashCode()`
    `boolean` | `isCompleted()`
    `boolean` | `isFailed()`
    `boolean` | `isSucceeded()`
    `static <T> Completion<T>` | `newInstance(Completion arg)`
    `static <T> Completion<T>` | `newInstance(Completion arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T)`
    `void` | `resolve(Promise<T> future)` Completes the future upon completion, otherwise fails it.
    `Maybe<T>` | `rxHandler()` Completion handler to receive a completion signal when this completions completes.
    `String` | `toString()`

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<Completion> __TYPE_ARG

    - #### __typeArg_0

          public final io.vertx.lang.rx.TypeArg<T> __typeArg_0

  - ### Constructor Detail

    - #### Completion

          public Completion(Completion delegate)

    - #### Completion

          public Completion(Object delegate,
                            io.vertx.lang.rx.TypeArg<T> typeArg_0)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public Completion getDelegate()

    - #### resolve

          public void resolve(Promise<T> future)

      Completes the future upon completion, otherwise fails it.
      Parameters:
        `future` - the future to resolve

    - #### isCompleted

          public boolean isCompleted()

      Returns:
        true if this completion is completed

    - #### isSucceeded

          public boolean isSucceeded()

      Returns:
        true if this completion is completed and succeeded

    - #### isFailed

          public boolean isFailed()

      Returns:
        true if the this completion is completed and failed

    - #### handler

          public void handler(Handler<AsyncResult<T>> completionHandler)

      Completion handler to receive a completion signal when this completions completes.
      Parameters:
        `completionHandler` - the completion handler

    - #### rxHandler

          public Maybe<T> rxHandler()

      Completion handler to receive a completion signal when this completions completes.
      Returns:

    - #### await

          public void await()

      Cause the current thread to wait until this completion completes.

      If the current thread is interrupted, an exception will be thrown.

    - #### await

          public void await(long timeoutMillis)

      Cause the current thread to wait until this completion completes with a configurable timeout.

      If completion times out or the current thread is interrupted, an exception will be thrown.
      Parameters:
        `timeoutMillis` - the timeout in milliseconds

    - #### awaitSuccess

          public void awaitSuccess()

      Cause the current thread to wait until this completion completes and succeeds.

      If the current thread is interrupted or the suite fails, an exception will be thrown.

    - #### awaitSuccess

          public void awaitSuccess(long timeoutMillis)

      Cause the current thread to wait until this completion completes and succeeds with a configurable timeout.

      If completion times out or the current thread is interrupted or the suite fails, an exception will be thrown.
      Parameters:
        `timeoutMillis` - the timeout in milliseconds

    - #### newInstance

          public static <T> Completion<T> newInstance(Completion arg)

    - #### newInstance

          public static <T> Completion<T> newInstance(Completion arg,
                                                      io.vertx.lang.rx.TypeArg<T> __typeArg_T)

Copyright © 2022 Eclipse. All rights reserved.