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);
}
