Interface Promise<C>

Type Parameters:
C - the type of the result value
All Known Implementing Classes:
AbstractHttpTransport.Writer, Promise.Completable, Promise.Wrapper
public interface Promise<C>

The future result of an operation, either a value if the operation succeeded, or a failure if the operation failed.

  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Interface
    Description
    static class 
    Promise.Completable<S>
    A CompletableFuture that is also a Promise.
    static class 
    Promise.Wrapper<W>
    A wrapper for Promise instances.

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final Promise<?>
    NOOP
    Shared instance whose methods are implemented empty,

  • Method Summary

    Modifier and Type
    Method
    Description
    default BiConsumer<C, Throwable>
    complete()
    Returns a BiConsumer that, when invoked, completes this Promise.
    static <T> Promise<T>
    complete(BiConsumer<T, Throwable> fn)
    Returns a Promise that, when completed, invokes the given BiConsumer function.
    default void
    fail(Throwable failure)
    Callback to invoke when the operation fails.
    static <T> Promise<T>
    from(Consumer<T> succeed, Consumer<Throwable> fail)
     
    static <T> Promise<T>
    noop()
     
    default void
    succeed(C result)
    Callback to invoke when the operation succeeds.

  • Field Details

    • NOOP

      static final Promise<?> NOOP

      Shared instance whose methods are implemented empty,

      use noop() to ease type inference.

  • Method Details

    • succeed

      default void succeed(C result)

      Callback to invoke when the operation succeeds.

      Parameters:
      result - the result
      See Also:

    • fail

      default void fail(Throwable failure)

      Callback to invoke when the operation fails.

      Parameters:
      failure - the operation failure

    • complete

      default BiConsumer<C, Throwable> complete()

      Returns a BiConsumer that, when invoked, completes this Promise.

      Typical usage is with CompletableFuture:

      public void process(ServerMessage message, Promise<Boolean> promise) {
    CompletableFuture.supplyAsync(() -> asyncOperation(message))
            .whenComplete(promise.complete());
}
      Returns:
      a BiConsumer that completes this Promise
      See Also:

    • noop

      static <T> Promise<T> noop()
      Type Parameters:
      T - the type of the empty result
      Returns:
      a Promise whose methods are implemented empty.

    • from

      static <T> Promise<T> from(Consumer<T> succeed, Consumer<Throwable> fail)
      Type Parameters:
      T - the type of the result value
      Parameters:
      succeed - the Consumer to call in case of successful completion
      fail - the Consumer to call in case of failed completion
      Returns:
      a Promise from the given consumers

    • complete

      static <T> Promise<T> complete(BiConsumer<T, Throwable> fn)

      Returns a Promise that, when completed, invokes the given BiConsumer function.

      Type Parameters:
      T - the type of the result value
      Parameters:
      fn - the function to invoke when the Promise is completed
      Returns:
      a Promise that invokes the BiConsumer function