@Override public ExtendedIterator<Triple> filterDrop(final Filter<Triple> filter) { Filter<Triple> negFilter = new Filter<Triple>() { @Override public boolean accept(Triple t) { return !filter.accept(t) ; } }; return new FilterIterator<Triple>(negFilter, this) ; }
/** Answer the next acceptable object from the base iterator. The redundant test of `hasCurrent` appears to make a detectable speed difference. Crazy. */ @Override public T next() { if (hasCurrent || hasNext()) { canRemove = true; hasCurrent = false; return current; } throw new NoSuchElementException(); } }
/** Answer true iff there is at least one more acceptable object. [Stores reference into <code>current</code>, sets <code>canRemove</code> false; answer preserved in `hasCurrent`] */ @Override public boolean hasNext() { while (!hasCurrent && super.hasNext()) hasCurrent = accept( current = super.next() ); canRemove = false; return hasCurrent; }
@Override public ExtendedIterator<Triple> filterKeep(Filter<Triple> filter) { return new FilterIterator<Triple>(filter, this) ; }
/** * <p> * Answer an iterator over the elements of iterator a that are not members of iterator b. * As a side-effect, iterator b will be closed. * </p> * * @param a An iterator that will be filtered by rejecting the elements of b * @param b A closable iterator * @return The iteration of elements in a but not in b. */ public static <T> ClosableIterator<T> butNot( final ClosableIterator<T> a, final ClosableIterator<? extends T> b ) { return new FilterIterator<T>( reject( b ), a ); }
private Iterator<Bucket> scanBuckets() { // Looks through buckets, // if has single member then return in iterator. // Otherwise if some member of the bucket has friends // we can refine the hash, and we set refinableHash. check(HASH_OK); return new FilterIterator<Bucket>( new Filter<Bucket>() { @Override public boolean accept(Bucket o) { Bucket b = o; if (b.size()==1) return true; if (!refinableHash) { Iterator<AnonResource> it = b.members(); while ( it.hasNext() ) if (!it.next() .friends.isEmpty()) { refinableHash = true; break; } } return false; } },table.values().iterator()); } private void unbindAll(Set<AnonResource> s) {
Iterator<Resource> firstChoiceCyclic = new FilterIterator<Resource>(new Filter<Resource>() { @Override public boolean accept(Resource r) { Iterator<Resource> nonAnonInfinite = new FilterIterator<Resource>(new Filter<Resource>() { @Override public boolean accept(Resource r) { Iterator<Resource> reifications = new FilterIterator<Resource>(new Filter<Resource>() { @Override public boolean accept(Resource r) { return new FilterIterator<Resource>(new Filter<Resource>() { @Override public boolean accept(Resource r) {