@Override public ExtendedIterator<T> filterKeep( Iterator<T> it ) { return WrappedIterator.create( it ); } };
private ExtendedIterator<Node> expectOnlyNodes( Iterator<Object> elements ) { return WrappedIterator.<Object>createNoRemove( elements ).mapWith( expectNode ); }
/** Answer an ExtendedIterator wrapped round <code>it</code> which does not permit <code>.remove()</code> even if <code>it</code> does. */ public static <T> WrappedIterator<T> createNoRemove( Iterator<T> it ) { return new WrappedIterator<T>( it, true ); }
/** Return an iterator over the unique predicate between s and o. * s and o can be wildcards (Node.ANY) * @param g Graph * @param s Subject - may be Node.ANY * @param o Object - may be Node.ANY * @return ExtendedIterator */ public static ExtendedIterator<Node> listPredicates(Graph g, Node s, Node o) { ExtendedIterator<Triple> iter = g.find(s,Node.ANY, o) ; Set<Node> nodes = iter.mapWith(mapPredicate).toSet() ; return WrappedIterator.createNoRemove(nodes.iterator()) ; }
/** * An Iterator over the pairs of the Relation. * Each pair is returned as a java.util.Map.Entry. * The first element is accessed through <code>getKey()</code>, * the second through <code>getValue()</code>. *@see java.util.Map.Entry */ public Iterator<PairEntry<T, T>> iterator() { Map1<Map.Entry<T, Set<T>>, Iterator<PairEntry<T, T>>> m1 = new Map1<Map.Entry<T, Set<T>>, Iterator<PairEntry<T, T>>>(){ @Override public Iterator<PairEntry<T, T>> map1(Entry<T, Set<T>> entry) { return pairEntry(entry) ; }} ; Map1Iterator<Map.Entry<T, Set<T>>,Iterator<PairEntry<T, T>>> iter1 = new Map1Iterator<Map.Entry<T, Set<T>>,Iterator<PairEntry<T, T>>>(m1 , rows.entrySet().iterator()) ; // And now flatten it. Iterator<PairEntry<T, T>> iter2 = WrappedIterator.createIteratorIterator(iter1) ; return iter2 ; } }
/** close: defer to the base, iff it is closable */ @Override public void close() { close( base ); }
/** * @see Iterator#hasNext() */ @Override public boolean hasNext() { while (next == null && super.hasNext()) next = nextIfNew(); return next != null; }
/** Return an iterator over the unique objects with a given subject and object. * s and p can be wildcards (Node.ANY) * @param g Graph * @param s Subject - may be Node.ANY * @param p Predicate - may be Node.ANY * @return ExtendedIterator */ public static ExtendedIterator<Node> listObjects(Graph g, Node s, Node p) { ExtendedIterator<Triple> iter = g.find(s, p, Node.ANY) ; Set<Node> nodes = iter.mapWith(mapObject).toSet() ; return WrappedIterator.createNoRemove(nodes.iterator()) ; }
/** 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; }
}} ; return WrappedIterator.createIteratorIterator( new Map1Iterator<Set<Resource>, Iterator<Resource>>(mapper, Arrays.asList(bucketArray).iterator()));
@Override public ExtendedIterator filterKeep( Iterator it ) { return WrappedIterator.create( it ); } };
/** Return an iterator over the unique subjects with predciate p and object o. * p and o can be wildcards (Node.ANY) * @param g Graph * @param p Predicate - may be Node.ANY * @param o Object - may be Node.ANY * @return ExtendedIterator */ public static ExtendedIterator<Node> listSubjects(Graph g, Node p, Node o) { // Restore a minimal QueryHandler? ExtendedIterator<Triple> iter = g.find(Node.ANY, p, o) ; Set<Node> nodes = iter.mapWith(mapSubject).toSet() ; return WrappedIterator.createNoRemove(nodes.iterator()) ; }
Iterator<Resource> allAsOne = WrappedIterator.createIteratorIterator( Arrays.asList(all).iterator() );
/** Answer an ExtendedIterator returning the elements of <code>it</code>. If <code>it</code> is itself an ExtendedIterator, return that; otherwise wrap <code>it</code>. */ public static <T> ExtendedIterator<T> create( Iterator<T> it ) { return it instanceof ExtendedIterator<?> ? (ExtendedIterator<T>) it : new WrappedIterator<T>( it, false ); }
@Override public ExtendedIterator<Triple> iterator() { return WrappedIterator.create( elements.iterator() ); }
@Override protected ExtendedIterator<Triple> graphBaseFind( final TripleMatch m ) { ExtendedIterator<Triple> iter =null; if (iteratorDeleteAllowed) { iter = SimpleEventManager.notifyingRemove( this, triples.iterator() ); } else { iter = WrappedIterator.createNoRemove( triples.iterator() ); } return iter .filterKeep ( new TripleMatchFilterEquality( m.asTriple() ) ); }
/** * Return an iterator over all registered subject nodes */ public ExtendedIterator<Node> listAllSubjects() { return WrappedIterator.create(nodeMap.keySet().iterator()); }
@Override public ExtendedIterator<Triple> graphBaseFind(final Triple pattern) { try { return WrappedIterator.createNoRemove(query(pattern)); } catch (final SyntaxError exception) { logger().error(MessageCatalog._00113_NWS_FAILURE, exception); return new NullIterator<Triple>(); } }
@Override public ExtendedIterator<String> listGraphs() { return WrappedIterator.create( graphs.keySet().iterator() ); } }