private static Stream<String> apps() { if (cl instanceof URLClassLoader) { URLClassLoader ucl = (URLClassLoader) cl; return Stream.of(ucl.getURLs()) .map(propagating(url -> Paths.get(url.toURI()))) .flatMap( propagating( path -> { if (Files.isRegularFile(path)) { return zipContents(path); } else if (Files.isDirectory(path)) { return Files.walk(path) .map(subpath -> path.relativize(subpath)) .map(subpath -> subpath.toString()) .filter(subpath -> subpath.endsWith(".class")) .map(Scanner::toClassName); } else { return Stream.empty(); } })) .filter(x -> !x.startsWith("com.cakemanny.app.")) .filter(implementsInterface(App.class)); } else { return Stream.empty(); } }
public static void main(String[] args) throws IOException { Path path = Paths.get("../alice.txt"); String contents = new String(Files.readAllBytes(path), StandardCharsets.UTF_8); Stream<String> words = Stream.of(contents.split("[\\P{L}]+")); show("words", words); Stream<String> song = Stream.of("gently", "down", "the", "stream"); show("song", song); Stream<String> silence = Stream.empty(); silence = Stream.<String>empty(); // Explicit type specification show("silence", silence); Stream<String> echos = Stream.generate(() -> "Echo"); show("echos", echos); Stream<Double> randoms = Stream.generate(Math::random); show("randoms", randoms); Stream<BigInteger> integers = Stream.iterate(BigInteger.ONE, n -> n.add(BigInteger.ONE)); show("integers", integers); Stream<String> wordsAnotherWay = Pattern.compile("[\\P{L}]+").splitAsStream(contents); show("wordsAnotherWay", wordsAnotherWay); try (Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)) { show("lines", lines); } }
/** * If <code>usePrimary</code> is true the segments are the primary segments but only those that * exist in targetSegments. However if <code>usePrimary</code> is false then <code>targetSegments * </code> must be provided and non null and this will be used specifically. * * @param ch * @param targetSegments * @param excludedKeys * @param usePrimary determines whether we should utilize the primary segments or not. * @return */ protected Supplier<Stream<CacheEntry>> supplierForSegments( ConsistentHash ch, Set<Integer> targetSegments, Set<Object> excludedKeys, boolean usePrimary) { if (!ch.getMembers().contains(localAddress)) { return Stream::empty; } Set<Integer> segments; if (usePrimary) { segments = ch.getPrimarySegmentsForOwner(localAddress); if (targetSegments != null) { segments.retainAll(targetSegments); } } else { segments = targetSegments; } return () -> { if (segments.isEmpty()) { return Stream.empty(); } CacheStream<CacheEntry> stream = supplier.get().filterKeySegments(segments); if (keysToFilter != null) { stream = stream.filterKeys(keysToFilter); } if (excludedKeys != null) { return stream.filter(e -> !excludedKeys.contains(e.getKey())); } // Make sure the stream is set to be parallel or not return parallel ? stream.parallel() : stream.sequential(); }; }
public static <T> Stream<T> traverse( Function<T, Iterator<T>> iteratorBuilder, boolean includeParent, @Nullable T obj) { return ((obj != null) ? StreamSupport.stream( new TraversingSpliterator<>(iteratorBuilder, includeParent, obj), false) : Stream.empty()); }
private static Stream<ElmReference> getReferencesFromSingleId(ElmUpperCaseId element) { if (ElmCoreLibrary.isBuiltIn(element.getText())) { return Stream.empty(); } else { return Stream.of(new ElmTypeReference(element)); } }
@Test public void optionalTAndListTEmptyStream() { OptionalTValue<Integer> opt = OptionalT.fromValue(Maybe.just(Optional.of(10))); ListTSeq<Integer> list = ListT.fromStream(Stream.empty()); assertThat(For.Publishers.each2(list, a -> opt, (a, b) -> a + b).toList(), equalTo(ListX.of())); }
@Override public Stream<IdxPref> getIidxPreferences(int iidx) { if (iidxList.get(iidx) == null) { return Stream.empty(); } else { return iidxList.get(iidx).stream(); } }
public List<Triangle> parseFile(InputStream is) { try { VTDGen vg = new VTDGen(); vg.setDoc(IOUtils.toByteArray(is)); vg.parse(false); VTDNav vn = vg.getNav(); NODE_PATH.resetXPath(); NODE_PATH.bind(vn); // This is important state for the later method calls! NODE_REF_PATH.resetXPath(); NODE_REF_PATH.bind(vn); BUILDING_WAY_PATH.resetXPath(); BUILDING_WAY_PATH.bind(vn); BUILDING_MULTIPOLYGON_PATH.resetXPath(); BUILDING_MULTIPOLYGON_PATH.bind(vn); MEMBER_WAY_PATH.resetXPath(); MEMBER_WAY_PATH.bind(vn); WAY_PATH.resetXPath(); WAY_PATH.bind(vn); // A hash from node ids to actual node positions Hashtable<Long, Point2D> nodes = new Hashtable<>(); // A hash from way refs referenced from multipolygons to their actual list of node refs Hashtable<Long, List<Long>> multipolygonWays = new Hashtable<>(); // The following call initializes accessed node refs in nodes to a dummy value. List<List<Long>> buildingWays = extractWaysOfBuildings(vn, nodes); // The following call initializes accessed way refs from multipolygons to a dummy value. List<List<Tuple2<WayRole, Long>>> multipolygonWayRefs = extractWayRefsOfMultipolygons(vn, multipolygonWays); // This will extract all referenced multipolygon multipolygonWays, excluding the building // multipolygonWays // Also adds referenced nodes to nodes extractReferencedWays(vn, multipolygonWays, nodes); // This will extract all referenced nodes, but no more. extractReferencedNodes(vn, nodes); // Finally build the polygon list by following the node refs in wayRefs. // Triangulate each polygon and return the flattened list of triangles. // This way, poly2tri's types will not leak out of this class and we operate // on triangles anyway. return buildPolygons(nodes, buildingWays, multipolygonWays, multipolygonWayRefs) .flatMap( p -> { try { p.ComplexToSimplePolygon(); EarClipping ec = new EarClipping(p.SimplePolygon); return ec.Triangulation().stream(); } catch (RuntimeException ignored) { } return Stream.empty(); }) .toList(); } catch (XPathEvalException | NavException | IOException | ParseException e) { e.printStackTrace(); return new ArrayList<>(); } }
@Test public void _02_스트림_생성() { // 배열로 부터~ Stream<String> words = Stream.of(contents.split("[\\P{L}]+")); // 가변 인자로.. Stream<String> song = Stream.of("gently", "down", "the", "stream"); // 빈 스트림 Stream<String> silence = Stream.empty(); }
private static <T, R> Function<T, Stream<R>> guarded(FailingFunction<T, R> f) { return t -> { try { return Stream.of(f.apply(t)); } catch (RuntimeException x) { throw x; } catch (Exception x) { return Stream.empty(); } }; }
public Stream<ElmReference> getReferencesStream() { PsiElement parent = this.getParent(); if (parent instanceof ElmImportClause) { return this.getReferencesInImport(); } else if (parent instanceof ElmModuleDeclaration) { return Stream.empty(); } List<ElmUpperCaseId> children = Arrays.stream(this.getChildren()) .filter(e -> e instanceof ElmUpperCaseId) .map(e -> (ElmUpperCaseId) e) .collect(Collectors.toList()); int size = children.size(); if (size == 1) { return getReferencesFromSingleId(children.get(0)); } else if (size >= 2) { return getReferencesFromNonSinglePath(children); } return Stream.empty(); }
@Way public static List<URL> step_2_flatmap(List<String> strings) { return strings .stream() .flatMap( string -> { try { return Stream.of(new URL(string)); } catch (MalformedURLException ignored) { return Stream.empty(); } }) .collect(toList()); }
@Override public Stream<Entity> findAll(Query q) { if (q.getRules().isEmpty()) { return getEntities().stream(); } if ((q.getRules().size() != 1) || (q.getRules().get(0).getOperator() != Operator.EQUALS)) { throw new MolgenisDataException("The only query allowed on this Repository is gene EQUALS"); } String geneSymbol = (String) q.getRules().get(0).getValue(); List<Entity> entities = getEntitiesByGeneSymbol().get(geneSymbol); return entities != null ? entities.stream() : Stream.empty(); }
private List<Location> locationsOfNewbornCells() { return liveCellLocations .stream() .flatMap( l1 -> liveCellLocations .stream() .flatMap( l2 -> liveCellLocations .stream() .flatMap( l3 -> areInNeighbourhoodOfSomeCell(l1, l2, l3) ? emptyLocationsWithLiveNeighboursInAllAndOnlyLocations( l1, l2, l3) : Stream.empty()))) .collect(toList()); }
private Optional<Map<String, String>> variablesFor(String source) { List<Map<String, String>> satisfyingVars = sources .stream() .flatMap( s -> s.variablesFor(source, potentials, Collections.emptyMap()) .map(Stream::of) .orElse(Stream.empty())) .collect(Collectors.toList()); if (satisfyingVars.isEmpty()) { return Optional.empty(); } Map<String, String> allVariables = new HashMap<>(); satisfyingVars.forEach(allVariables::putAll); return Optional.of(allVariables); }
/** * Base solution is assumed to be satisfiable. if cacheQuads is empty and queryQuads is non-empty * the baseSolution is returned * * @param cacheQuads * @param queryQuads * @param baseSolution * @return */ public static Stream<Map<Var, Var>> createSolutions( Collection<Quad> cacheQuads, Collection<Quad> queryQuads, Map<Var, Var> baseSolution) { Stream<Map<Var, Var>> result; if (cacheQuads.isEmpty() && !queryQuads.isEmpty()) { result = Stream.of(baseSolution); } else { TriFunction<Map<Var, Var>, Quad, Quad, Stream<Map<Var, Var>>> solutionCombiner = (s, a, b) -> { Stream<Map<Var, Var>> r; try { // HashBiMap<Var, Var> d = HashBiMap.create(); Map<Var, Var> d = new HashMap<>(); Map<Var, Var> contib = Utils2.createVarMap(a, b); d.putAll(contib); d.putAll(s); r = Stream.of(d); } catch (IllegalArgumentException e) { // Indicates inconsistent variable mapping r = Stream.empty(); } return r; }; result = StateCombinatoricCallback.createKPermutationsOfN( cacheQuads, queryQuads, baseSolution, solutionCombiner) .map(stack -> stack.getValue().getSolution()); } return result; // Stream<Map<Var, Var>> result = IsoMapUtils.createSolutionStream( // cacheQuads, // queryQuads, // (a, b, c) -> Stream.of(Utils2.createVarMap(a, b)), // baseSolution); // // return result; }
private Stream<VirtualMachine> attach(VirtualMachineDescriptor vmDescriptor) { try { com.sun.tools.attach.VirtualMachine vm = com.sun.tools.attach.VirtualMachine.attach(vmDescriptor); String vmArgs = vm.getAgentProperties().getProperty(VM_ARGS); String id = vmDescriptor.id(); String displayName = vmDescriptor.displayName(); boolean agentLoaded = vmArgs.contains(AGENT_NAME); String userDir = getUserDir(vm); return Stream.of(new VirtualMachine(id, displayName, agentLoaded, userDir)); } catch (AttachNotSupportedException e) { logger.warn(e.getMessage()); } catch (IOException e) { if (!noSuchProcess(e)) { logger.warn(e.getMessage(), e); } } return Stream.empty(); }
@Test public void deleteStream() { Stream<Entity> entities = Stream.empty(); entityListenerRepositoryDecorator.delete(entities); verify(decoratedRepository, times(1)).delete(entities); }
@NotNull public static <T> Stream<T> toStream(@Nullable T... items) { return items == null ? Stream.empty() : Stream.of(items); }
@Test public void collectEmptyNSArrayWhenStreamReturnsNoElements() throws Exception { NSArray<?> result = Stream.empty().collect(toNSArray()); assertThat(result.isEmpty(), is(true)); }
@Test public void addStream() { Stream<Entity> entities = Stream.empty(); when(decoratedRepository.add(entities)).thenReturn(Integer.valueOf(123)); assertEquals(entityListenerRepositoryDecorator.add(entities), Integer.valueOf(123)); }
public Stream<Map.Entry<String, JsonValue>> entryStream() { return Stream.empty(); }
public Stream<JsonValue> valueStream() { return Stream.empty(); }
public Stream<String> keyStream() { return Stream.empty(); }
protected Stream<String> stringPathStream(String path) { return Stream.empty(); }
@NotNull public static <T> Stream<T> notNullize(@Nullable Stream<T> items) { return ObjectUtils.notNull(items, Stream.empty()); }
@Test(expected = NullPointerException.class) public void ctorThrowsIfNullArg() { newBuilder(null, Stream.empty()); }
private Stream<ElmReference> getReferencesInImport() { return this.getText().startsWith("Native.") ? Stream.empty() : Stream.of(new ElmFullPathModuleReference(this)); }
/** * Subclasses may override this method to provide objects that the {@link * #read(ResourceLocation...) read} method will return if no resource data can be found in all of * the specified resource locations. * * @return the fall-back objects to use. */ public Stream<T> getFallback() { return Stream.empty(); }
/** * There probably could be some performance issues if there is lots of streams to concat. See * http://mail.openjdk.java.net/pipermail/lambda-dev/2013-July/010659.html for some details. * * <p>Also see {@link Stream#concat(Stream, Stream)} documentation for other possible issues of * concatenating large number of streams. */ @NotNull public static <T> Stream<T> concat(@NotNull Stream<T>... streams) { return toStream(streams).reduce(Stream.empty(), Stream::concat); }