/** * Returns an equivalent stream that is sequential. May return * itself, either because the stream was already sequential, or because * the underlying stream state was modified to be sequential. * <p> * This is an intermediate operation. * * @return a sequential stream */ @Override public MapStream<K, V> sequential() { inner = inner.sequential(); return this; }
private static Map<String, Object> convertHttptrace(List<Map<String, Object>> traces) { return singletonMap("traces", traces.stream().sequential().map(LegacyEndpointConverters::convertHttptrace).collect(toList())); }
@SuppressWarnings("unchecked") private static Map<String, Object> convertFlyway(List<Map<String, Object>> reports) { Map<String, Object> flywayBeans = reports.stream() .sequential() .collect(toMap(r -> (String) r.get("name"), r -> singletonMap("migrations", LegacyEndpointConverters.convertFlywayMigrations( (List<Map<String, Object>>) r.get("migrations"))))); return singletonMap("contexts", singletonMap("application", singletonMap("flywayBeans", flywayBeans))); }
@SuppressWarnings("unchecked") private static Map<String, Object> convertLiquibase(List<Map<String, Object>> reports) { Map<String, Object> liquibaseBeans = reports.stream() .sequential() .collect(toMap(r -> (String) r.get("name"), r -> singletonMap("changeSets", LegacyEndpointConverters.convertLiquibaseChangesets( (List<Map<String, Object>>) r.get("changeLogs"))))); return singletonMap("contexts", singletonMap("application", singletonMap("liquibaseBeans", liquibaseBeans))); }
@Override public Stream<T> sequential() { return wrap(stream().sequential()); }
private List<Tag> getObjectTags(ProcessContext context, FlowFile flowFile) { final String prefix = context.getProperty(OBJECT_TAGS_PREFIX).evaluateAttributeExpressions(flowFile).getValue(); final List<Tag> objectTags = new ArrayList<>(); final Map<String, String> attributesMap = flowFile.getAttributes(); attributesMap.entrySet().stream().sequential() .filter(attribute -> attribute.getKey().startsWith(prefix)) .forEach(attribute -> { String tagKey = attribute.getKey(); String tagValue = attribute.getValue(); if (context.getProperty(REMOVE_TAG_PREFIX).asBoolean()) { tagKey = tagKey.replace(prefix, ""); } objectTags.add(new Tag(tagKey, tagValue)); }); return objectTags; }
return segments.stream().sequential().flatMap( (final WindowedDataSegment segment) -> { FileInputFormat.setInputPaths(
/** {@inheritDoc} */ @Override public Stream<UpstreamEntry> transform(Stream<UpstreamEntry> upstream) { PoissonDistribution poisson = new PoissonDistribution( new Well19937c(seed), subsampleRatio, PoissonDistribution.DEFAULT_EPSILON, PoissonDistribution.DEFAULT_MAX_ITERATIONS); return upstream.sequential().flatMap(en -> Stream.generate(() -> en).limit(poisson.sample())); } }
executor.execute(() -> { try { final Iterator<T> it = stream.sequential().iterator(); boolean headerSent = false; while (it.hasNext()) {
@Override public Stream<T> sequential() { return stream().sequential(); }
@Override public Object generate( SourceOfRandomness random, GenerationStatus status) { int length = length(random, status); Object array = Array.newInstance(componentType, length); Stream<?> items = Stream.generate(() -> component.generate(random, status)) .sequential(); if (distinct) items = items.distinct(); Iterator<?> iterator = items.iterator(); for (int i = 0; i < length; ++i) Array.set(array, i, iterator.next()); return array; }
@Override public Stream<T> sequential() { realizeStream(); return wrap(wrappedStream.sequential()); }
@SuppressWarnings("unchecked") @Override public T generate( SourceOfRandomness random, GenerationStatus status) { int size = size(random, status); Generator<?> generator = componentGenerators().get(0); Stream<?> itemStream = Stream.generate(() -> generator.generate(random, status)) .sequential(); if (distinct) itemStream = itemStream.distinct(); T items = empty(); itemStream.limit(size).forEach(items::add); return items; }
@SuppressWarnings("unchecked") @Override public T generate( SourceOfRandomness random, GenerationStatus status) { int size = size(random, status); Generator<?> keyGenerator = componentGenerators().get(0); Stream<?> keyStream = Stream.generate(() -> keyGenerator.generate(random, status)) .sequential(); if (distinct) keyStream = keyStream.distinct(); T items = empty(); Generator<?> valueGenerator = componentGenerators().get(1); keyStream .map(key -> new SimpleEntry(key, valueGenerator.generate(random, status))) .filter(entry -> okToAdd(entry.getKey(), entry.getValue())) .limit(size) .forEach(entry -> items.put(entry.getKey(), entry.getValue())); return items; }
private Optional<Entry<String, String>> findMapping( String uri, boolean partial ) { return getNsPrefixMap().entrySet().stream().sequential().filter(e->{ String ss = e.getValue(); if (uri.startsWith( ss ) && (partial || ss.length() == uri.length())) return true; return false; }).findFirst(); }
private Stream<Function<DeriveConfig, DeriveConfig>> deriveConfigs(TypeElement typeElement, Element element, HashSet<AnnotationMirror> seenAnnotations) { return element.getAnnotationMirrors().stream().sequential().filter(a -> !seenAnnotations.contains(a)).flatMap(a -> { seenAnnotations.add(a); return concat(deriveConfigs(typeElement, a.getAnnotationType().asElement(), seenAnnotations), annotationConfig(typeElement, a)); }); }
private Stream<Function<DeriveConfig, DeriveConfig>> deriveConfigs(TypeElement typeElement, Element element, HashSet<AnnotationMirror> seenAnnotations) { return element.getAnnotationMirrors().stream().sequential().filter(a -> !seenAnnotations.contains(a)).flatMap(a -> { seenAnnotations.add(a); return concat(deriveConfigs(typeElement, a.getAnnotationType().asElement(), seenAnnotations), annotationConfig(typeElement, a)); }); }
default Stream<Quad> findInUnionGraph(final Node s, final Node p, final Node o) { final Set<Triple> seen = new HashSet<>(); return find(ANY, s, p, o).sequential() .filter(q -> !q.isDefaultGraph()) .map(Quad::asTriple) .filter(seen::add) .map(t -> Quad.create(Quad.unionGraph, t)); } }
@Override public Stream<Map<String, Concept>> stream(Optional<MindmapsGraph> optionalGraph, Optional<MatchOrder> order) { MindmapsGraph graph = optionalGraph.orElseThrow( () -> new IllegalStateException(ErrorMessage.NO_GRAPH.getMessage()) ); for (VarAdmin var : pattern.getVars()) { var.getProperties().forEach(property -> ((VarPropertyInternal) property).checkValid(graph, var)); } GraphTraversal<Vertex, Map<String, Vertex>> traversal = getQuery(graph, order).getTraversal(); return traversal.toStream().map(vertices -> makeResults(graph, vertices)).sequential(); }
private static List<Binding> build(List<String> items) { return items.stream().sequential().map((s)->{ BindingMap b = BindingFactory.create() ; b.add(var_a, NodeFactory.createLiteral(s)) ; return b ; }).collect(Collectors.toList()) ; }