/** Project quads to triples */ public static Iter<Triple> quads2triples(Iterator<Quad> iter) { return Iter.iter(iter).map(Quad::asTriple) ; }
/** Create an {@code Iter} such that it yields elements while a predicate test on * the elements is true, end the iteration. * @see Iter#filter(Predicate) */ public Iter<T> takeWhile(Predicate<T> predicate) { return iter(takeWhile(iterator, predicate)) ; }
/** FlatMap each element using given function of element to iterator of mapped elements.s */ public <R> Iter<R> flatMap(Function<T, Iterator<R>> converter) { return iter(flatMap(iterator, converter)) ; } /**
/** Create an {@code Iter} such that elements from the front while * a predicate test become true are dropped then return all remaining elements * are iterated over. * The first element where the predicted becomes true is the first element of the * returned iterator. */ public Iter<T> dropWhile(Predicate<T> predicate) { return iter(dropWhile(iterator, predicate)) ; }
/** Return an {:@code Iter} that will see each element of the underlying iterator only once. * Note that this need working memory to remember the elements already seen. */ public Iter<T> distinct() { return iter((distinct(iterator))) ; }
/** Evaluate a path */ /*package*/ static Iter<Node> eval$(Graph graph, Node node, Path path, PathEngine engine) { Collection<Node> acc = new ArrayList<>() ; eval$(graph, node, path, engine, acc); return Iter.iter(acc) ; } }
/** Join on an {@code Iterator}.. * If there are going to be many iterators, uit is better to create an {@link IteratorConcat} * and <tt>.add</tt> each iterator. The overheads are much lower. */ public Iter<T> append(Iterator<T> iter) { return iter(IteratorCons.create(iterator, iter)) ; }
/** Remove adjacent duplicates. This operation does not need * working memory to remember the all elements already seen, * just a slot for the last element seen. */ public Iter<T> distinctAdjacent() { return iter(distinctAdjacent(iterator)) ; }
/** * Apply an action to everything in the stream, yielding a stream of the * original items. */ public Iter<T> operate(Consumer<T> action) { return iter(operate(iterator, action)) ; }
/** Create an {@code Iter} such that elements from the front until * a predicate test become true are dropped then return all remaining elements * are iterated over. * The first element where the predicate becomes true is the first element of the * returned iterator. */ public Iter<T> dropUntil(Predicate<T> predicate) { return iter(dropWhile(iterator, predicate.negate())) ; }
static Iter<Token> createN(String s) { PeekReader pr = PeekReader.readString(s) ; TokenizerText tt = new TokenizerText(pr) ; List<Token> x = new ArrayList<>() ; while(tt.hasNext()) x.add(tt.next()) ; return Iter.iter(x) ; }
protected Iter<Triple> backwardLinks(Node x, Collection<Node> excludeProperties) { Iter<Triple> iter1 = Iter.iter(graphFind(Node.ANY, Node.ANY, x)) ; if ( excludeProperties != null ) iter1 = iter1.filter(new FilterExclude(excludeProperties)) ; return iter1 ; }
@Override public Iterator<Node> listGraphNodes() { Iter<Quad> iter = Iter.iter(find(Node.ANY, Node.ANY, Node.ANY, Node.ANY)) ; return iter.map(Quad::getGraph).distinct() ; }
/** List the predicates in a graph (no duplicates) */ public static Iterator<Node> listPredicates(Graph graph) { ExtendedIterator<Triple> iter = graph.find(Node.ANY, Node.ANY, Node.ANY) ; return Iter.iter(iter).map(Triple::getPredicate).distinct() ; }
/** List the subjects in a graph (no duplicates) */ public static Iterator<Node> listSubjects(Graph graph) { ExtendedIterator<Triple> iter = graph.find(Node.ANY, Node.ANY, Node.ANY) ; return Iter.iter(iter).map(Triple::getSubject).distinct() ; }
/** List the objects in a graph (no duplicates) */ public static Iterator<Node> listObjects(Graph graph) { ExtendedIterator<Triple> iter = graph.find(Node.ANY, Node.ANY, Node.ANY) ; return Iter.iter(iter).map(Triple::getObject).distinct() ; }
@Test public void iter_01() { Iter<String> iter = Iter.iter(data2) ; iter = iter.append(data2.iterator()) ; test(iter, "x", "y", "z", "x", "y", "z") ; }
@Override public Iterator<Node> listGraphNodes() { checkNotClosed(); Iterator<Tuple<NodeId>> x = storage.quadTable.getNodeTupleTable().findAll(); Iterator<NodeId> z = Iter.iter(x).map(t -> t.get(0)).distinct(); return NodeLib.nodes(storage.quadTable.getNodeTupleTable().getNodeTable(), z); }
@Test public void peek_1() { PeekIterator<String> peek = create("a", "b", "c") ; assertEquals("a", peek.peek()) ; test(Iter.iter(peek), "a", "b", "c") ; }