Example usage for com.google.common.util.concurrent MoreExecutors directExecutor

Introduction

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

Prototype

public static Executor directExecutor()

Source Link

Document

Returns an Executor that runs each task in the thread that invokes Executor#execute execute , as in CallerRunsPolicy .

Usage

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

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

From source file:com.navercorp.nbasearc.gcp.SingleThreadEventLoopTrunk.java

ListenableFuture<?> close() {
    final SettableFuture<?> sf = SettableFuture.create();
    final AtomicInteger counter = new AtomicInteger(eventLoops.length);

    for (final SingleThreadEventLoop eventLoop : eventLoops) {
        eventLoop.close().addListener(new Runnable() {
            @Override/*from  w  w w .ja  v a  2s.co  m*/
            public void run() {
                if (counter.decrementAndGet() == 0) {
                    sf.set(null);
                }
            }
        }, MoreExecutors.directExecutor());
    }

    return sf;
}

From source file:com.orangerhymelabs.helenus.cassandra.table.TableService.java

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

From source file:io.crate.operation.projectors.IterableRowEmitter.java

public IterableRowEmitter(RowReceiver rowReceiver, final Iterable<? extends Row> rows,
        Optional<Executor> executor) {
    this.rowReceiver = rowReceiver;
    this.rows = rows;
    this.rowsIt = rows.iterator();
    this.resumeable = new ExecutorResumeHandle(executor.or(MoreExecutors.directExecutor()), this);
}

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 ww  w  .j  a  v a  2  s.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: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/* w  w w .jav  a 2  s  .  c  o  m*/
        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:org.immutables.eventual.CompletedModule.java

static ListenableFuture<Module> from(Injector injectingFutures, CompletionCriteria criteria) {
    final LinkedHashMap<Key<?>, Key<?>> keyMapping = mapUnfutureKeys(injectingFutures);
    List<ListenableFuture<?>> listOfFutures = getFutureInstances(keyMapping.keySet(), injectingFutures);

    ListenableFuture<List<Object>> futureOfList = criteria == CompletionCriteria.SUCCESSFUL
            ? Futures.successfulAsList(listOfFutures)
            : Futures.allAsList(listOfFutures);

    return Futures.transform(futureOfList, new Function<List<Object>, Module>() {
        Key<?>[] keys = Iterables.toArray(keyMapping.values(), Key.class);

        @Override/*from   w w  w  .  j a  va  2  s . co  m*/
        public Module apply(List<Object> instances) {
            return new CompletedModule(keys, instances.toArray());
        }
    }, MoreExecutors.directExecutor());
}

From source file:snippets.tasks.ExecutorCallbackSample.java

public void doSomething() {
    service.submit(new Callable<String>() {
        @Override/* www  . j  a  v a2s  .  com*/
        public String call() throws Exception {
            return "heavy computation has been done";
        }
    }).onSuccess(new ManagedFutureTask.SuccessCallback<String>() {
        @Override
        public void onSuccess(ManagedFutureTask<String> future, String result) {
            System.out.println("Task has returned " + result);
        }
    }).onFailure(new ManagedFutureTask.FailureCallback() {
        @Override
        public void onFailure(ManagedFutureTask future, Throwable throwable) {
            System.out.println("Task has thrown an exception");
        }
    }, MoreExecutors.directExecutor());
}

From source file:com.orangerhymelabs.helenus.cassandra.table.TableService.java

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

From source file:com.codeabovelab.dm.cluman.cluster.docker.management.JsonStreamProcessor.java

@Override
public void processResponseStream(StreamContext<T> context) {
    Consumer<T> watcher = context.getWatcher();
    InputStream response = context.getStream();
    final Thread thread = Thread.currentThread();
    SettableFuture<Boolean> interrupter = context.getInterrupter();
    interrupter.addListener(() -> thread.interrupt(), MoreExecutors.directExecutor());
    try {/* w w  w.j  av a  2s  .c o m*/
        JsonParser jp = JSON_FACTORY.createParser(response);
        Boolean closed = jp.isClosed();
        JsonToken nextToken = jp.nextToken();
        while (!closed && nextToken != null && nextToken != JsonToken.END_OBJECT && !interrupter.isDone()) {
            try {
                ObjectNode objectNode = OBJECT_MAPPER.readTree(jp);
                // exclude empty item serialization into class #461
                if (!objectNode.isEmpty(null)) {
                    T next = OBJECT_MAPPER.treeToValue(objectNode, clazz);
                    LOG.trace("Monitor value: {}", next);
                    watcher.accept(next);
                }
            } catch (Exception e) {
            }

            closed = jp.isClosed();
            nextToken = jp.nextToken();
        }
    } catch (Throwable t) {
        throw Throwables.asRuntime(t);
    } finally {
        try {
            response.close();
        } catch (IOException e) {
            LOG.error("Can't close stream", e);

        }
    }

}