Interface Promise<C>

Type Parameters:
C - the type of the result value
All Known Implementing Classes:
Promise.Completable

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 
    A CompletableFuture that is also a Promise.
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static Promise<?>
    Shared instance whose methods are implemented empty,
  • Method Summary

    Modifier and Type
    Method
    Description
    default BiConsumer<C,​Throwable>
    Returns a BiConsumer that, when invoked, completes this Promise.
    static <T> Promise<T>
    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>
     
    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(Throwable)
    • 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:
      Promise.Completable
    • 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