private Iterator<Quad> filter(Iterator<Quad> iter) { if ( this.quadFilter == null ) return iter; return Iter.filter(iter, this::filter); }
public static <T> Iterator<T> notFilter(final Iterator<? extends T> stream, final Predicate<T> filter) { return filter(stream, filter.negate()) ; }
/** 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 static <T> Iterator<T> distinctAdjacent(Iterator<T> iter) { return filter(iter, new FilterDistinctAdjacent<T>()) ; }
/** Return an iterator that will see each element of the underlying iterator only once. * Note that this need working memory to remember the elements already seen. */ public static <T> Iterator<T> distinct(Iterator<T> iter) { return filter(iter, new FilterUnique<T>()) ; }
/** Remove adjacent duplicates */ public static <T> Iterator<T> distinctAdjacent(Iterator<T> iter) { return filter(iter, new FilterDistinctAdjacent<T>()) ; }
/** Return an iterator that will see each element of the underlying iterator only once. * Note that this need working memory to remember the elements already seen. */ public static <T> Iterator<T> distinct(Iterator<T> iter) { return filter(iter, new FilterUnique<T>()) ; }
/** 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 static <T> Iterator<T> distinctAdjacent(Iterator<T> iter) { return filter(iter, new FilterDistinctAdjacent<T>()) ; }
/** Filter by predicate */ public Iter<T> filter(Predicate<T> filter) { return iter(filter(iterator, filter)) ; }
/** Filter by predicate */ public Iter<T> filter(Predicate<T> filter) { return iter(filter(iterator, filter)) ; }
@Override protected ExtendedIterator<Triple> graphBaseFind(Triple m) { Iterator<Triple> iter = Iter.filter(db.iterator(), m::matches) ; return WrappedIterator.create(iter) ; } }
@Override protected QueryIterator joinFinished() { Iterator<Binding> iter = Iter.filter(hashTable.values(), b-> ! leftHits.contains(b) ) ; return new QueryIterPlainWrapper(iter, getExecContext()) ; } }
public static <T> List<T> unique(List<T> list) { Iter<T> iter = Iter.iter(list.iterator()) ; return iter.filter(new FilterUnique<T>()).toList() ; }
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<Triple> find(Node _s, Node _p, Node _o) { Node s = m(_s) ; Node p = m(_p) ; Node o = m(_o) ; return Iter.filter(triples.iterator(), (t)->matches(t, s, p, o)); }
protected static Iter<Triple> backwardLinks(Graph graph, Node x, Collection<Node> excludeProperties) { Iter<Triple> iter1 = Iter.iter(graph.find(Node.ANY, Node.ANY, x)) ; if ( excludeProperties != null ) iter1 = iter1.filter(new FilterExclude(excludeProperties)) ; return iter1 ; } }
protected Iter<Triple> forwardLinks(Node x, Collection<Node> excludeProperties) { Iter<Triple> iter1 = Iter.iter(graphFind(x, Node.ANY, Node.ANY)) ; if ( excludeProperties != null ) iter1 = iter1.filter(new FilterExclude(excludeProperties)) ; return iter1 ; }
@Test public void filter_02() { Iterator<String> it = Iter.filter(data3.iterator(), item -> "x".equals(item) || "z".equals(item)); test(it, "x", "z"); }
@Test public void filter_03() { Iterator<String> it = Iter.filter(data3.iterator(), item -> null == item || "x".equals(item)); test(it, null, "x", null, null, null, null); }
private static int existsPath(Graph graph, Node subject, Path path, final Node object, ExecutionContext execCxt) { if ( ! subject.isConcrete() || !object.isConcrete() ) throw new ARQInternalErrorException("Non concrete node for existsPath evaluation") ; Iterator<Node> iter = PathEval.eval(graph, subject, path, execCxt.getContext()) ; Predicate<Node> filter = node -> Objects.equals(node, object); // See if we got to the node we're interested in finishing at. iter = Iter.filter(iter, filter) ; long x = Iter.count(iter) ; return (int)x ; } }
private static int existsPath(Graph graph, Node subject, Path path, final Node object) { if ( ! subject.isConcrete() || !object.isConcrete() ) throw new ARQInternalErrorException("Non concrete node for existsPath evaluation") ; Iterator<Node> iter = PathEval.eval(graph, subject, path) ; Filter<Node> filter = new Filter<Node>() { @Override public boolean accept(Node node) { return Lib.equal(node, object) ; } } ; // See if we got to the node we're interested in finishing at. iter = Iter.filter(iter, filter) ; long x = Iter.count(iter) ; return (int)x ; } }