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

List of usage examples for com.google.common.util.concurrent Futures allAsList

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.util.concurrent.*
  5. Futures
  6. allAsList

Introduction

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

Prototype

@Beta
@CheckReturnValue
public static <V> ListenableFuture<List<V>> allAsList(
        Iterable<? extends ListenableFuture<? extends V>> futures)

Source Link

Document

Creates a new ListenableFuture whose value is a list containing the values of all its input futures, if all succeed.

Usage

From source file:com.github.fhuss.storm.cassandra.executor.AsyncExecutor.java

/**
 * Asynchronously executes all statements associated to the specified input. The input will be passed to
 * the {@link #handler} once all queries succeed or failed.
 *///from  w  w w. j a v  a 2s  .co  m
public List<SettableFuture<T>> execAsync(List<Statement> statements, final T input) {
    Stream<SettableFuture<T>> futureStream = statements.stream()
            .map(s -> execAsync(s, input, AsyncResultHandler.NO_OP_HANDLER));

    List<SettableFuture<T>> settableFutures = futureStream.collect(Collectors.toList());
    ListenableFuture<List<T>> allAsList = Futures.allAsList(settableFutures);
    Futures.addCallback(allAsList, new FutureCallback<List<T>>() {
        @Override
        public void onSuccess(List<T> inputs) {
            handler.success(input);
        }

        @Override
        public void onFailure(Throwable t) {
            handler.failure(t, input);
        }
    }, executorService);
    return settableFutures;
}

From source file:io.crate.executor.transport.task.UpsertTask.java

@Override
public void start() {
    if (subTasks.size() == 0) {
        ((SettableFuture) resultList.get(0)).set(RowCountResult.EMPTY_RESULT);
        return;//from w  w w .j  a v  a 2  s.c o m
    } else if (forwardResultsFromSubTask) {
        // result list is bind to sub task results, no further action/listener required
        transportExecutor.execute(subTasks);
    } else {
        final SettableFuture<TaskResult> result = (SettableFuture) resultList.get(0);

        final List<ListenableFuture<TaskResult>> subTasksResult = transportExecutor.execute(subTasks);
        Futures.addCallback(Futures.allAsList(subTasksResult), new FutureCallback<List<TaskResult>>() {
            @Override
            public void onSuccess(@Nullable List<TaskResult> results) {
                if (results == null) {
                    result.setException(new NullPointerException());
                    return;
                }
                assert results.size() == 1 : "Last sub-task is expected to have 1 result only";
                result.set(new RowCountResult(
                        ((Number) results.get(0).rows().iterator().next().get(0)).longValue()));
            }

            @Override
            public void onFailure(@Nonnull Throwable t) {
                if (t == null) {
                    t = new NullPointerException();
                }
                result.setException(t);
            }
        });

    }
}

From source file:com.cloudera.oryx.kmeans.computation.local.WeightedPointsByFold.java

@Override
public List<List<WeightedRealVector>> call() throws InterruptedException, ExecutionException {
    Config config = ConfigUtils.getDefaultConfig();
    ClusterSettings cluster = ClusterSettings.create(config);
    KSketchIndex index = buildIndex(foldVecs, cluster);
    int pointsPerIteration = cluster.getSketchPoints();
    RandomGenerator random = RandomManager.getRandom();

    ListeningExecutorService exec = MoreExecutors
            .listeningDecorator(Executors.newFixedThreadPool(config.getInt("model.parallelism"),
                    new ThreadFactoryBuilder().setNameFormat("KSKETCH-%d").setDaemon(true).build()));
    for (int iter = 0; iter < cluster.getSketchIterations(); iter++) {
        log.info("Starting sketch iteration {}", iter + 1);
        List<ListenableFuture<Collection<RealVector>>> futures = Lists.newArrayList();
        for (int foldId = 0; foldId < foldVecs.size(); foldId++) {
            futures.add(exec/*from   w  w w . ja  va 2  s  .  c  o  m*/
                    .submit(new SamplingRun(index, random, foldId, foldVecs.get(foldId), pointsPerIteration)));
        }
        // At the end of each iteration, gather up the sampled points to add to the index
        Future<List<Collection<RealVector>>> all = Futures.allAsList(futures);
        try {
            List<Collection<RealVector>> newSamples = all.get();
            for (int foldId = 0; foldId < foldVecs.size(); foldId++) {
                for (RealVector v : newSamples.get(foldId)) {
                    index.add(v, foldId);
                }
            }
        } catch (ExecutionException e) {
            ExecutorUtils.shutdownNowAndAwait(exec);
            all.cancel(true);
            throw e;
        }
        index.rebuildIndices();
    }

    List<ListenableFuture<List<WeightedRealVector>>> ret = Lists.newArrayList();
    for (int foldId = 0; foldId < foldVecs.size(); foldId++) {
        ret.add(exec.submit(new AssignmentRun(index, foldId, foldVecs.get(foldId))));
    }
    try {
        return Futures.allAsList(ret).get();
    } finally {
        ExecutorUtils.shutdownNowAndAwait(exec);
    }
}

From source file:com.google.idea.blaze.base.sync.filediff.FileDiffService.java

private static List<FileEntry> updateTimeStamps(@NotNull Iterable<File> fileList) throws Exception {
    final FileAttributeProvider fileAttributeProvider = FileAttributeProvider.getInstance();
    List<ListenableFuture<FileEntry>> futures = Lists.newArrayList();
    for (File file : fileList) {
        futures.add(submit(() -> {//from   ww  w. ja  va2s  .c  om
            FileEntry fileEntry = new FileEntry();
            fileEntry.file = file;
            fileEntry.timestamp = fileAttributeProvider.getFileModifiedTime(fileEntry.file);
            return fileEntry;
        }));
    }
    return Futures.allAsList(futures).get();
}

From source file:com.flipkart.hydra.task.entities.WrapperCallable.java

protected Object getResponsesForMap() throws Exception {
    Map iterable = (Map) loopVar;

    Map<Object, ListenableFuture<Object>> futureMap = new HashMap<>();
    for (Object i : iterable.keySet()) {
        ListenableFuture<Object> future = getFuture(i, iterable.get(i));
        futureMap.put(i, future);/*  w  w  w  . ja  va 2  s  . c o  m*/
    }

    ListenableFuture<List<Object>> compositeFuture = Futures.allAsList(futureMap.values());
    compositeFuture.get();

    Map<Object, Object> responsesMap = new HashMap<>();
    for (Object i : iterable.keySet()) {
        responsesMap.put(i, futureMap.get(i).get());
    }

    return responsesMap;
}

From source file:io.crate.autocomplete.AutoCompleter.java

public ListenableFuture<CompletionResult> complete(String statement) {
    StatementLexer lexer = getLexer(statement);
    final Context ctx = new Context(statement.length());
    List<ListenableFuture<List<String>>> futureCompletions;
    try {/* w ww  . j av  a2  s . c o  m*/
        futureCompletions = innerComplete(lexer, statement, ctx);
    } catch (ParsingException e) {
        return Futures.immediateFuture(new CompletionResult(0, Collections.<String>emptyList()));
    } catch (Throwable t) {
        logger.error(t.getMessage(), t);
        return Futures.immediateFuture(new CompletionResult(0, Collections.<String>emptyList()));
    }

    final SettableFuture<CompletionResult> result = SettableFuture.create();
    Futures.addCallback(Futures.allAsList(futureCompletions), new FutureCallback<List<List<String>>>() {
        @Override
        public void onSuccess(@Nullable List<List<String>> completionsList) {
            if (completionsList == null) {
                result.set(new CompletionResult(0, ImmutableList.<String>of()));
                return;
            }
            if (ctx.parts.size() > 1) {
                Set<String> fullyQualifiedCompletions = new TreeSet<>();
                for (List<String> completions : completionsList) {
                    for (String completion : completions) {
                        ctx.parts.set(ctx.parts.size() - 1, completion);
                        fullyQualifiedCompletions.add(dotJoiner.join(ctx.parts));
                    }
                }
                result.set(new CompletionResult(ctx.startIdx, fullyQualifiedCompletions));
            } else {
                Set<String> uniqueSortedCompletions = new TreeSet<>();
                for (List<String> completions : completionsList) {
                    uniqueSortedCompletions.addAll(completions);
                }
                result.set(new CompletionResult(ctx.startIdx, uniqueSortedCompletions));
            }
        }

        @Override
        public void onFailure(@Nonnull Throwable t) {
            result.setException(t);
        }
    });
    return result;
}

From source file:com.helion3.prism.api.query.QueryBuilder.java

/**
 * Builds a {@link Query} by parsing an array of arguments.
 *
 * @param parameters String[] Parameter:value list
 * @return {@link Query} Database query object
 *//* w  w  w .j a  v  a2s  . c o m*/
public static CompletableFuture<Query> fromArguments(QuerySession session, @Nullable String[] arguments)
        throws ParameterException {
    checkNotNull(session);

    Query query = new Query();
    CompletableFuture<Query> future = new CompletableFuture<Query>();

    // Track all parameter pairs
    Map<String, String> definedParameters = new HashMap<String, String>();

    if (arguments.length > 0) {
        List<ListenableFuture<?>> futures = new ArrayList<ListenableFuture<?>>();
        for (String arg : arguments) {
            Optional<ListenableFuture<?>> listenable;

            if (flagPattern.matcher(arg).matches()) {
                listenable = parseFlagFromArgument(session, query, arg);
            } else {
                // Get alias/value pair
                Pair<String, String> pair = getParameterKeyValue(arg);

                // Parse for handler
                listenable = parseParameterFromArgument(session, query, pair);

                // Add to list of defined
                definedParameters.put(pair.getKey(), pair.getValue());
            }

            if (listenable.isPresent()) {
                futures.add(listenable.get());
            }
        }

        if (!futures.isEmpty()) {
            ListenableFuture<List<Object>> combinedFuture = Futures.allAsList(futures);
            combinedFuture.addListener(new Runnable() {
                @Override
                public void run() {
                    future.complete(query);
                }
            }, MoreExecutors.sameThreadExecutor());
        } else {
            future.complete(query);
        }
    } else {
        future.complete(query);
    }

    if (Prism.getConfig().getNode("defaults", "enabled").getBoolean()) {
        // Require any parameter defaults
        String defaultsUsed = "";
        for (ParameterHandler handler : Prism.getParameterHandlers()) {
            boolean aliasFound = false;

            for (String alias : handler.getAliases()) {
                if (definedParameters.containsKey(alias)) {
                    aliasFound = true;
                    break;
                }
            }

            if (!aliasFound) {
                Optional<Pair<String, String>> pair = handler.processDefault(session, query);
                if (pair.isPresent()) {
                    defaultsUsed += pair.get().getKey() + ":" + pair.get().getValue() + " ";
                }
            }
        }

        // @todo should move this
        if (!defaultsUsed.isEmpty()) {
            session.getCommandSource().get().sendMessage(
                    Format.subduedHeading(Text.of(String.format("Defaults used: %s", defaultsUsed))));
        }
    }

    return future;
}

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

public static ListenableFuture<?> rollupAsync(Collection<ListenableFuture<ResultSet>> futures,
        Executor asyncExecutor, DoRollup function) {
    return transformAsync(Futures.allAsList(futures), asyncExecutor,
            new AsyncFunction<List<ResultSet>, /*@Nullable*/ Object>() {
                @Override//from   w w w .  j  a  v a 2 s  .  c om
                @SuppressWarnings("unchecked")
                public ListenableFuture</*@Nullable*/ Object> apply(List<ResultSet> list) throws Exception {
                    List<Row> rows = new ArrayList<>();
                    for (ResultSet results : list) {
                        rows.addAll(results.all());
                    }
                    if (rows.isEmpty()) {
                        return Futures.immediateFuture(null);
                    }
                    return (ListenableFuture</*@Nullable*/ Object>) function.execute(rows);
                }
            });
}

From source file:com.google.pubsub.clients.experimental.CPSPublisherTask.java

@Override
public ListenableFuture<RunResult> doRun() {
    try {//from  w  w w .jav a2  s.  com
        List<ListenableFuture<String>> results = new ArrayList<>();
        String sendTime = String.valueOf(System.currentTimeMillis());
        for (int i = 0; i < batchSize; i++) {
            results.add(publisher.publish(PubsubMessage.newBuilder().setData(payload)
                    .putAttributes("sendTime", sendTime).putAttributes("clientId", id.toString())
                    .putAttributes("sequenceNumber", Integer.toString(sequenceNumber.getAndIncrement()))
                    .build()));
        }
        return Futures.transform(Futures.allAsList(results), response -> RunResult.fromBatchSize(batchSize));
    } catch (Throwable t) {
        log.error("Flow control error.", t);
        return Futures.immediateFailedFuture(t);
    }
}

From source file:de.dfki.kiara.impl.DefaultInvocationHandler.java

@Override
protected Object handleInvocation(Object o, Method method, Object[] os) throws Throwable {
    if (method.equals(SpecialMethods.riGetConnection)) {
        return connection;
    }/*from w w  w .  jav  a2  s  .  co m*/

    InterfaceMapping<?> mapping = getInterfaceMapping();

    final String idlFunctionName = mapping.getIDLMethodName(method);
    if (idlFunctionName == null) {
        throw new UnsupportedOperationException("Unbound method: " + method);
    }

    // check for Future<?>
    final MethodEntry methodEntry = mapping.getMethodEntry(method);

    logger.debug("has future params {} has listeningfuture params {}", methodEntry.hasFutureParams,
            methodEntry.hasListeningFutureParams);

    ListenableFuture<List<Object>> futureParams = null;

    if (methodEntry.hasFutureParams) {
        List<ListenableFuture<Object>> futureParamsList = new ArrayList<>(os.length);
        for (int i = 0; i < os.length; ++i) {
            final Function<Object, Object> f = ((Function<Object, Object>) methodEntry.paramConverters[i]);
            futureParamsList.add((ListenableFuture<Object>) f.apply(os[i]));
        }
        futureParams = Futures.allAsList(futureParamsList);
        //System.out.format("futureParams = %s%n", Joiner.on(" ").join(futureParams.get()));
    }

    if (methodEntry.kind == MethodEntry.MethodKind.SERIALIZER) {
        if (futureParams != null) {
            return protocol
                    .createRequestMessage(new Message.RequestObject(idlFunctionName, futureParams.get()));
        } else {
            return protocol.createRequestMessage(new Message.RequestObject(idlFunctionName, os));
        }
    } else if (methodEntry.kind == MethodEntry.MethodKind.DESERIALIZER) {
        Message msg = (Message) os[0];
        Message.ResponseObject ro = msg.getResponseObject(TypeToken.of(method.getGenericReturnType()));

        if (ro.isException) {
            if (ro.result instanceof Exception) {
                throw (Exception) ro.result;
            }
            throw new WrappedRemoteException(ro.result);
        }

        return ro.result;
    } else {
        if (futureParams != null && methodEntry.futureParamOfReturnType != null) {

            AsyncFunction<List<Object>, Object> f = new AsyncFunction<List<Object>, Object>() {

                @Override
                public ListenableFuture<Object> apply(List<Object> params) throws Exception {
                    final Message request = protocol
                            .createRequestMessage(new Message.RequestObject(idlFunctionName, params));
                    final TypeToken<?> returnType = TypeToken.of(methodEntry.futureParamOfReturnType);
                    final ListenableFuture<Message> responseFuture = connection.performRemoteAsyncCall(request,
                            Global.executor);
                    AsyncFunction<Message, Object> g = new AsyncFunction<Message, Object>() {

                        @Override
                        public ListenableFuture<Object> apply(final Message response) throws Exception {
                            return Global.executor.submit(new Callable<Object>() {

                                @Override
                                public Object call() throws Exception {
                                    Message.ResponseObject ro = response.getResponseObject(returnType);

                                    if (ro.isException) {
                                        if (ro.result instanceof Exception) {
                                            throw (Exception) ro.result;
                                        }
                                        throw new WrappedRemoteException(ro.result);
                                    }

                                    return ro.result;

                                }
                            });
                        }
                    };
                    return Futures.transform(responseFuture, g);
                }
            };
            return Futures.transform(futureParams, f);
        } else {

            /* Following code is for testing of synchronous message sending
                    
             if (futureParams == null && methodEntry.futureParamOfReturnType == null) {
             final Message request = protocol.createRequestMessage(new Message.RequestObject(idlFunctionName, os));
             final Message response = performSyncCall(request, method);
             final Message.ResponseObject ro = response.getResponseObject(method.getReturnType());
             if (ro.isException) {
             if (ro.result instanceof Exception) {
             throw (Exception) ro.result;
             }
             throw new WrappedRemoteException(ro.result);
             }
                    
             return ro.result;
             }
             */
            List<Object> params = futureParams != null ? futureParams.get() : Arrays.asList(os);

            final Message request = protocol
                    .createRequestMessage(new Message.RequestObject(idlFunctionName, params));

            final TypeToken<?> returnType = methodEntry.futureParamOfReturnType != null
                    ? TypeToken.of(methodEntry.futureParamOfReturnType)
                    : TypeToken.of(method.getGenericReturnType());

            final ListenableFuture<Message> responseFuture = connection.performRemoteAsyncCall(request,
                    Global.executor);

            if (methodEntry.futureParamOfReturnType != null) {
                AsyncFunction<Message, Object> f = new AsyncFunction<Message, Object>() {

                    @Override
                    public ListenableFuture<Object> apply(final Message response) throws Exception {
                        return Global.executor.submit(new Callable<Object>() {

                            @Override
                            public Object call() throws Exception {
                                Message.ResponseObject ro = response.getResponseObject(returnType);

                                if (ro.isException) {
                                    if (ro.result instanceof Exception) {
                                        throw (Exception) ro.result;
                                    }
                                    throw new WrappedRemoteException(ro.result);
                                }

                                return ro.result;

                            }
                        });
                    }
                };
                return Futures.transform(responseFuture, f);

            } else {

                Message response;
                try {
                    response = responseFuture.get();
                } catch (Exception ex) {
                    throw new RemoteInvocationException(ex);
                }
                Message.ResponseObject ro = response.getResponseObject(returnType);

                if (ro.isException) {
                    if (ro.result instanceof Exception) {
                        throw (Exception) ro.result;
                    }
                    throw new WrappedRemoteException(ro.result);
                }

                return ro.result;
            }
        }
    }

}