CallbackToFutureAdapter

public final class CallbackToFutureAdapter

A utility useful for adapting interfaces that take callbacks into interfaces that return .

It also provides additional safety checks, failing the future if it will never complete.

For example, you work with the following async api: 

class AsyncApi  {
    interface OnResult {
        void onSuccess(Foo foo);
        void onError(Failure failure);
    }

    void load(OnResult onResult) {}
}

Code that wraps it as ListenableFuture would look like: 

ListenableFuture<Foo> asyncOperation() {
    return CallbackToFutureAdapter.getFuture(completer -> {
        asyncApi.load(new OnResult() {
            @Override
            public void onSuccess(Foo foo) {
                completer.set(foo);
            }

            @Override
            public void onError(Failure failure) {
                completer.setException(failure.exception);
            }
        });
        // This value is used only for debug purposes: it will be used in toString()
        // of returned future or error cases.
        return "AsyncApi.load operation";
    });
}

Try to avoid creating references from listeners on the returned Future to the or the passed-in tag object, as this will defeat the best-effort early failure detection based on garbage collection.

Summary

Nested types
public final class CallbackToFutureAdapter.Completer<T>

Used to complete the future returned by getFuture

This interface should be implemented by the object passed into getFuture.

Public methods
static @NonNull ListenableFuture<T>

Returns a Future that will be completed by the Completer provided in attachCompleter.

Public methods

getFuture

Added in 1.0.0
public static @NonNull ListenableFuture<T> <T> getFuture(@NonNull CallbackToFutureAdapter.Resolver<T> callback)

Returns a Future that will be completed by the Completer provided in attachCompleter.

The provided callback is invoked immediately inline. Any exceptions thrown by it will fail the returned Future.