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(ListenableFuture<V> future, FutureCallback<? super V> callback)

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:com.spotify.futures.ListenableToCompletableFutureWrapper.java

ListenableToCompletableFutureWrapper(final ListenableFuture<V> future) {
    this.future = checkNotNull(future, "future");
    Futures.addCallback(future, this);
}

From source file:com.yahoo.parsec.clients.ParsecCompletableFuture.java

/**
 * Constructor.//from   w w w . j  ava 2  s.c  o  m
 *
 * @param future future
 */
public ParsecCompletableFuture(final Future<T> future) {
    if (future instanceof com.ning.http.client.ListenableFuture) {
        this.future = ListenableFutureAdapter.asGuavaFuture((com.ning.http.client.ListenableFuture<T>) future);
    } else {
        this.future = future;
    }

    if (this.future instanceof ListenableFuture) {
        Futures.addCallback((ListenableFuture<T>) this.future, new FutureCallback<T>() {
            @Override
            public void onSuccess(T result) {
                complete(result);
            }

            @Override
            public void onFailure(Throwable t) {
                completeExceptionally(t);
            }
        });
    }
}

From source file:com.microsoft.office.integration.test.ConfigurationAsyncTestCase.java

public void testAuthorization() {
    counter = new CountDownLatch(1);
    // try any request
    Futures.addCallback(Me.init(), new FutureCallback<Void>() {
        public void onFailure(Throwable t) {
            reportError(t);/*w w  w  .  j  a va2s  . c  om*/
            counter.countDown();
        }

        public void onSuccess(Void result) {
            try {
                Me.getAlias();
            } catch (Throwable t) {
                reportError(t);
            }

            counter.countDown();
        }
    });

    try {
        if (!counter.await(60000, TimeUnit.MILLISECONDS)) {
            fail("testAuthorization() timed out");
        }
    } catch (InterruptedException e) {
        fail("testAuthorization() has been interrupted");
    }
}

From source file:com.microsoft.artcurator.net.MessagesLoader.java

/**
 * Marks a Message as read//from w  w w. j  a  v a 2s  . c  om
 *
 * @param client   the client to make the request
 * @param msgId    the Message to mark read
 * @param callback callback to notify on success/failure
 */
public static void markReadAsync(OutlookClient client, String msgId, FutureCallback<String> callback) {
    ListenableFuture<String> future = client.getMe().getMessage(msgId).updateRaw("{\"IsRead\" : true}");
    Futures.addCallback(future, callback);
}

From source file:com.noorq.casser.support.Scala.java

public static <T, A, B> Future<Fun.Tuple3<T, A, B>> asFuture(ListenableFuture<T> future, A a, B b) {
    final scala.concurrent.Promise<Fun.Tuple3<T, A, B>> promise = new DefaultPromise<Fun.Tuple3<T, A, B>>();
    Futures.addCallback(future, new FutureCallback<T>() {
        @Override/*  w w w  .j  a va2 s  . c  o  m*/
        public void onSuccess(T result) {
            promise.success(new Fun.Tuple3<T, A, B>(result, a, b));
        }

        @Override
        public void onFailure(Throwable t) {
            promise.failure(t);
        }
    });
    return promise.future();
}

From source file:com.github.tempora.concurrent.BackgroundTaskExecutor.java

private static <T> void execute(final BackgroundTask<T> task, boolean wait) {
    final ListeningExecutorService service = MoreExecutors.listeningDecorator(
            wait ? MoreExecutors.sameThreadExecutor() : Executors.newSingleThreadExecutor());
    try {//  w ww  . j a v a 2s .co m
        if (task instanceof LifecycleAware) {
            ((LifecycleAware) task).beforeCall();
        }
        final ListenableFuture<T> resultFuture = service.submit(task);
        task.relatedFuture = resultFuture;
        Futures.addCallback(resultFuture, task);
        if (task instanceof LifecycleAware) {
            Futures.addCallback(resultFuture, new FutureCallback<T>() {
                @Override
                public void onSuccess(T result) {
                    ((LifecycleAware) task).afterCall();
                }

                @Override
                public void onFailure(Throwable t) {
                    ((LifecycleAware) task).afterCall();
                }
            });
        }
        if (wait) {
            Futures.getUnchecked(resultFuture);
        }
    } finally {
        service.shutdown();
    }
}

From source file:com.microsoft.services.orc.http.BaseHttpTransport.java

@Override
public ListenableFuture<Response> execute(final Request request) {

    final SettableFuture<Response> future = SettableFuture.create();
    final NetworkRunnable target = createNetworkRunnable(request, future);

    final NetworkThread networkThread = new NetworkThread(target) {
        @Override// w  w w.j a  v  a2s  .  co m
        public void releaseAndStop() {
            try {
                target.closeStreamAndConnection();
            } catch (Throwable ignored) {
            }
        }
    };

    Futures.addCallback(future, new FutureCallback<Response>() {
        @Override
        public void onFailure(Throwable t) {
            networkThread.releaseAndStop();
        }

        @Override
        public void onSuccess(Response response) {
        }
    });

    networkThread.start();
    return future;
}

From source file:com.sk89q.worldedit.util.paste.ActorCallbackPaste.java

/**
 * Submit data to a pastebin service and inform the sender of
 * success or failure.//from w w w  . ja  v  a 2 s .  c  o  m
 *
 * @param supervisor The supervisor instance
 * @param sender The sender
 * @param content The content
 * @param successMessage The message, formatted with {@link String#format(String, Object...)} on success
 */
public static void pastebin(Supervisor supervisor, final Actor sender, String content,
        final String successMessage, final ExceptionConverter exceptionConverter) {
    ListenableFuture<URL> future = new EngineHubPaste().paste(content);

    AsyncCommandHelper.wrap(future, supervisor, sender, exceptionConverter)
            .registerWithSupervisor("Submitting content to a pastebin service...")
            .sendMessageAfterDelay("(Please wait... sending output to pastebin...)");

    Futures.addCallback(future, new FutureCallback<URL>() {
        @Override
        public void onSuccess(URL url) {
            sender.print(String.format(successMessage, url));
        }

        @Override
        public void onFailure(Throwable throwable) {
            LOGGER.warn("Failed to submit pastebin", throwable);
            sender.printError("Failed to submit to a pastebin. Please see console for the error.");
        }
    });
}

From source file:com.kixeye.chassis.transport.websocket.responseconverter.ListenableFutureResponseConverter.java

@Override
public DeferredResult<Object> convertToDeferredResult(Object response) {
    final DeferredResult<Object> deferredResult = new DeferredResult<>();
    Futures.addCallback((ListenableFuture<?>) response, new FutureCallback<Object>() {
        @Override/* ww w.j a v a2s.  c o  m*/
        public void onSuccess(@Nullable Object result) {
            deferredResult.setResult(result);
        }

        @Override
        public void onFailure(Throwable t) {
            deferredResult.setErrorResult(t);
        }
    });
    return deferredResult;
}

From source file:org.opendaylight.genius.mdsalutil.MDSALDataStoreUtils.java

public static <T extends DataObject> void asyncUpdate(final DataBroker broker,
        final LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data,
        FutureCallback<Void> callback) {
    WriteTransaction tx = broker.newWriteOnlyTransaction();
    tx.merge(datastoreType, path, data, true);
    Futures.addCallback(tx.submit(), callback);
}