public <U, V> FluentFutureStream<V> map(Function<T, U> function, Function<FluentFutureStream<U>, FluentFutureStream<V>> unboxer) { return unboxer.apply(map(function)); }
/** * For all values of the underlying stream, an action will be performed. */ public FluentFutureStream<T> performOnAll(Function<T, CompletableFuture<Void>> action) { return map(t -> action.apply(t).thenApply(any -> t), FluentFutureStream::unboxFuture); }
/** * For all values of the underlying stream, an action will be performed. */ public FluentFutureStream<T> performOnAll(Function<T, CompletableFuture<Void>> action) { return map(t -> action.apply(t).thenApply(any -> t), FluentFutureStream::unboxFuture); }
public FluentFutureStream<T> thenFilter(Function<T, CompletableFuture<Boolean>> futurePredicate) { return map(t -> futurePredicate.apply(t) .thenApply(isKept -> Optional.of(t).filter(any -> isKept)), FluentFutureStream::unboxFutureOptional); }
public FluentFutureStream<T> thenFilter(Function<T, CompletableFuture<Boolean>> futurePredicate) { return map(t -> futurePredicate.apply(t) .thenApply(isKept -> Optional.of(t).filter(any -> isKept)), FluentFutureStream::unboxFutureOptional); }
/** * Apply a transformation to all value of the underlying stream. * * As the supplied transformation produces optionals, the results will be unboxed. */ public <U> FluentFutureStream<U> flatMapOptional(Function<T, Optional<U>> function) { return map(function) .flatMap(OptionalUtils::toStream); }
public static <T> FluentFutureStream<T> unboxFluentFuture(FluentFutureStream<FluentFutureStream<T>> futures) { return unboxStream( unboxFuture( futures.map(FluentFutureStream::completableFuture))); }
public static <T> FluentFutureStream<T> unboxFluentFuture(FluentFutureStream<FluentFutureStream<T>> futures) { return unboxStream( unboxFuture( futures.map(FluentFutureStream::completableFuture))); }
private CompletableFuture<Stream<SimpleMailboxMessage>> expungeUidChunk(CassandraId mailboxId, Collection<MessageUid> uidChunk) { return FluentFutureStream.of( uidChunk.stream().map(uid -> retrieveComposedId(mailboxId, uid)), FluentFutureStream::unboxOptional) .performOnAll(this::deleteUsingMailboxId) .map(idWithMetadata -> FluentFutureStream.of( messageDAO.retrieveMessages(ImmutableList.of(idWithMetadata), FetchType.Metadata, Limit.unlimited())), FluentFutureStream::unboxFluentFuture) .filter(CassandraMessageDAO.MessageResult::isFound) .map(CassandraMessageDAO.MessageResult::message) .map(pair -> pair.getKey().toMailboxMessage(ImmutableList.of())) .completableFuture(); }
@Override public List<Mailbox> list() { return mailboxDAO.retrieveAllMailboxes() .map(this::toMailboxWithAclFuture, FluentFutureStream::unboxFuture) .join() .collect(Guavate.toImmutableList()); }
public FluentFutureStream<SimpleMailbox> retrieveAllMailboxes() { return FluentFutureStream.of(executor.execute(listStatement.bind()) .thenApply(cassandraUtils::convertToStream)) .map(this::toMailboxWithId); }
private List<Mailbox> toMailboxes(MailboxPath path, CompletableFuture<Stream<CassandraIdAndPath>> listUserMailboxes) { Pattern regex = Pattern.compile(constructEscapedRegexForMailboxNameMatching(path)); return FluentFutureStream.of(listUserMailboxes) .filter(idAndPath -> regex.matcher(idAndPath.getMailboxPath().getName()).matches()) .map(this::retrieveMailbox, FluentFutureStream::unboxFutureOptional) .join() .collect(Guavate.toImmutableList()); }
@Override public List<Mailbox> findNonPersonalMailboxes(String userName, Right right) { return FluentFutureStream.of(userMailboxRightsDAO.listRightsForUser(userName) .thenApply(map -> toAuthorizedMailboxIds(map, right))) .map(this::retrieveMailbox, FluentFutureStream::unboxFutureOptional) .join() .collect(Guavate.toImmutableList()); }
@Test void flatMapShouldTransformUnderlyingValuesAndFlatMapResult() { assertThat( FluentFutureStream.of( CompletableFuture.completedFuture( Stream.of(1, 2, 3))) .map(i -> Stream.of(i, i + 1), FluentFutureStream::unboxStream) .join() .collect(Guavate.toImmutableList())) .containsExactly(1, 2, 2, 3, 3, 4); }
@Test void flatMapOptionalShouldTransformUnderlyingValuesAndUnboxResult() { assertThat( FluentFutureStream.of( CompletableFuture.completedFuture( Stream.of(1, 2, 3))) .map(i -> Optional.of(i + 1) .filter(j -> j % 2 == 0), FluentFutureStream::unboxOptional) .join() .collect(Guavate.toImmutableList())) .containsExactly(2, 4); }
@Test void thenComposeOnAllShouldTransformUnderlyingValuesAndComposeFutures() { assertThat( FluentFutureStream.of( CompletableFuture.completedFuture( Stream.of(1, 2, 3))) .map(i -> CompletableFuture.completedFuture(i + 1), FluentFutureStream::unboxFuture) .join() .collect(Guavate.toImmutableList())) .containsExactly(2, 3, 4); }
@Test void mapShouldTransformUnderlyingValues() { assertThat( FluentFutureStream.of( CompletableFuture.completedFuture( Stream.of(1, 2, 3))) .map(i -> i + 1) .join() .collect(Guavate.toImmutableList())) .containsExactly(2, 3, 4); }
@Test void thenFlatComposeShouldTransformUnderlyingValuesAndComposeFuturesWithStreamUnboxing() { assertThat( FluentFutureStream.of( CompletableFuture.completedFuture( Stream.of(1, 2, 3))) .map(i -> FluentFutureStream.of(CompletableFuture.completedFuture(Stream.of(i, i + 1))), FluentFutureStream::unboxFluentFuture) .join() .collect(Guavate.toImmutableList())) .containsExactly(1, 2, 2, 3, 3, 4); }
@Test public void mapShouldTransformUnderlyingValues() { assertThat( FluentFutureStream.of( CompletableFuture.completedFuture( Stream.of(1, 2, 3))) .map(i -> i + 1) .join() .collect(Guavate.toImmutableList())) .containsExactly(2, 3, 4); }
@Override public void delete(Mailbox mailbox) { CassandraId mailboxId = (CassandraId) mailbox.getMailboxId(); FluentFutureStream.ofFutures( mailboxPathDAO.delete(mailbox.generateAssociatedPath()), mailboxPathV2DAO.delete(mailbox.generateAssociatedPath())) .map(any -> mailboxDAO.delete(mailboxId), FluentFutureStream::unboxFuture) .join(); }