private Class<? extends Filter> detectClass(Iterator<Map.Entry<String, JsonNode>> elements) { Optional<Class<? extends Filter>> maybeFilterOperator = Iterators.toStream(elements) .map(Map.Entry::getKey) .filter(name -> name.equals("operator")) .findFirst() .map(x -> FilterOperator.class); return maybeFilterOperator.orElse(FilterCondition.class); } }
private Stream<MessageSearchIndex.SearchResult> transformResponseToUidStream(SearchResponse searchResponse) { return Iterators.toStream(searchResponse.getHits().iterator()) .map(this::extractContentFromHit) .filter(Optional::isPresent) .map(Optional::get); }
public Stream<SearchResponse> stream() { return Iterators.toStream(iterator()); }
@SuppressWarnings("unchecked") @Override public Optional<Collection<AttributeValue<U>>> deserialize(JsonNode json) { if (json instanceof ArrayNode) { return Optional.of(Iterators.toStream(json.elements()) .map(value -> (AttributeValue<U>) AttributeValue.fromJson(value)) .collect(ImmutableList.toImmutableList())); } else { return Optional.empty(); } }
@SuppressWarnings("unchecked") @Override public Optional<Map<String, AttributeValue<U>>> deserialize(JsonNode json) { if (json instanceof ObjectNode) { return Optional.of(Iterators.toStream(json.fields()) .collect(ImmutableMap.toImmutableMap( Map.Entry::getKey, entry -> (AttributeValue<U>) AttributeValue.fromJson(entry.getValue()) ))); } else { return Optional.empty(); } }
private static Optional<ImmutableMap<String, String>> fetchAttributes(Set<AdditionalField> additionalFields, Mail mail) { if (!additionalFields.contains(AdditionalField.ATTRIBUTES)) { return Optional.empty(); } return Optional.of(Iterators.toStream(mail.getAttributeNames()) .collect(Guavate.toImmutableMap(Function.identity(), attributeName -> mail.getAttribute(attributeName).toString()))); }
@Override public List<MailboxAnnotation> getAnnotationsByKeysWithAllDepth(MailboxId mailboxId, final Set<MailboxAnnotationKey> keys) { return Iterators.toStream(retrieveAllAnnotations((InMemoryId)mailboxId).iterator()) .filter(getPredicateFilterByAll(keys)) .collect(Guavate.toImmutableList()); }
public Flags computeApplicableFlags() { return ApplicableFlagBuilder.builder() .add(Iterators.toStream(mailboxMessages.iterator()) .map(MailboxMessage::createFlags) .collect(Guavate.toImmutableList())) .build(); } }
public Optional<List<MailKeyDTO>> listMails(MailRepositoryPath path, Offset offset, Limit limit) throws MailRepositoryStore.MailRepositoryStoreException, MessagingException { Optional<Stream<MailKeyDTO>> maybeMails = Optional.of(getRepositories(path) .flatMap(Throwing.function((MailRepository repository) -> Iterators.toStream(repository.list())).sneakyThrow()) .map(MailKeyDTO::new) .skip(offset.getOffset())); return maybeMails.map(limit::applyOnStream) .map(stream -> stream.collect(ImmutableList.toImmutableList())); }
public void updateReferences(Headers headers, MailboxSession session) throws MailboxException { Map<String, String> headersAsMap = Iterators.toStream(headers.headers()) .collect(Guavate.toImmutableMap(Header::getName, Header::getValue)); updateReferences(headersAsMap, session); }
private Optional<MailboxMessage> fullyReadMessage(MailboxSession mailboxSession, Mailbox mailbox, MessageUid mUid) throws MailboxException { return Iterators.toStream(mailboxSessionMapperFactory.getMessageMapper(mailboxSession) .findInMailbox(mailbox, MessageRange.one(mUid), MessageMapper.FetchType.Full, SINGLE_MESSAGE)) .findFirst(); }
public void reprocessAll(MailRepositoryPath path, Optional<String> targetProcessor, String targetQueue, Consumer<MailKey> keyListener) throws MailRepositoryStore.MailRepositoryStoreException, MessagingException { Reprocessor reprocessor = new Reprocessor(getMailQueue(targetQueue), targetProcessor); mailRepositoryStoreService .getRepositories(path) .forEach(Throwing.consumer((MailRepository repository) -> Iterators.toStream(repository.list()) .peek(keyListener) .map(Throwing.function(key -> Optional.ofNullable(repository.retrieve(key)))) .flatMap(OptionalUtils::toStream) .forEach(mail -> reprocessor.reprocess(repository, mail)))); }
@Override public List<User> search(QuotaQuery query) { Stream<User> results = Iterators.toStream(listUsers()) .map(User::fromUsername) .filter(clauseConverter.andToPredicate(query.getClause())) .sorted(Comparator.comparing(User::asString)) .skip(query.getOffset().getValue()); return limit(results, query.getLimit()) .collect(Guavate.toImmutableList()); }
@Test public void toStreamShouldReturnSameContent() { //Given UnmodifiableIterator<String> iterator = ImmutableList.of("a", "b", "c").iterator(); //When Stream<String> actual = Iterators.toStream(iterator); //Then assertThat(actual.collect(toList())).containsExactly("a", "b", "c"); }
@Test public void toStreamShouldReturnEmptyStreamWhenEmptyIterator() { //Given UnmodifiableIterator<String> emptyIterator = ImmutableList.<String>of().iterator(); //When Stream<String> actual = Iterators.toStream(emptyIterator); //Then assertThat(actual.count()).isEqualTo(0); }
@Test void toStreamShouldReturnEmptyStreamWhenEmptyIterator() { //Given UnmodifiableIterator<String> emptyIterator = ImmutableList.<String>of().iterator(); //When Stream<String> actual = Iterators.toStream(emptyIterator); //Then assertThat(actual.count()).isEqualTo(0); }
@Test void toStreamShouldReturnSameContent() { //Given UnmodifiableIterator<String> iterator = ImmutableList.of("a", "b", "c").iterator(); //When Stream<String> actual = Iterators.toStream(iterator); //Then assertThat(actual.collect(toList())).containsExactly("a", "b", "c"); }
public Stream<T> getBuildChain() throws CycleDetectedException { DefaultDirectedGraph<T, DefaultEdge> graph = builder.build(); ensureNoCycle(graph); return Iterators.toStream(new TopologicalOrderIterator<>(graph)); }
public static boolean mappingAlreadyExist(Client client, IndexName indexName, TypeName typeName) { return Iterators.toStream(client.admin() .indices() .prepareGetMappings(indexName.getValue()) .execute() .actionGet() .getMappings() .valuesIt()) .anyMatch(mapping -> mapping.keys().contains(typeName.getValue())); }
private Task.Result reIndex(MailboxPath path, MailboxSession mailboxSession, ReprocessingContext reprocessingContext) throws MailboxException { LOGGER.info("Intend to reindex {}", path.asString()); Mailbox mailbox = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession).findMailboxByPath(path); messageSearchIndex.deleteAll(mailboxSession, mailbox); try { return Iterators.toStream( mailboxSessionMapperFactory.getMessageMapper(mailboxSession) .findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Metadata, NO_LIMIT)) .map(MailboxMessage::getUid) .map(uid -> handleMessageReIndexing(mailboxSession, mailbox, uid)) .peek(reprocessingContext::updateAccordingToReprocessingResult) .reduce(Task::combine) .orElse(Task.Result.COMPLETED); } finally { LOGGER.info("Finish to reindex {}", path.asString()); } }