Package io.vertx.rxjava3.ext.unit

## Class Completion<T>

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

- All Implemented Interfaces:
    `io.vertx.lang.rx.RxDelegate`
  Direct Known Subclasses:
    `Async`, `TestCompletion`

      public class Completion<T>
      extends Object
      implements io.vertx.lang.rx.RxDelegate

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

  - ### Constructor Summary

    Constructors
    Constructor | 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 | Description
    --- | --- | ---
    `void` | `await()` | Cause the current thread to wait until this completion completes.
    `void` | `await​(long timeoutMillis)` | Cause the current thread to wait until this completion completes with a configurable timeout.
    `void` | `awaitSuccess()` | Cause the current thread to wait until this completion completes and succeeds.
    `void` | `awaitSuccess​(long timeoutMillis)` | Cause the current thread to wait until this completion completes and succeeds with a configurable timeout.
    `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.
    `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()

      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`

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

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

    - #### handler

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

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

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