/** * {@inheritDoc} */ @Override public ResIterator listSubjects() { return super.object.listSubjects(); }
public ResIterator listSubjects() { return model.listSubjects(); }
protected ResIterator listSubjects(Model model) { return model.listSubjects(); }
private ResIterator modelListSubjects() { ResIterator resIt = model.listSubjects(); openResIterators.add(resIt); return resIt; }
private List<Resource> findRoots() { List<Resource> roots = new ArrayList<Resource>(); for (ResIterator i = model.listSubjects(); i.hasNext(); ) { Resource r = i.next(); if (r.isAnon() && model.contains(null, null, r)) continue; roots.add(r); } return roots; }
public void setContents(String contentsAsString) { if (contentsAsString.startsWith("<rdf:RDF")) { Model model = ModelFactory.createDefaultModel(); model.read(new StringReader(contentsAsString), null); Set<Resource> subjects = model.listSubjects().toSet(); Set<RDFNode> objects = model.listObjects().toSet(); subjects.removeAll(objects); node = subjects.iterator().next(); } else { node = RdfUtils.createTypedLiteral(contentsAsString); } }
public static RDFNode convert(InputStream stream) { Model model = ModelFactory.createDefaultModel().read(stream, null); Set<Resource> subjects = model.listSubjects().toSet(); Set<RDFNode> objects = model.listObjects().toSet(); subjects.removeAll(objects); return subjects.iterator().next(); }
protected void writeRDFStatements( Model model, PrintWriter writer ) { ResIterator rIter = model.listSubjects(); while (rIter.hasNext()) writeRDFStatements( model, rIter.nextResource(), writer ); }
private void importRdfModel(Results results, Model model, File baseDir, GraphPropertyWorkData data, VisibilityJson visibilityJson, Visibility visibility, User user, Authorizations authorizations) { ResIterator subjects = model.listSubjects(); while (subjects.hasNext()) { Resource subject = subjects.next(); importSubject(results, graph, subject, baseDir, data, visibilityJson, visibility, user, authorizations); } }
public Set<Resource> runLicenceQuery(String licenceQuery) { Source dataSource = spec.getAPISpec().getDataSource(); final Set<Resource> licences = new HashSet<Resource>(); if (licenceQuery != null) { Model cons = dataSource.executeConstruct(QueryFactory.create(licenceQuery)); licences.addAll(cons.listSubjects().toSet()); } return licences; }
/** Filter the model m according to the view-languages rules of the LDA spec. <p> If the list of viewing languages contains some values, then the only untyped literal values of a property P for some subject S that will kept are those with a language in the list or, if there are none, those with no language. </p> */ public static void filterByLanguages( Model m, String[] split) { Set<String> allowed = new HashSet<String>( Arrays.asList( split ) ); if (allowed.contains( "none" )) allowed.add( "" ); for (Resource sub: m.listSubjects().toList()) { for (Property prop: sub.listProperties().mapWith( Statement.Util.getPredicate ).toSet()) removeUnwantedPropertyValues( allowed, sub, prop ); } }
private List<EIInstance> create(final Model model) { if ( model == null ) { return Collections.emptyList(); } final List<EIInstance> instances = new ArrayList<EIInstance>(); final Set<Resource> subjects = model.listSubjects().toSet(); // create an EIInstance per subject for (final Resource r : subjects) { final Model subModel = model.query( new SimpleSelector( r, null, (RDFNode)null ) ); final EIInstance ei = jenaIntanceFactory.create( EIURI.create( r.getURI() ), subModel ); if ( ei != null && !EIInstance.NULL_INSTANCE.equals( ei ) ) { instances.add( ei ); } } return instances; }
ResIterator rIter = m.listSubjects(); while (rIter.hasNext()) { Resource subjectResource = rIter.next();
ResIterator rs = model.listSubjects(); try { while (rs.hasNext()) {
private List<Resource> getRoots(Model m) { List<Resource> l = new LinkedList<>(); // First try to find the root using the "http://www.apache.org/juneau/root" property. Property root = m.createProperty(getJuneauNs().getUri(), RDF_juneauNs_ROOT); for (ResIterator i = m.listResourcesWithProperty(root); i.hasNext();) l.add(i.next()); if (! l.isEmpty()) return l; // Otherwise, we need to find all resources that aren't objects. // We want to explicitly ignore statements where the subject // and object are the same node. Set<RDFNode> objects = new HashSet<>(); for (StmtIterator i = m.listStatements(); i.hasNext();) { Statement st = i.next(); RDFNode subject = st.getSubject(); RDFNode object = st.getObject(); if (object.isResource() && ! object.equals(subject)) objects.add(object); } for (ResIterator i = m.listSubjects(); i.hasNext();) { Resource r = i.next(); if (! objects.contains(r)) l.add(r); } return l; }
ResIterator resIterator = model.listSubjects(); Map<String, String> properties = new HashMap<String, String>(); Long subjectCounter = 0L;
ResIterator resIt = model.listSubjects();
ResIterator resIt = model.listSubjects();
ResIterator res = rdfModel.listSubjects(); while (res.hasNext()) { Resource node = res.nextResource();
Resource sNode = qpModel.listSubjects().next(); m.add(new StatementImpl(problemURI, QPRO.problematicThing, sNode)); m.add(qpModel);