public static <T, U> CompletableFuture<Stream<U>> thenComposeOnAll(CompletableFuture<Stream<T>> futurStream, Function<T, CompletableFuture<U>> action) { return futurStream .thenCompose(stream -> CompletableFutureUtil.allOf( stream.map(action))); }
@Override public boolean hasQuota(User user) { return CompletableFutureUtil.combine( cassandraSieveQuotaDAO.getQuota(user).thenApply(Optional::isPresent), cassandraSieveQuotaDAO.getQuota().thenApply(Optional::isPresent), (b1, b2) -> b1 || b2) .join(); }
/** * Reduces the underlying stream. Reduced value is supplied as a Future of optional, as no empty value is supplied. */ public CompletableFuture<Optional<T>> reduce(BinaryOperator<T> combiner) { return CompletableFutureUtil.reduce(combiner, completableFuture); }
public static <T> CompletableFuture<Stream<T>> performOnAll(CompletableFuture<Stream<T>> futurStream, Function<T, CompletableFuture<Void>> action) { return thenComposeOnAll(futurStream, value -> keepValue(() -> action.apply(value), value)); }
@Override public void setActive(User user, ScriptName name) throws ScriptNotFoundException { CompletableFuture<Boolean> activateNewScript = unactivateOldScript(user) .thenCompose(any -> updateScriptActivation(user, name, true) .thenCompose(CompletableFutureUtil.composeIfTrue( () -> cassandraActiveScriptDAO.activate(user, name)))); if (!activateNewScript.join()) { throw new ScriptNotFoundException(); } }
@Test public void reduceShouldReturnIdentityAccumulatorWhenNoValue() { long identityAccumulator = 0L; assertThat( CompletableFutureUtil.reduce( (i, j) -> i + j, CompletableFutureUtil.<Long>allOfArray(), identityAccumulator) .join()) .isEqualTo(identityAccumulator); }
/** * Apply a transformation to all values of the underlying stream. */ public <U> FluentFutureStream<U> map(Function<T, U> function) { return FluentFutureStream.of( CompletableFutureUtil.map(completableFuture(), function)); }
public CompletableFuture<Stream<MessageResult>> retrieveMessages(List<ComposedMessageIdWithMetaData> messageIds, FetchType fetchType, Limit limit) { return CompletableFutureUtil.chainAll( limit.applyOnStream(messageIds.stream().distinct()) .collect(JamesCollectors.chunker(configuration.getMessageReadChunkSize())), ids -> rowToMessages(fetchType, ids)) .thenApply(stream -> stream.flatMap(Function.identity())); }
/** * Constructs a FluentFutureStream from the supplied futures. */ @SafeVarargs public static <T> FluentFutureStream<T> ofFutures(CompletableFuture<T>... completableFutures) { return new FluentFutureStream<>(CompletableFutureUtil.allOfArray(completableFutures)); }
@Override public CompletableFuture<byte[]> readBytes(BlobId blobId) { try { return CompletableFuture.completedFuture(retrieveStoredValue(blobId)); } catch (ObjectStoreException e) { return CompletableFutureUtil.exceptionallyFuture(e); } }
public static <R, T> CompletableFuture<Stream<R>> chainAll(Stream<T> futureStream, Function<T, CompletableFuture<R>> transformationToChain) { return futureStream .map(t -> (Supplier<CompletableFuture<R>>) (() -> transformationToChain.apply(t))) .reduce(CompletableFuture.<Stream<R>>completedFuture(Stream.of()), (accumulator, supplier) -> accumulator.thenCompose( accumulatedStream -> supplier.get() .thenCompose(r -> CompletableFuture.completedFuture(Stream.<R>concat(accumulatedStream, Stream.of(r)))) ), getCompletableFutureBinaryOperator()); }
@Test public void keepValueShouldCompleteWhenTheGivenCompletableFutureEnd() { final AtomicInteger numOfFutureExecution = new AtomicInteger(0); Supplier<CompletableFuture<Void>> future = () -> CompletableFuture.runAsync(numOfFutureExecution::incrementAndGet); assertThat( CompletableFutureUtil.keepValue(future, 42) .join()) .isEqualTo(42); assertThat( numOfFutureExecution.get()) .isEqualTo(1); }
private CompletableFuture<Boolean> trySave(SimpleMailbox cassandraMailbox, CassandraId cassandraId) { return mailboxPathV2DAO.save(cassandraMailbox.generateAssociatedPath(), cassandraId) .thenCompose(CompletableFutureUtil.composeIfTrue( () -> retrieveMailbox(cassandraId) .thenCompose(optional -> CompletableFuture .allOf(optional .map(storedMailbox -> mailboxPathV2DAO.delete(storedMailbox.generateAssociatedPath())) .orElse(CompletableFuture.completedFuture(null)), mailboxDAO.save(cassandraMailbox))))); }
@Test public void reduceShouldWorkWithIdentityAccumulator() { assertThat( CompletableFutureUtil.reduce( (i, j) -> i + j, CompletableFutureUtil.allOfArray( CompletableFuture.completedFuture(1L), CompletableFuture.completedFuture(2L), CompletableFuture.completedFuture(3L) ), 0L) .join()) .isEqualTo(6L); }
/** * Apply a transformation to all values of the underlying stream. */ public <U> FluentFutureStream<U> map(Function<T, U> function) { return FluentFutureStream.of( CompletableFutureUtil.map(completableFuture(), function)); }
@Test void chainAllShouldNotThrowOnEmptyStream() { Stream<Integer> result = CompletableFutureUtil.chainAll(Stream.<Integer>of(), i -> CompletableFuture.supplyAsync(() -> i, executorService)) .join(); assertThat(result.collect(Guavate.toImmutableList())) .isEmpty(); }
@Test public void allOfArrayShouldUnboxNoArgs() { assertThat( CompletableFutureUtil.allOfArray() .join() .collect(Guavate.toImmutableList())) .isEmpty(); }
@Test void exceptionallyFutureShouldReturnACompletedExceptionallyFuture() { CompletableFuture<Object> failedFuture = CompletableFutureUtil.exceptionallyFuture(new Exception("failure")); assertThat(failedFuture) .isCompletedExceptionally(); } }
public static <R, T> CompletableFuture<Stream<R>> chainAll(Stream<T> futureStream, Function<T, CompletableFuture<R>> transformationToChain) { return futureStream .map(t -> (Supplier<CompletableFuture<R>>) (() -> transformationToChain.apply(t))) .reduce(CompletableFuture.<Stream<R>>completedFuture(Stream.of()), (accumulator, supplier) -> accumulator.thenCompose( accumulatedStream -> supplier.get() .thenCompose(r -> CompletableFuture.completedFuture(Stream.<R>concat(accumulatedStream, Stream.of(r)))) ), getCompletableFutureBinaryOperator()); }
@Test public void keepValueShouldReturnNullWithNullValue() { Supplier<CompletableFuture<Void>> future = () -> CompletableFuture.completedFuture(null); assertThat( CompletableFutureUtil.keepValue(future, null) .join()) .isNull(); }