/** * Obtains a stream of resource URLs. * * @param path The path * @return A resource stream */ public Stream<URL> getResources(String path) { Enumeration<URL> all; try { all = classLoader.getResources(prefixPath(path)); } catch (IOException e) { return Stream.empty(); } Stream.Builder<URL> builder = Stream.builder(); while (all.hasMoreElements()) { URL url = all.nextElement(); builder.accept(url); } return builder.build(); }
protected <U, W extends Tuple> JinqStream<W> groupToTuple(Select<T, U> select, AggregateGroup<U, T, ?>[] aggregates) { Map<U, List<T>> groups = collect(Collectors.groupingBy(in -> select.select(in))); final Stream.Builder<W> streamBuilder = Stream.builder(); for (Map.Entry<U, List<T>> entry: groups.entrySet()) { Object[] groupAggregates = new Object[aggregates.length + 1]; for (int n = 0; n < aggregates.length; n++) groupAggregates[n + 1] = aggregates[n].aggregateSelect(entry.getKey(), wrap(entry.getValue().stream())); groupAggregates[0] = (Object)entry.getKey(); streamBuilder.accept(Tuple.createTuple(groupAggregates)); } return (JinqStream<W>) wrap(streamBuilder.build()); }
@Override public <U> JinqStream<Pair<T, U>> crossJoin(JinqStream<U> join) { List<U> saved = join.toList(); // TODO: This stream should be constructed on the fly final Stream.Builder<Pair<T,U>> streamBuilder = Stream.builder(); forEach( left -> { saved.stream().forEach( right -> streamBuilder.accept(new Pair<>(left, right))); }); return wrap(streamBuilder.build()); }
@Override public void onNext(Event event) { eventStream.accept(eventCipher.decrypt(event)); count++; }
private void buildSlaves(Stream.Builder<Redis> builder, ReplicationGroup g) { for (Integer slavePort : g.slavePorts) { serverBuilder.reset(); serverBuilder.port(slavePort); serverBuilder.slaveOf("localhost", g.masterPort); final RedisServer slave = serverBuilder.build(); builder.accept(slave); } }
private Stream<Triple> getRepositoryTriples() { LOGGER.trace("Creating RDF triples for repository description"); final Stream.Builder<Triple> b = Stream.builder(); of("RepositoryRoot", "Resource", "Container").forEach(x -> b.accept(create(subject(), type.asNode(), createURI(REPOSITORY_NAMESPACE + x)))); // offer all these accumulated triples return b.build(); } }
@Override public void onNext(Event event) { eventStream.accept(eventCipher.decrypt(event)); count++; }
/** * Returns stream that contains this class and all its superclasses in order. */ private static Stream<Class<?>> superclassStream(final Class<?> clazz) { final Stream.Builder<Class<?>> superclassStreamBuilder = Stream.builder(); for(Class<?> current = clazz; current!=null; current = current.getSuperclass()) { superclassStreamBuilder.accept(current); } return superclassStreamBuilder.build(); }
private void collectGroupContent( ExplicitGroup eg, Stream.Builder<Group> out ) { eg.getContainedRoleAssgineeIdentifiers().stream() .map( idtf -> roleAssigneeSvc.getRoleAssignee(idtf) ) .filter( asn -> asn instanceof Group ) .forEach( group -> out.accept((Group)group) ); eg.getContainedExplicitGroups().forEach( meg -> { out.accept(meg); collectGroupContent(meg, out); }); }
private List<Redis> buildServers() { return groups.stream().flatMap(g -> { final Stream.Builder<Redis> builder = Stream.builder(); builder.accept(buildMaster(g)); buildSlaves(builder, g); return builder.build(); }).collect(Collectors.toList()); }
public ExactQuantile combine(final ExactQuantile other) { if (_array.isEvaluated()) { throw new IllegalStateException( "Quantile has already been evaluated." ); } _collectors.accept(other); return this; }
@Override public <U> JinqStream<Pair<T, U>> leftOuterJoin(JoinWithSource<T, U> join, WhereForOn<T, U> on) { // TODO: This stream should be constructed on the fly final Stream.Builder<Pair<T,U>> streamBuilder = Stream.builder(); forEach( left -> { AtomicBoolean wasMatched = new AtomicBoolean(); join.join(left, inQueryStreamSource).forEach( right -> { if (on.where(left, right)) { wasMatched.set(true); streamBuilder.accept(new Pair<>(left, right)); } }); if (!wasMatched.get()) streamBuilder.accept(new Pair<>(left, null)); }); return wrap(streamBuilder.build()); }
@Override public <U> JinqStream<Pair<T, U>> leftOuterJoinList( org.jinq.orm.stream.JinqStream.JoinToIterable<T, U> join) { // TODO: This stream should be constructed on the fly final Stream.Builder<Pair<T,U>> streamBuilder = Stream.builder(); forEach( left -> { int count = 0; for (U right: join.join(left)) { streamBuilder.accept(new Pair<>(left, right)); count++; } if (count == 0) streamBuilder.accept(new Pair<>(left, null)); }); return wrap(streamBuilder.build()); }
@Override public <U> JinqStream<Pair<T, U>> leftOuterJoin(Join<T,U> join) { // TODO: This stream should be constructed on the fly final Stream.Builder<Pair<T,U>> streamBuilder = Stream.builder(); forEach( left -> { if (join.join(left).count() > 0) join.join(left).forEach( right -> { streamBuilder.accept(new Pair<>(left, right)); }); else streamBuilder.accept(new Pair<>(left, null)); }); return wrap(streamBuilder.build()); }
@Override public <U> JinqStream<Pair<T, U>> join(JoinWithSource<T,U> join) { // TODO: This stream should be constructed on the fly final Stream.Builder<Pair<T,U>> streamBuilder = Stream.builder(); forEach( left -> { join.join(left, inQueryStreamSource).forEach( right -> { streamBuilder.accept(new Pair<>(left, right)); }); }); return wrap(streamBuilder.build()); }
@Override public <U> JinqStream<Pair<T, U>> joinList( org.jinq.orm.stream.JinqStream.JoinToIterable<T, U> join) { // TODO: This stream should be constructed on the fly final Stream.Builder<Pair<T,U>> streamBuilder = Stream.builder(); forEach( left -> { for (U right: join.join(left)) { streamBuilder.accept(new Pair<>(left, right)); }}); return wrap(streamBuilder.build()); }
@Override public <U> JinqStream<Pair<T, U>> join(Join<T,U> join) { // TODO: This stream should be constructed on the fly final Stream.Builder<Pair<T,U>> streamBuilder = Stream.builder(); forEach( left -> { join.join(left).forEach( right -> { streamBuilder.accept(new Pair<>(left, right)); }); }); return wrap(streamBuilder.build()); }
@Override public void onNext(Event event) { eventStream.accept(eventCipher.decrypt(event)); count++; }
@Override public void onNext(Event event) { eventStream.accept(eventCipher.decrypt(event)); count++; }
@Override Stream<ExecutingQuery> queries() { Stream.Builder<ExecutingQuery> builder = Stream.builder(); ExecutingQueryList entry = this; while ( entry != EMPTY ) { Entry current = (Entry) entry; builder.accept( current.query ); entry = current.next; } return builder.build(); }