private static <T> Stream.Builder<? extends T> traverseBredthFirst( T first, Function<T, Stream<? extends T>> traverser, Stream.Builder<T> builder) { requireNonNulls(first, traverser, builder); if (first == null) { return builder; } final Queue<T> q = new ArrayDeque<>(); q.add(first); while (!q.isEmpty()) { final T node = q.poll(); builder.add(node); traverser .apply(node) .filter(Objects::nonNull) .forEach(q::add); } return builder; }
/** * Get an iterator on the list of project helpers configured. The iterator * will always return at least one element as there will always be the * default project helper configured. * * @return an iterator of {@link ProjectHelper} */ public Iterator<ProjectHelper> getHelpers() { Stream.Builder<Constructor<? extends ProjectHelper>> b = Stream.builder(); helpers.forEach(b::add); return b.add(PROJECTHELPER2_CONSTRUCTOR).build().map(c -> { try { return c.newInstance(); } catch (Exception e) { throw new BuildException("Failed to invoke no-arg constructor" + " on " + c.getName()); } }).map(ProjectHelper.class::cast).iterator(); } }
public Stream<Class<? extends Constraint>> domains() { Stream.Builder<Class<? extends Constraint>> builder = Stream.builder(); constraintPMap.forEach((domain, constraint) -> builder.add(domain)); return builder.build(); }
@Override public Stream<VarPatternAdmin> innerVarPatterns() { return relationPlayers().stream().flatMap(relationPlayer -> { Stream.Builder<VarPatternAdmin> builder = Stream.builder(); builder.add(relationPlayer.getRolePlayer()); relationPlayer.getRole().ifPresent(builder::add); return builder.build(); }); }
@Override public void visitSynchronizedStatement(SynchronizedStatementTree tree) { synchronizedKeywords.add(tree.synchronizedKeyword()); super.visitSynchronizedStatement(tree); }
static Stream<Constraint> pmapToStream(@Nullable PMap<Class<? extends Constraint>, Constraint> pmap) { if(pmap == null) { return Stream.empty(); } Stream.Builder<Constraint> result = Stream.builder(); pmap.forEach((d, c) -> result.add(c)); return result.build(); }
@Test public void collectingOneDatasetGivesThatDataset() { Graph graph = parseGraph("(graph (triple <s1> <p1> <o1> ))"); Model model = createModelForGraph(graph); Dataset dataset = DatasetFactory.create(model); Node graphName = NodeFactory.createBlankNode(); dataset.addNamedModel(graphName.toString(), model); Dataset collection = Stream.<Dataset>builder().add(dataset).build().collect(testInstance()); assertDatasetsAreIsomorphicPerGraph(dataset, collection); }
@Test public void collectionOfStreamOfEmptyDatasetsShouldBeEmpty() { Stream<Dataset> stream = Stream.<Dataset>builder() .add(DatasetFactory.create()) .add(DatasetFactory.create()) .add(DatasetFactory.create()).build(); final Dataset collected = stream.collect(testInstance()); assertTrue(collected.isEmpty()); }
public Stream<Class<? extends Constraint>> domains() { Stream.Builder<Class<? extends Constraint>> builder = Stream.builder(); constraintPMap.forEach((domain, constraint) -> builder.add(domain)); return builder.build(); }
public FileToWordsBuilder(String filePath) throws Exception { Files.lines(Paths.get(filePath)) .skip(1) // Skip the comment line at the beginning .forEach(line -> { for(String w : line.split("[ .?,]+")) builder.add(w); }); } Stream<String> stream() { return builder.build(); }
/** * Extracts all tokens from a {@code document} as a stream. */ public Stream<Word> extractTokens(Word document) { Stream.Builder<Word> output = Stream.builder(); String[] words = tokenizer.tokenize(document.word()); // Ensure we track empty documents throughout so that they are not reprocessed. if (words.length == 0) { output.add(Word.builder().path(document.path()).word("").build()); return output.build(); } for (int i = 0; i < words.length; i++) { output.add(Word.builder().path(document.path()).word(words[i]).build()); } return output.build(); }
public static Stream<ResourceTableEntry> entries(ResourceTable resourceTable) { Stream.Builder<ResourceTableEntry> stream = Stream.builder(); for (Package pkg : resourceTable.getPackageList()) { for (Type type : pkg.getTypeList()) { for (Entry entry : type.getEntryList()) { stream.add(ResourceTableEntry.create(pkg, type, entry)); } } } return stream.build(); }
streamBuilder.add(rsMapper.apply(rs));
private static <T> Stream.Builder<? extends T> traverse( T first, Function<T, Stream<? extends T>> traverser, TraversalOrder traversalOrder, Stream.Builder<T> builder) { requireNonNulls(first, traverser, traversalOrder, builder); if (first == null) { return builder; } if (traversalOrder == TraversalOrder.DEPTH_FIRST_PRE) { builder.add(first); } final Stream<? extends T> next = traverser.apply(first); if (next != null) { next.filter(Objects::nonNull) .forEach((T n) -> { traverse(n, traverser, traversalOrder, builder); }); } if (traversalOrder == TraversalOrder.DEPTH_FIRST_POST) { builder.add(first); } return builder; }
public static String[] generateApplyResultSetBody( ReadFromResultSet readFromResultSet, TranslatorSupport<Table> support, File file, Supplier<Stream<? extends Column>> columnsSupplier) { file.add(Import.of(SQLException.class)); final List<String> rows = new LinkedList<>(); rows.add("return createEntity()"); final Stream.Builder<String> streamBuilder = Stream.builder(); final AtomicInteger position = new AtomicInteger(1); columnsSupplier.get() .filter(HasEnabled::isEnabled) .forEachOrdered(c -> streamBuilder.add(indent(".set" + support.namer().javaTypeName(c.getJavaName()) + "(\t " + readFromResultSet.readFromResultSet(file, c, position) + ")")) ); streamBuilder.add(indent(";")); streamBuilder.build().forEachOrdered(rows::add); return rows.toArray(new String[rows.size()]); }
/** * Returns a {@link Stream} of the current mappings that are registered with * this class. Mappings that are not associated to any particular DbmsType * will have their {@code Optional<DbmsType>} set to * {@code Optional.empty()} whereas specific DbmsType mappings will have the * {@code Optional<DbmsType>} field set accordingly. * * @return a {@link Stream} of the current mappings that are registered with * this class */ public Stream<Tuple2<Optional<DbmsType>, ResultSetMapping<?>>> stream() { final Stream<Tuple2<Optional<DbmsType>, ResultSetMapping<?>>> s0 = map.values().stream().map(v -> Tuples.of(Optional.empty(), v)); final Stream.Builder<Stream<Tuple2<Optional<DbmsType>, ResultSetMapping<?>>>> sb = Stream.builder(); sb.add(s0); dbmsTypeMap.entrySet().forEach(e -> { final DbmsType dbmsType = e.getKey(); Stream<Tuple2<Optional<DbmsType>, ResultSetMapping<?>>> sn = e.getValue().values().stream().map(v -> Tuples.of(Optional.of(dbmsType), v)); sb.add(sn); }); return sb.build().flatMap(Function.identity()); }
private static <T> Stream.Builder<? extends T> walk( T first, Function<T, T> traverser, WalkingOrder order, Stream.Builder<T> builder) { requireNonNulls(first, traverser, order, builder); if (order == WalkingOrder.FORWARD) { builder.add(first); } final T next = traverser.apply(first); if (next != null) { walk(next, traverser, order, builder); } if (order == WalkingOrder.BACKWARD) { builder.add(first); } return builder; }
private static <T> Stream.Builder<? extends T> walkOptional( T first, Function<T, Optional<T>> traverser, WalkingOrder order, Stream.Builder<T> builder) { requireNonNulls(first, traverser, order, builder); if (order == WalkingOrder.FORWARD) { builder.add(first); } traverser.apply(first) .ifPresent(p -> walkOptional(p, traverser, order, builder)); if (order == WalkingOrder.BACKWARD) { builder.add(first); } return builder; }
private static <A extends Attribute> void writeAttributes(XMLExtendedStreamWriter writer, ModelNode model, Stream<A> stream) throws XMLStreamException { // Write attributes before elements Stream.Builder<Attribute> objectAttributes = Stream.builder(); Iterable<A> attributes = stream::iterator; for (Attribute attribute : attributes) { if (attribute.getDefinition().getType() == ModelType.OBJECT) { objectAttributes.add(attribute); } else { writeAttribute(writer, model, attribute); } } Iterable<Attribute> elementAttributes = objectAttributes.build()::iterator; for (Attribute attribute : elementAttributes) { writeElement(writer, model, attribute); } }