Example usage for com.google.common.util.concurrent ListenableFuture addListener

Introduction

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

Prototype

void addListener(Runnable listener, Executor executor);

Source Link

Document

Registers a listener to be Executor#execute(Runnable) run on the given executor.

Usage

From source file:com.example.retrofit.CustomCallAdapter.java

public static void main(String... args) {
    Retrofit retrofit = new Retrofit.Builder().baseUrl("http://httpbin.org")
            .addCallAdapterFactory(new ListenableFutureCallAdapterFactory()).build();

    HttpBinService service = retrofit.create(HttpBinService.class);
    final ListenableFuture<Ip> ip = service.getIp();
    ip.addListener(new Runnable() {
        @Override/* w  w w . ja  v  a 2s  . c  o  m*/
        public void run() {
            try {
                System.out.println("IP: " + ip.get().origin);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }, Executors.newSingleThreadExecutor());
}

From source file:retrofit.CustomCallAdapter.java

public static void main(String... args) {
    Retrofit retrofit = new Retrofit.Builder().baseUrl("http://httpbin.org")
            .addCallAdapterFactory(new ListenableFutureCallAdapterFactory())
            .addConverterFactory(GsonConverterFactory.create()).build();

    HttpBinService service = retrofit.create(HttpBinService.class);
    final ListenableFuture<Ip> ip = service.getIp();
    ip.addListener(new Runnable() {
        @Override/*from  w  w w .  j  a v a2  s .c  o  m*/
        public void run() {
            try {
                System.out.println("IP: " + ip.get().origin);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }, Executors.newSingleThreadExecutor());
}

From source file:com.sk89q.worldedit.command.util.FutureProgressListener.java

public static void addProgressListener(ListenableFuture<?> future, Actor sender, String message) {
    future.addListener(new FutureProgressListener(sender, message), MoreExecutors.directExecutor());
}

From source file:com.google.gapid.rpc.Rpc.java

/**
 * Calls {@link Callback#onFinish} with the {@link Result} once the {@link ListenableFuture} RPC
 * call has either successfully completed or thrown an exception.
 *
 * @param <V>      the RPC result type.
 * @param future   the {@link ListenableFuture} returned by the invoking the RPC call.
 * @param callback the {@link Callback} to handle {@link Callback#onFinish} events.
 *///from   ww w.  j a v  a 2  s . c  o m
public static <V> void listen(ListenableFuture<V> future, Callback<V> callback) {
    future.addListener(new Runnable() {
        @Override
        public void run() {
            callback.onFinish(new Result<V>(future));
        }
    }, EXECUTOR);
}

From source file:com.continuuity.weave.common.Services.java

/**
 * Performs the actual logic of chain Service start/stop.
 *//*from  w  w w . j  a  v  a2s  .co  m*/
private static ListenableFuture<List<ListenableFuture<Service.State>>> doChain(boolean doStart,
        Service firstService, Service... moreServices) {
    SettableFuture<List<ListenableFuture<Service.State>>> resultFuture = SettableFuture.create();
    List<ListenableFuture<Service.State>> result = Lists.newArrayListWithCapacity(moreServices.length + 1);

    ListenableFuture<Service.State> future = doStart ? firstService.start() : firstService.stop();
    future.addListener(
            createChainListener(future, moreServices, new AtomicInteger(0), result, resultFuture, doStart),
            Threads.SAME_THREAD_EXECUTOR);
    return resultFuture;
}

From source file:com.continuuity.weave.common.Services.java

/**
 * Returns a {@link Runnable} that can be used as a {@link ListenableFuture} listener to trigger
 * further service action or completing the result future. Used by
 * {@link #doChain(boolean, com.google.common.util.concurrent.Service, com.google.common.util.concurrent.Service...)}
 *///from   ww  w  .  ja va  2s .  com
private static Runnable createChainListener(final ListenableFuture<Service.State> future,
        final Service[] services, final AtomicInteger idx, final List<ListenableFuture<Service.State>> result,
        final SettableFuture<List<ListenableFuture<Service.State>>> resultFuture, final boolean doStart) {
    return new Runnable() {

        @Override
        public void run() {
            result.add(future);
            int nextIdx = idx.getAndIncrement();
            if (nextIdx == services.length) {
                resultFuture.set(result);
                return;
            }
            ListenableFuture<Service.State> actionFuture = doStart ? services[nextIdx].start()
                    : services[nextIdx].stop();
            actionFuture.addListener(
                    createChainListener(actionFuture, services, idx, result, resultFuture, doStart),
                    Threads.SAME_THREAD_EXECUTOR);
        }
    };
}

From source file:com.google.gapid.rpclib.rpccore.Rpc.java

/**
 * Extension of {@link #listen(ListenableFuture, Callback)} that also takes a {@link FutureController}
 * for controlling the {@link Future}s.//from   ww w. ja va  2 s  . co m
 *
 * @param <V>        the RPC result type.
 * @param future     the {@link ListenableFuture} returned by the invoking the RPC call.
 * @param controller the {@link FutureController} used to manage the RPC futures.
 * @param callback   the {@link Callback} to handle {@link Callback#onStart} and {@link Callback#onFinish} events.
 */
public static <V> void listen(final ListenableFuture<V> future, final FutureController controller,
        final Callback<V> callback) {
    controller.onStart(future);
    future.addListener(new Runnable() {
        @Override
        public void run() {
            if (!controller.onStop(future)) {
                return;
            }
            callback.onFinish(new Result<V>(future));
        }
    }, EXECUTOR);
}

From source file:org.hawkular.rx.cassandra.driver.RxUtil.java

/**
 * Converts from {@link ListenableFuture} to {@link rx.Observable}.
 *
 * @param future  the {@link ListenableFuture} to register a listener on.
 * @param executor  the {@link Executor} where the callback will be executed.  The will be where the
 * {@link Observer#onNext(Object)} call from.
 * @return an {@link Observable} that emits the one value when the future completes.
 */// w w w. j a  v  a  2  s.c  om
public static <T> Observable<T> from(final ListenableFuture<T> future, final Executor executor) {
    return Observable.create(new Observable.OnSubscribe<T>() {
        @Override
        public void call(final Subscriber<? super T> subscriber) {
            future.addListener(new Runnable() {
                @Override
                public void run() {
                    try {
                        T t = future.get();
                        subscriber.onNext(t);
                        subscriber.onCompleted();
                    } catch (Exception e) {
                        subscriber.onError(e);
                    }
                }
            }, executor);
        }
    });
}

From source file:com.android.tools.rpclib.rpccore.Rpc.java

/**
 * Extension of {@link #listen(ListenableFuture, Logger, Callback)} that also takes a {@link FutureController}
 * for controlling the {@link Future}s./*w  ww .  j  a v a2 s.c  o  m*/
 *
 * @param future     the {@link ListenableFuture} returned by the invoking the RPC call.
 * @param log        the {@link Logger} used for logging uncaught exceptions thrown from {@link Callback#onFinish}.
 * @param callback   the {@link Callback} to handle {@link Callback#onStart} and {@link Callback#onFinish} events.
 * @param controller the {@link FutureController} used to manage the RPC futures.
 * @param <V>        the RPC result type.
 */
public static <V> void listen(final ListenableFuture<V> future, final Logger log,
        final FutureController controller, final Callback<V> callback) {
    controller.onStart(future);
    future.addListener(new Runnable() {
        @Override
        public void run() {
            if (!controller.onStop(future)) {
                return;
            }
            try {
                callback.onFinish(new Result<>(future));
            } catch (CancellationException e) {
                // Not an error, don't log.
            } catch (Exception e) {
                log.error(e);
            }
        }
    }, EXECUTOR);
}

From source file:com.facebook.presto.execution.scheduler.NodeScheduler.java

private static ListenableFuture<?> getFirstCompleteAndCancelOthers(List<ListenableFuture<?>> blockedFutures) {
    // wait for the first task to unblock and then cancel all futures to free up resources
    ListenableFuture<?> result = whenAnyComplete(blockedFutures);
    result.addListener(() -> {
        for (ListenableFuture<?> blockedFuture : blockedFutures) {
            blockedFuture.cancel(true);/*from w  ww .  j  a v  a2s.co m*/
        }
    }, MoreExecutors.directExecutor());
    return result;
}