org.apache.ignite.lang

## Interface IgniteFuture<V>

- Type Parameters:
    `V` - Type of the result for the future.
  All Known Subinterfaces:
    ComputeTaskFuture<R>, SchedulerFuture<R>

      public interface IgniteFuture<V>

  Future with simplified exception handling, functional programming support and ability to listen for future completion via functional callback.

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `cancel()` Cancels this future.
    `<T> IgniteFuture<T>` | `chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)` Make a chained future to convert result of this future (when complete) into a new format.
    `<T> IgniteFuture<T>` | `chainAsync(IgniteClosure<? super IgniteFuture<V>,T> doneCb, Executor exec)` Make a chained future to convert result of this future (when complete) into a new format.
    `V` | `get()` Synchronously waits for completion of the computation and returns computation result.
    `V` | `get(long timeout)` Synchronously waits for completion of the computation for up to the timeout specified and returns computation result.
    `V` | `get(long timeout, TimeUnit unit)` Synchronously waits for completion of the computation for up to the timeout specified and returns computation result.
    `boolean` | `isCancelled()` Returns `true` if this task was cancelled before it completed normally.
    `boolean` | `isDone()` Returns `true` if this task completed.
    `void` | `listen(IgniteInClosure<? super IgniteFuture<V>> lsnr)` Registers listener closure to be asynchronously notified whenever future completes.
    `void` | `listenAsync(IgniteInClosure<? super IgniteFuture<V>> lsnr, Executor exec)` Registers listener closure to be asynchronously notified whenever future completes.

- - ### Method Detail

    - #### get

          V get()
          throws IgniteException

      Synchronously waits for completion of the computation and returns computation result.
      Returns:
        Computation result.
      Throws:
        `IgniteInterruptedException` - Subclass of `IgniteException` thrown if the wait was interrupted.
        `IgniteFutureCancelledException` - Subclass of `IgniteException` thrown if computation was cancelled.
        `IgniteException` - If computation failed.

    - #### get

          V get(long timeout)
          throws IgniteException

      Synchronously waits for completion of the computation for up to the timeout specified and returns computation result. This method is equivalent to calling `get(long, TimeUnit.MILLISECONDS)`.
      Parameters:
        `timeout` - The maximum time to wait in milliseconds.
      Returns:
        Computation result.
      Throws:
        `IgniteInterruptedException` - Subclass of `IgniteException` thrown if the wait was interrupted.
        `IgniteFutureCancelledException` - Subclass of `IgniteException` thrown if computation was cancelled.
        `IgniteFutureTimeoutException` - Subclass of `IgniteException` thrown if the wait was timed out.
        `IgniteException` - If computation failed.

    - #### get

          V get(long timeout,
                TimeUnit unit)
          throws IgniteException

      Synchronously waits for completion of the computation for up to the timeout specified and returns computation result.
      Parameters:
        `timeout` - The maximum time to wait.
        `unit` - The time unit of the `timeout` argument.
      Returns:
        Computation result.
      Throws:
        `IgniteInterruptedException` - Subclass of `IgniteException` thrown if the wait was interrupted.
        `IgniteFutureCancelledException` - Subclass of `IgniteException` thrown if computation was cancelled.
        `IgniteFutureTimeoutException` - Subclass of `IgniteException` thrown if the wait was timed out.
        `IgniteException` - If computation failed.

    - #### cancel

          boolean cancel()
                  throws IgniteException

      Cancels this future.
      Returns:
        `True` if future was canceled (i.e. was not finished prior to this call).
      Throws:
        `IgniteException` - If cancellation failed.

    - #### isCancelled

          boolean isCancelled()

      Returns `true` if this task was cancelled before it completed normally.
      Returns:
        `true` if this task was cancelled before it completed

    - #### isDone

          boolean isDone()

      Returns `true` if this task completed.

      Completion may be due to normal termination, an exception, or cancellation - in all of these cases, this method will return `true`.

      Returns:
        `true` if this task completed.

    - #### listen

          void listen(IgniteInClosure<? super IgniteFuture<V>> lsnr)

      Registers listener closure to be asynchronously notified whenever future completes. Closure will be processed in thread that completes this future or (if future already completed) immediately in current thread.
      Parameters:
        `lsnr` - Listener closure to register. Cannot be `null`.

    - #### listenAsync

          void listenAsync(IgniteInClosure<? super IgniteFuture<V>> lsnr,
                           Executor exec)

      Registers listener closure to be asynchronously notified whenever future completes. Closure will be processed in specified executor.
      Parameters:
        `lsnr` - Listener closure to register. Cannot be `null`.
        `exec` - Executor to run listener. Cannot be `null`.

    - #### chain

          <T> IgniteFuture<T> chain(IgniteClosure<? super IgniteFuture<V>,T> doneCb)

      Make a chained future to convert result of this future (when complete) into a new format. It is guaranteed that done callback will be called only ONCE.
      Parameters:
        `doneCb` - Done callback that is applied to this future when it finishes to produce chained future result.
      Returns:
        Chained future that finishes after this future completes and done callback is called.

    - #### chainAsync

          <T> IgniteFuture<T> chainAsync(IgniteClosure<? super IgniteFuture<V>,T> doneCb,
                                         Executor exec)

      Make a chained future to convert result of this future (when complete) into a new format. It is guaranteed that done callback will be called only ONCE.
      Parameters:
        `doneCb` - Done callback that is applied to this future when it finishes to produce chained future result.
        `exec` - Executor to run done callback. Cannot be `null`.
      Returns:
        Chained future that finishes after this future completes and done callback is called.

2020 Copyright © Apache Software Foundation
| Follow @ApacheIgnite
Ignite Database and Caching Platform | : ver. 2.9.1
Release Date | : December 9 2020