private ExtendedIterator<Node> expectOnlyNodes( Iterator<Object> elements ) { return WrappedIterator.<Object>createNoRemove( elements ).mapWith( expectNode ); }
/** 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()) ; }
/** 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()) ; }
/** 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()) ; }
@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() ) ); }
@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 protected ExtendedIterator<Triple> graphBaseFind(Node s, Node p, Node o) { Node g = graphNode(gn) ; Iterator<Triple> iter = GLib.quads2triples(dsg.find(g, s, p, o)) ; if ( Quad.isUnionGraph(gn) ) return graphUnionFind(s, p, o) ; return WrappedIterator.createNoRemove(iter) ; }
protected ExtendedIterator<Triple> graphUnionFind(Node s, Node p, Node o) { Node g = graphNode(gn) ; // Implementations may wish to do better so this is separated out. // For example, Iter.distinctAdjacent is a lot cheaper than Iter.distinct // but assumes thing come back in a particular order Iterator<Quad> iterQuads = getDataset().find(g, s, p, o) ; Iterator<Triple> iter = GLib.quads2triples(iterQuads) ; // Suppress duplicates after projecting to triples. iter = Iter.distinct(iter) ; return WrappedIterator.createNoRemove(iter) ; }
private static ExtendedIterator<Node> findNodesForTriple(Graph graph, Triple t, boolean oneWillDo) { ExtendedIterator<Triple> iter = graph.find(Node.ANY, rdfType, statement) ; List<Node> nodes = new ArrayList<Node>() ; try { while (iter.hasNext()) { Triple typeTriple = iter.next() ; Node n = typeTriple.getSubject() ; // Check. if ( t != null ) { if ( ! exactlyOne(graph, n, subject, t.getSubject()) ) continue ; if ( ! exactlyOne(graph, n, predicate, t.getPredicate()) ) continue ; if ( ! exactlyOne(graph, n, object, t.getObject()) ) continue ; } nodes.add(n) ; if ( oneWillDo ) break ; } } finally { iter.close() ; } return WrappedIterator.createNoRemove(nodes.iterator()) ; } // ----
return WrappedIterator.createNoRemove(triples.iterator()) ;
return WrappedIterator.createNoRemove(triples.iterator()) ;