Java ExtendedIterator.hasNext方法代码示例

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
public synchronized Set<PathMetadata> getGroupPaths(Node group, Graph graph) {
	if(groupPaths == null) {
		groupPaths = new HashMap<>();
		if(JenaNodeUtil.isInstanceOf(classNode, SH.Shape.asNode(), graph)) {
			addGroupProperties(classNode, graph, SH.parameter.asNode());
			addGroupProperties(classNode, graph, SH.property.asNode());
		}
		ExtendedIterator<Triple> it = graph.find(null, SH.targetClass.asNode(), classNode);
		while(it.hasNext()) {
			Node shape = it.next().getSubject();
			addGroupProperties(shape, graph, SH.parameter.asNode());
			addGroupProperties(shape, graph, SH.property.asNode());
		}
	}
	return groupPaths.get(group);
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
ClassPropertyMetadata(Node classNode, Node predicate, boolean inverse, Graph graph) {
	
	this.inverse = inverse;
	this.predicate = predicate;
	
	// Init from SHACL shapes
	if(SHACLUtil.exists(graph)) {
		if(JenaNodeUtil.isInstanceOf(classNode, SH.Shape.asNode(), graph)) {
			initFromShape(classNode, graph);
		}
		ExtendedIterator<Triple> it = graph.find(null, SH.targetClass.asNode(), classNode);
		while(it.hasNext()) {
			Node shape = it.next().getSubject();
			initFromShape(shape, graph);
		}
	}
	
	if(!inverse) {
		for(Plugin plugin : plugins) {
			plugin.init(this, classNode, graph);
		}
	}
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
@Override
   public final boolean hasSuperTemplate(Template superTemplate)
   {
if (superTemplate == null) throw new IllegalArgumentException("Template cannot be null");
       
       ExtendedIterator<OntClass> it = listSuperClasses(false);
       try
       {
           while (it.hasNext())
           {
               OntClass nextClass = it.next();
               if (nextClass.canAs(Template.class))
               {
                   Template nextTemplate = nextClass.as(Template.class);
                   if (nextTemplate.equals(superTemplate) || nextTemplate.hasSuperTemplate(superTemplate))
                       return true;
               }
           }
       }
       finally
       {
           it.close();
       }
       
       return false;
   }
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
private QueryIterator execAllNodes(Var subjVar, Node nodeLocalname,  Binding input, ExecutionContext execCxt)
{
    if ( ! nodeLocalname.isVariable() )
    {
        if ( ! nodeLocalname.isLiteral() )
            // Not a variable, not a literal=> can't match
            return QueryIterNullIterator.create(execCxt) ;
    
        if( ! NodeUtils.isSimpleString(nodeLocalname) )
            return QueryIterNullIterator.create(execCxt) ;
    }
    
    //Set bindings = new HashSet() ;    // Use a Set if you want unique results. 
    List<Binding> bindings = new ArrayList<Binding>() ;   // Use a list if you want counting results. 
    Graph graph = execCxt.getActiveGraph() ;
    
    ExtendedIterator<Triple>iter = graph.find(Node.ANY, Node.ANY, Node.ANY) ;
    for ( ; iter.hasNext() ; )
    {
        Triple t = iter.next() ;
        slot(bindings, input, t.getSubject(),   subjVar, nodeLocalname) ;
        slot(bindings, input, t.getPredicate(), subjVar, nodeLocalname) ;
        slot(bindings, input, t.getObject(),    subjVar, nodeLocalname) ;
    }
    return new QueryIterPlainWrapper(bindings.iterator(), execCxt) ;
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
@Override
public void enrich(StreamRDF stream, Node match) {
    if (match.isURI()) {
        Resource r = rdf.getResource( match.getURI() );
        if (enrichDescribe) {
            Model description = Closure.closure(r, false);
            ExtendedIterator<Triple> it = description.getGraph().find(null, null, null);
            while (it.hasNext()) {
                stream.triple(it.next());
            }
        } else {
            for (Property p : enrich) {
                for (StmtIterator si = r.listProperties(p); si.hasNext(); ) {
                    stream.triple( si.next().asTriple() ); 
                }
            }
        }
    } 
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
public Value fetch(String...strings) {
    ConverterProcess proc = ConverterProcess.get();
    String uri = asURI();
    Model model = proc.fetchModel(uri);
    if (model != null) {
        StreamRDF out = proc.getOutputStream();
        for (String puri : strings) {
            puri = proc.getDataContext().getPrefixes().expandPrefix(puri);
            Node p = NodeFactory.createURI(puri);
            Node s = NodeFactory.createURI(uri );
            ExtendedIterator<Triple> it = model.getGraph().find(s, p, null);
            while (it.hasNext()) {
                out.triple(it.next());
            }
        }
    }
    return this;
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
private void assertIdenticalGraphs(final Model orig, final Model roundtripped) {
    final Graph roundtrippedGraph = roundtripped.getGraph();
    final ExtendedIterator<Triple> originalTripleIt = orig.getGraph().find(Node.ANY, Node.ANY, Node.ANY);
    while (originalTripleIt.hasNext()) {
        final Triple t = originalTripleIt.next();
        assertTrue("Roundtripped resource should contain triple " + t + "!", roundtrippedGraph.contains(t));
        roundtrippedGraph.delete(t);
    }
    assertTrue("Triples round in roundtripped resource that weren't in original!\n" + roundtrippedGraph,
            roundtrippedGraph.isEmpty());
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
public static Node getObject(Node subject, Node predicate, Graph graph) {
    ExtendedIterator<Triple> it = graph.find(subject, predicate, Node.ANY);
    try { 
           return it.hasNext() 
               ? it.next().getObject() 
               : null;
    } finally { 
        it.close();
    }
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
public static List<Node> getObjects(Node subject, Node predicate, Graph graph) {
	List<Node> results = new LinkedList<>();
	ExtendedIterator<Triple> it = graph.find(subject, predicate, Node.ANY);
	while(it.hasNext()) {
		results.add(it.next().getObject());
	}
	return results;
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
public static List<Node> getSubjects(Node predicate, Node object, Graph graph) {
	List<Node> results = new LinkedList<>();
	ExtendedIterator<Triple> it = graph.find(Node.ANY, predicate, object);
	while(it.hasNext()) {
		results.add(it.next().getSubject());
	}
	return results;
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
private void addGroupProperties(Node nodeShape, Graph graph, Node systemPredicate) {
	ExtendedIterator<Triple> it = graph.find(nodeShape, systemPredicate, Node.ANY);
	while(it.hasNext()) {
		Node propertyShape = it.next().getObject();
		if(!graph.contains(propertyShape, SH.deactivated.asNode(), JenaDatatypes.TRUE.asNode())) {
			Node group = JenaNodeUtil.getObject(propertyShape, SH.group.asNode(), graph);
			if(group != null) {
				Node path = JenaNodeUtil.getObject(propertyShape, SH.path.asNode(), graph);
				if(path != null) {
					Set<PathMetadata> paths = groupPaths.get(group);
					if(paths == null) {
						paths = new HashSet<>();
						groupPaths.put(group, paths);
					}
					if(path.isURI()) {
						paths.add(new PathMetadata(path, false));
					}
					else {
						Node inverse = JenaNodeUtil.getObject(path, SH.inversePath.asNode(), graph);
						if(inverse != null && inverse.isURI()) {
							paths.add(new PathMetadata(inverse, true));
						}
					}
				}
			}
		}
	}
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
public synchronized Iterable<ClassMetadata> getSuperClasses(Graph graph) {
	if(superClasses == null) {
		superClasses = new LinkedList<>();
		ExtendedIterator<Triple> it = graph.find(classNode, RDFS.subClassOf.asNode(), Node.ANY);
		while(it.hasNext()) {
			Node superClass = it.next().getObject();
			superClasses.add(OntologyOptimizations.get().getClassMetadata(superClass, graph, graphKey));
		}
	}
	return superClasses;
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
@Override
public void init(ClassPropertyMetadata cpm, Node classNode, Graph graph) {
	ExtendedIterator<Triple> it = graph.find(classNode, RDFS.subClassOf.asNode(), Node.ANY);
	while(it.hasNext()) {
		Node superClass = it.next().getObject();
		if(superClass.isBlank() && graph.contains(superClass, OWL.onProperty.asNode(), cpm.getPredicate())) {
			if(cpm.getLocalRange() == null) {
				Node localRange = JenaNodeUtil.getObject(superClass, OWL.allValuesFrom.asNode(), graph);
				if(localRange != null) {
					cpm.setLocalRange(localRange);
					it.close();
					break;
				}
			}
			if(cpm.getMaxCount() == null) {
				Node maxCountNode = JenaNodeUtil.getObject(superClass, OWL.maxCardinality.asNode(), graph);
				if(maxCountNode == null) {
					maxCountNode = JenaNodeUtil.getObject(superClass, OWL.cardinality.asNode(), graph);
				}
				if(maxCountNode != null && maxCountNode.isLiteral()) {
					Object value = maxCountNode.getLiteralValue();
					if(value instanceof Number) {
						cpm.setMaxCount(((Number) value).intValue());
					}
				}
			}
		}
	}
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
protected Map<Property, Parameter> addSuperParameters(Template template, Map<Property, Parameter> args)
{
    if (template == null) throw new IllegalArgumentException("Template Set cannot be null");        
    if (args == null) throw new IllegalArgumentException("Parameter Map cannot be null");        
    
    ExtendedIterator<OntClass> superIt = template.listSuperClasses();
    try
    {
        while (superIt.hasNext())
        {
            OntClass superClass = superIt.next();
            if (superClass.canAs(Template.class))
            {
                Template superTemplate = superClass.as(Template.class);
                Map<Property, Parameter> superArgs = superTemplate.getLocalParameters();
                Iterator<Entry<Property, Parameter>> entryIt = superArgs.entrySet().iterator();
                while (entryIt.hasNext())
                {
                    Entry<Property, Parameter> entry = entryIt.next();
                    args.putIfAbsent(entry.getKey(), entry.getValue()); // reject Parameters for existing predicates
                }
                
                addSuperParameters(superTemplate, args);  // recursion to super class
            }
        }
    }
    finally
    {
        superIt.close();
    }

    return args;
}
 

import org.apache.jena.util.iterator.ExtendedIterator; //导入方法依赖的package包/类
protected List<Locale> getLanguages(Property property)
{
    if (property == null) throw new IllegalArgumentException("Property cannot be null");
    
    List<Locale> languages = new ArrayList<>();
    Resource langs = getPropertyResourceValue(property);
    if (langs != null)
    {
        if (!langs.canAs(RDFList.class))
        {
            if (log.isErrorEnabled()) log.error("ldt:lang value is not an rdf:List on template '{}'", getURI());
            throw new OntologyException("ldt:lang value is not an rdf:List on template  '" + getURI() +"'");
        }

        // could use list order as priority (quality value q=)
        RDFList list = langs.as(RDFList.class);
        ExtendedIterator<RDFNode> it = list.iterator();
        try
        {
            while (it.hasNext())
            {
                RDFNode langTag = it.next();
                if (!langTag.isLiteral())
                {
                    if (log.isErrorEnabled()) log.error("Non-literal language tag (ldt:lang member) on template '{}'", getURI());
                    throw new OntologyException("Non-literal language tag (ldt:lang member) on template '" + getURI() +"'");
                }

                languages.add(Locale.forLanguageTag(langTag.asLiteral().getString()));
            }
        }
        finally
        {
            it.close();
        }
    }
    
    return languages;
}