Java Code Examples for java.util.stream.Stream#flatMap()

@Override
public Stream<? extends Type> apply( Type type )
{
    Class clazz = RAW_CLASS.apply( type );

    if( clazz.isInterface() )
    {
        Stream<? extends Type> genericInterfaces = Arrays.stream( clazz.getGenericInterfaces() );
        Stream<? extends Type> intfaces = genericInterfaces.flatMap( INTERFACES_OF );
        return concat( Stream.of( type ), intfaces );
    }
    else
    {
        if( type.equals( Object.class ) )
        {
            return Arrays.stream( clazz.getGenericInterfaces() );
        }
        else
        {
            return concat( Stream.of( clazz.getGenericInterfaces() ).flatMap( INTERFACES_OF ),
                           Stream.of( clazz.getSuperclass() ).flatMap( INTERFACES_OF ) );

        }
    }
}
 

/**
 * Generates a tree of patterns where such that each child is a generalisation of its parent pattern.
 * @param basePattern starting specific pattern
 * @param ctx schema(type) context
 * @return map containing parent->{children} mappings
 */
private static HashMultimap<Pattern, Pattern> generatePatternTree(Pattern basePattern, TransactionContext ctx, List<Operator> ops, int maxOps){
    HashMultimap<Pattern, Pattern> patternTree = HashMultimap.create();
    Set<Pattern> output = Operators.removeSubstitution().apply(basePattern, ctx).collect(Collectors.toSet());

    int applications = 0;
    while (!(output.isEmpty() || applications > maxOps)){
        Stream<Pattern> pstream = output.stream();
        for(Operator op : ops){
            pstream = pstream.flatMap(parent -> op.apply(parent, ctx).peek(child -> patternTree.put(parent, child)));
        }
        output = pstream.collect(Collectors.toSet());
        applications++;
    }
    return patternTree;
}
 

/**
 * Returns all the nodes at the given depth in the history tree, always including a node from the
 * main variation (possibly less deep that the given depth).
 *
 * @return the list of candidate nodes
 */
private List<BoardHistoryNode> branchCandidates(BoardHistoryNode node) {
  int targetDepth = node.getData().moveNumber;
  Stream<BoardHistoryNode> nodes = singletonList(history.root()).stream();
  for (int i = 0; i < targetDepth; i++) {
    nodes = nodes.flatMap(n -> n.getVariations().stream());
  }
  LinkedList<BoardHistoryNode> result = nodes.collect(Collectors.toCollection(LinkedList::new));

  if (result.isEmpty() || !result.get(0).isMainTrunk()) {
    BoardHistoryNode endOfMainTrunk = history.root();
    while (endOfMainTrunk.next().isPresent()) {
      endOfMainTrunk = endOfMainTrunk.next().get();
    }
    result.addFirst(endOfMainTrunk);
    return result;
  } else {
    return result;
  }
}
 

@Test
public void
stream_of_nonempty_optionals() {
    Stream<Integer> numbers = Stream.of(123, 456);
    Stream<Integer> results = numbers.flatMap(n -> StreamUtils.stream(maybeAdd3(n)));
    List<Integer> resultList = results.collect(Collectors.toList());
    assertEquals(Arrays.asList(126, 459), resultList);
}
 

private void writeLocal(String string) throws IOException {
    Stream<HtmlElement> stream = Html.stream(string);
    for (int index = 0; index < steps.length; ++index ) {
        stream = stream.flatMap(steps[index]);
        log.error("adding {}", steps[index]);
    }
    char[] cache = stream.map(HtmlElements.TO_HTML).collect(Collectors.joining()).toCharArray();
    originalWriter.write(cache, 0, cache.length);
}
 

/**
 * Create a decorator map from a mapping of GroupMatchers.
 */
private static DecoratorMap group_map_(Map<String, PathMatcher> paths) {
    if (paths.isEmpty()) return concat();

    return new DecoratorMap() {
        @Override
        public Stream<Consumer<MutableContext>> map(Stream<Consumer<MutableContext>> in, Context ctx) {
            final Map<String, TimeSeriesValueSet> pathMapping = paths.entrySet().stream()
                    .collect(Collectors.toMap(Map.Entry::getKey,
                            pmEntry -> {
                                return ctx.getTSData()
                                .getCurrentCollection()
                                .get(p -> pmEntry.getValue().match(p.getPath()), x -> true);
                            }));

            for (final Map.Entry<String, TimeSeriesValueSet> pm
                         : pathMapping.entrySet()) {
                final String identifier = pm.getKey();
                final List<Consumer<MutableContext>> applications = pm.getValue().stream()
                        .map(group -> {
                            Consumer<MutableContext> application = (nestedCtx) -> nestedCtx.putGroupAliasByName(identifier, group::getGroup);
                            return application;
                        })
                        .collect(Collectors.toList());

                in = in.flatMap(inApplication -> applications.stream().map(inApplication::andThen));
            }
            return in;
        }
    };
}
 

@Override
public Stream<String> apply(Stream<String> input) {
    if (option.equals(Option.L)) {
        return Stream.of(valueOf(input.count()));
    } else {
        Stream<String> stringStream = input.flatMap(s -> Stream.of(s.split(" +")));
        return Stream.of(valueOf(stringStream.count()));
    }
}
 

@Override
public Stream<TestResultPayload> extract(Stream<TestStep> testSteps) {
    Stream<HttpValidationResult> payloads = testSteps
            .flatMap(s -> s.getCombinedPayloadsOfType(HttpValidationResult.class));

    return Stream.of(new TestResultPayload(HTTP_CALLS_PAYLOAD_NAME,
            payloads.map(HttpValidationResult::toMap).collect(Collectors.toList())));
}
 

@Nonnull
@Override
public Stream<PlannerBindings> bindTo(@Nonnull final ExpressionMatcher<? extends Bindable> matcher) {
    Stream<PlannerBindings> bindings = matcher.matchWith(this);
    return bindings.flatMap(outerBindings -> matcher.getChildrenMatcher().matches(ImmutableList.of(getRangesOver()))
            .map(outerBindings::mergedWith));
}
 

@Override
@Nonnull
public Stream<PlannerBindings> bindTo(@Nonnull ExpressionMatcher<? extends Bindable> matcher) {
    Stream<PlannerBindings> bindings = matcher.matchWith(this);
    return bindings.flatMap(outerBindings -> matcher.getChildrenMatcher().matches(ImmutableList.of(getChild()))
            .map(outerBindings::mergedWith));
}
 

/**
 * Creates a stream of hostname identifiers from a stream of hostname expressions
 *
 * @param hostnameExpressions the hostname expressions
 * @return the hostname identifiers
 */
public static Stream<InstanceIdentifier> createIdentifiers(Stream<String> hostnameExpressions) {
    return hostnameExpressions.flatMap(hostnameExpression -> extractHostnames(hostnameExpression).flatMap(hostname -> {
        ExtractedRange extractedRange = new ExtractedRange(hostname, '(', ')');
        if (extractedRange.range == null) {
            return Stream.of(new InstanceIdentifier(hostname, 1));
        }
        if (!StringUtils.isEmpty(extractedRange.afterClose)) {
            throw new IllegalArgumentException("No characters expected after )");
        }
        return extractedRange.range.map(numString -> new InstanceIdentifier(extractedRange.beforeOpen, Integer.parseInt(numString)));
    }));
}
 

@Override
public Stream<DependencyModel> dependencies()
{
    Stream<Dependencies> models = Stream.of( this.mixinsModel, compositeMethodsModel );
    return models.flatMap( Dependencies::dependencies );
}
 

protected Set<String> getValuesForFieldFromHistory(String field, List<SuggestionQuery> history) {
  final Stream<String> stringStream = history.stream().map(SuggestionQuery::getValue).filter(x -> x.contains(field));
  final Stream<String> fieldValues = stringStream.flatMap(s -> getFieldValues(field, s).stream());
  return fieldValues.collect(Collectors.toSet());
}
 

public Stream<Envelope> messages() {
    Stream<Envelope> envelopeStream = envelopes != null ? envelopes.stream() : envelopeStreamFromPaths(paths);
    return envelopeStream
            .flatMap((Function<Envelope, Stream<Envelope>>) envelope -> parserMessageStream(envelope, includeSource, includeAst, includePickles));
}
 

public Stream<Envelope> messages() {
    Stream<Envelope> envelopeStream = envelopes != null ? envelopes.stream() : envelopeStreamFromPaths(paths);
    return envelopeStream
            .flatMap((Function<Envelope, Stream<Envelope>>) envelope -> parserMessageStream(envelope, includeSource, includeAst, includePickles));
}
 

private Stream<RaftServerImpl> getServerStream(RaftGroupId groupId) {
  final Stream<RaftServerProxy> stream = getRaftServerProxyStream(groupId);
  return groupId != null?
      stream.filter(s -> s.containsGroup(groupId)).map(s -> RaftServerTestUtil.getRaftServerImpl(s, groupId))
      : stream.flatMap(s -> RaftServerTestUtil.getRaftServerImpls(s).stream());
}
 

private Stream<UiSchema> flattenUiSchema(final Stream<UiSchema> uiSchema) {
    return uiSchema
            .flatMap(u -> u.getItems() == null ? Stream.of(u)
                    : Stream.concat(Stream.of(u), flattenUiSchema(u.getItems().stream())));
}
 

/**
 * Get a stream of all equipped items.
 *
 * @return equipped items
 */
private Stream<Item> equippedStream() {
	Stream<String> slotNames = Slots.CARRYING.getNames().stream();
	Stream<RPSlot> slots = slotNames.map(this::getSlot).filter(Objects::nonNull);
	return slots.flatMap(this::slotStream);
}
 

public static Stream<Type> typesOf( Stream<? extends Type> types )
{
    return types.flatMap( TYPES_OF );
}
 

private Stream<RaftServerImpl> getServerStream(RaftGroupId groupId) {
  final Stream<RaftServerProxy> stream = getRaftServerProxyStream(groupId);
  return groupId != null?
      stream.filter(s -> s.containsGroup(groupId)).map(s -> RaftServerTestUtil.getRaftServerImpl(s, groupId))
      : stream.flatMap(s -> RaftServerTestUtil.getRaftServerImpls(s).stream());
}