@Override public <X extends RDFNode> ExtendedIterator<RDFNode> andThen( final Iterator<X> other ) { return iter.andThen(other); }
@Override public <X extends ReifiedStatement> ExtendedIterator<ReifiedStatement> andThen( final Iterator<X> other ) { return iter.andThen(other); }
@Override public <X extends Resource> ExtendedIterator<Resource> andThen( final Iterator<X> other ) { return iter.andThen(other); }
@Override public <X extends Statement> ExtendedIterator<Statement> andThen( final Iterator<X> other ) { return iter.andThen(other); }
private synchronized Collection<SecuredGraphListener> getListenerCollection() { ExtendedIterator<SecuredGraphListener> retval = NiceIterator .emptyIterator(); for (final Collection<SecuredGraphListener> coll : listenerMap.values()) { retval = retval.andThen(coll.iterator()); } return retval.toList(); }
public ExtendedIterator<Key> keyIterator( final NotifyEmpty container ) { showkeys(); final List<Key> movedKeys = new ArrayList<>(); ExtendedIterator<Key> basic = new BasicKeyIterator( changes, container, movedKeys ); ExtendedIterator<Key> leftovers = new MovedKeysIterator( changes, container, movedKeys ); return basic.andThen( leftovers ); }
private ExtendedIterator<Quad> getQuads(Collection<QuadHolder> holders) { ExtendedIterator<Quad> result = NiceIterator.emptyIterator(); for (QuadHolder holder : holders) { result = result.andThen(holder.setValues(values).getQuads()); } return result; }
@Override public void visit(ElementTriplesBlock el) { iter = iter.andThen( WrappedIterator.create(el.getPattern().getList().iterator()) .mapWith( MAP )); }
private ExtendedIterator<Quad> getQuads(Collection<QuadHolder> holders) { ExtendedIterator<Quad> result = NiceIterator.emptyIterator(); for (QuadHolder holder : holders) { result = result.andThen(holder.setValues(values).getQuads()); } return result; }
@Override public void visit(ElementNamedGraph el) { final QuadIteratorBuilder bldr = new QuadIteratorBuilder( el.getGraphNameNode()); el.getElement().visit(bldr); iter = iter.andThen( bldr.iter ); }
@Override public void visit(ElementNamedGraph el) { final QuadIteratorBuilder bldr = new QuadIteratorBuilder( el.getGraphNameNode()); el.getElement().visit(bldr); iter = iter.andThen( bldr.iter ); }
/** To find in the union, find in the components, concatenate the results, and omit duplicates. That last is a performance penalty, but I see no way to remove it unless we know the graphs do not overlap. */ @Override protected ExtendedIterator<Triple> _graphBaseFind( final Triple t ) { Set<Triple> seen = CollectionFactory.createHashedSet(); return recording( L.find( t ), seen ).andThen( rejecting( R.find( t ), seen ) ); // return L.find( t ) .andThen( rejecting( R.find( t ), L ) ); } }
/** To find in the union, find in the components, concatenate the results, and omit duplicates. That last is a performance penalty, but I see no way to remove it unless we know the graphs do not overlap. */ @Override protected ExtendedIterator<Triple> _graphBaseFind( final Triple t ) { Set<Triple> seen = CollectionFactory.createHashedSet(); return recording( L.find( t ), seen ).andThen( rejecting( R.find( t ), seen ) ); // return L.find( t ) .andThen( rejecting( R.find( t ), L ) ); } }
/** * Find all the base triples matching tm, exclude the ones that are deleted, * add the ones that have been added. */ @Override protected ExtendedIterator<Triple> graphBaseFind(Triple t) { ExtendedIterator<Triple> iterator = base.find(t).filterDrop(ifIn(GraphUtil.findAll(deletions))).andThen(additions.find(t)) ; return SimpleEventManager.notifyingRemove( this, iterator ) ; }
public Iterator<Triple> execTriples() throws IOException { Model model = ModelFactory.createDefaultModel(); ExtendedIterator<Triple> result = new NullIterator<Triple>(); for (Query q: tq.getQueries()) { modifyQuery(q, table); QueryExecution ex = createQueryExecution(q, model); result = result.andThen(ex.execConstructTriples()); } return result; }
public void testAndThenExtension() { ExtendedIterator<String> L = iteratorOfStrings( "a b c" ); ExtendedIterator<String> R = iteratorOfStrings( "d e f" ); ExtendedIterator<String> X = iteratorOfStrings( "g h i" ); ExtendedIterator<String> LR = L.andThen( R ); ExtendedIterator<String> LRX = LR.andThen( X ); assertSame( LR, LRX ); List<String> aToI = listOfStrings( "a b c d e f g h i" ); assertEquals( aToI, iteratorToList( LRX ) ); }
public void testAndThenExtension() { ExtendedIterator<String> L = iteratorOfStrings( "a b c" ); ExtendedIterator<String> R = iteratorOfStrings( "d e f" ); ExtendedIterator<String> X = iteratorOfStrings( "g h i" ); ExtendedIterator<String> LR = L.andThen( R ); ExtendedIterator<String> LRX = LR.andThen( X ); assertSame( LR, LRX ); List<String> aToI = listOfStrings( "a b c d e f g h i" ); assertEquals( aToI, iteratorToList( LRX ) ); }
public void testAndThen() { ExtendedIterator<String> L = iteratorOfStrings( "a b c" ); ExtendedIterator<String> R = iteratorOfStrings( "d e f" ); assertInstanceOf( NiceIterator.class, L ); assertInstanceOf( NiceIterator.class, R ); assertEquals( listOfStrings( "a b c d e f" ), iteratorToList( L.andThen( R ) ) ); }
public void testAndThen() { ExtendedIterator<String> L = iteratorOfStrings( "a b c" ); ExtendedIterator<String> R = iteratorOfStrings( "d e f" ); assertInstanceOf( NiceIterator.class, L ); assertInstanceOf( NiceIterator.class, R ); assertEquals( listOfStrings( "a b c d e f" ), iteratorToList( L.andThen( R ) ) ); }
public void testClosingConcatenationClosesRemainingIterators() { LoggingClosableIterator<String> L = new LoggingClosableIterator<>( iteratorOfStrings( "only" ) ); LoggingClosableIterator<String> M = new LoggingClosableIterator<>( iteratorOfStrings( "single" ) ); LoggingClosableIterator<String> R = new LoggingClosableIterator<>( iteratorOfStrings( "it" ) ); ExtendedIterator<String> cat = L.andThen( M ).andThen( R ); cat.next(); cat.close(); assertTrue( "middle iterator should have been closed", M.isClosed() ); assertTrue( "final iterator should have been closed", R.isClosed() ); }