Example usage for com.google.common.util.concurrent Futures addCallback

Introduction

In this page you can find the example usage for com.google.common.util.concurrent Futures addCallback.

Prototype

public static <V> void addCallback(final ListenableFuture<V> future, final FutureCallback<? super V> callback,
        Executor executor)

Source Link

Document

Registers separate success and failure callbacks to be run when the Future 's computation is java.util.concurrent.Future#isDone() complete or, if the computation is already complete, immediately.

Usage

From source file:org.thingsboard.server.kafka.AsyncCallbackTemplate.java

public static <T> void withCallback(ListenableFuture<T> future, Consumer<T> onSuccess,
        Consumer<Throwable> onFailure, Executor executor) {
    FutureCallback<T> callback = new FutureCallback<T>() {
        @Override/*from w w  w. ja v a 2  s . c om*/
        public void onSuccess(T result) {
            try {
                onSuccess.accept(result);
            } catch (Throwable th) {
                onFailure(th);
            }
        }

        @Override
        public void onFailure(Throwable t) {
            onFailure.accept(t);
        }
    };
    if (executor != null) {
        Futures.addCallback(future, callback, executor);
    } else {
        Futures.addCallback(future, callback);
    }
}

From source file:org.opendaylight.sfc.genius.impl.utils.SfcGeniusUtils.java

/**
 * Adapts a {@link ListenableFuture} to a {@link CompletableFuture}. The
 * provided executor is used to execute the callback as per
 * {@link Futures#addCallback(ListenableFuture, FutureCallback, Executor)}
 * On such callback, completion will be performed.
 *
 * @param listenableFuture//  w w  w .j a  v  a 2s  .  c om
 *            the listenable future to adapt.
 * @param executor
 *            the executor where the callback execution is submitted.
 * @param <T>
 *            the type of the listenable future.
 * @return the completable future.
 */
public static <T> CompletableFuture<T> toCompletableFuture(final ListenableFuture<T> listenableFuture,
        Executor executor) {

    CompletableFuture<T> completable = new CompletableFuture<T>() {
        @Override
        public boolean cancel(boolean mayInterruptIfRunning) {
            boolean result = listenableFuture.cancel(mayInterruptIfRunning);
            super.cancel(mayInterruptIfRunning);
            return result;
        }
    };

    Futures.addCallback(listenableFuture, new FutureCallback<T>() {
        @Override
        public void onSuccess(@Nullable T listenable) {
            completable.complete(listenable);
        }

        @Override
        public void onFailure(Throwable throwable) {
            completable.completeExceptionally(throwable);
        }
    }, executor);
    return completable;
}

From source file:org.opendaylight.netconf.topology.impl.OnlySuccessStateAggregator.java

@Override
public ListenableFuture<Node> combineCreateAttempts(List<ListenableFuture<Node>> stateFutures) {
    final SettableFuture<Node> future = SettableFuture.create();
    final ListenableFuture<List<Node>> allAsList = Futures.allAsList(stateFutures);
    Futures.addCallback(allAsList, new FutureCallback<List<Node>>() {
        @Override/* w  ww  . ja v a2  s  .co m*/
        public void onSuccess(List<Node> result) {
            for (int i = 0; i < result.size() - 1; i++) {
                if (!result.get(i).equals(result.get(i + 1))) {
                    future.setException(new IllegalStateException("Create futures have different result"));
                }
            }
            future.set(result.get(0));
        }

        @Override
        public void onFailure(Throwable t) {
            LOG.error("One of the combined create attempts failed {}", t);
            future.setException(t);
        }
    }, TypedActor.context().dispatcher());

    return future;
}

From source file:io.airlift.http.server.AsyncResponseHandler.java

public static AsyncResponseHandler bindAsyncResponse(AsyncResponse asyncResponse,
        ListenableFuture<?> futureResponse, Executor httpResponseExecutor) {
    FutureCallback<Object> callback = toFutureCallback(asyncResponse);
    Futures.addCallback(futureResponse, callback, httpResponseExecutor);
    return new AsyncResponseHandler(asyncResponse, futureResponse);
}

From source file:com.orangerhymelabs.helenus.cassandra.database.DatabaseService.java

public void exists(String name, FutureCallback<Boolean> callback) {
    Futures.addCallback(exists(name), callback, MoreExecutors.directExecutor());
}

From source file:com.ecomnext.play.futures.GuavaFutures.java

/**
 * Converts a {@link ListenableFuture} into a {@link Future}.
 * @param lf the {@link ListenableFuture} to register a listener on.
 * @param executor the {@link Executor} where the callback will be executed.
 * @return a {@link Future} that emits the value when the future completes.
 *///from w ww  .j  a va2  s.  c  o  m
public static <V> Future<V> asScalaFuture(final ListenableFuture<V> lf, final Executor executor) {
    Promise<V> promise = akka.dispatch.Futures.promise();
    Futures.addCallback(lf, new FutureCallbackAdapter<>(promise), executor);
    return promise.future();
}

From source file:com.salesforce.grpc.contrib.MoreFutures.java

/**
 * Registers separate success and failure callbacks to be run when the {@code Future}'s
 * computation is {@linkplain java.util.concurrent.Future#isDone() complete} or, if the
 * computation is already complete, immediately.
 *
 * @see Futures#addCallback(ListenableFuture, FutureCallback, Executor)
 * @param future The future attach the callback to.
 * @param success A {@link Consumer} to execute when the future succeeds.
 * @param failure A {@link Consumer} to execute when the future fails.
 * @param executor The executor to run {@code callback} when the future completes.
 *//*from  ww  w.j  a va 2 s  . co  m*/
public static <V> void addCallback(@Nonnull final ListenableFuture<V> future,
        @Nonnull final Consumer<V> success, @Nonnull final Consumer<Throwable> failure,
        @Nonnull final Executor executor) {
    checkNotNull(future, "future");
    checkNotNull(success, "success");
    checkNotNull(failure, "failure");
    checkNotNull(executor, "executor");

    FutureCallback<V> futureCallback = new FutureCallback<V>() {
        @Override
        public void onSuccess(V result) {
            success.accept(result);
        }

        @Override
        public void onFailure(Throwable t) {
            failure.accept(t);
        }
    };
    Futures.addCallback(future, futureCallback, executor);
}

From source file:org.glowroot.central.util.MoreFutures.java

public static <V> ListenableFuture<V> onFailure(ListenableFuture<V> future, Runnable onFailure) {
    SettableFuture<V> outerFuture = SettableFuture.create();
    Futures.addCallback(future, new FutureCallback<V>() {
        @Override//from w w  w . ja va 2  s  .c om
        public void onSuccess(V result) {
            outerFuture.set(result);
        }

        @Override
        public void onFailure(Throwable t) {
            logger.debug(t.getMessage(), t);
            onFailure.run();
            outerFuture.setException(t);
        }
    }, MoreExecutors.directExecutor());
    return outerFuture;
}

From source file:net.javacrumbs.futureconverter.java8guava.FutureConverter.java

private static <T> CompletableFuture<T> buildCompletableFutureFromListenableFuture(
        final ListenableFuture<T> listenableFuture) {
    CompletableFuture<T> completable = new CompletableListenableFuture<T>(listenableFuture);
    Futures.addCallback(listenableFuture, new FutureCallback<T>() {
        @Override//from w w w. j  ava 2s . c o m
        public void onSuccess(T result) {
            completable.complete(result);
        }

        @Override
        public void onFailure(Throwable t) {
            completable.completeExceptionally(t);
        }
    }, MoreExecutors.directExecutor());
    return completable;
}

From source file:com.orangerhymelabs.helenus.cassandra.view.ViewService.java

public void create(View view, FutureCallback<View> callback) {
    Futures.addCallback(create(view), callback, MoreExecutors.directExecutor());
}