/** Fills <tt>m</tt> with statements from <tt>s</tt> and returns it. */ public static Model toModel(Set s, Model m) throws ModelException { Iterator it = s.iterator(); while (it.hasNext()) { Object o = it.next(); if (o instanceof Statement) m.add((Statement) o); } return m; }
/** * Example the conclusions graph for introduction of restrictions which require a comprehension * rewrite and declare new (anon) classes for those restrictions. */ public void comprehensionAxioms(Model premises, Model conclusions) { // Comprehend all restriction declarations and note them in a map Map<Resource, Resource> comprehension = new HashMap<>(); StmtIterator ri = conclusions.listStatements(null, RDF.type, OWL.Restriction); while (ri.hasNext()) { Resource restriction = ri.nextStatement().getSubject(); StmtIterator pi = restriction.listProperties(OWL.onProperty); while (pi.hasNext()) { Resource prop = (Resource) pi.nextStatement().getObject(); StmtIterator vi = restriction.listProperties(); while (vi.hasNext()) { Statement rs = vi.nextStatement(); if (!rs.getPredicate().equals(OWL.onProperty)) { // Have a restriction on(prop) of type rs in the conclusions // So assert a premise that such a restriction could exisit Resource comp = premises .createResource() .addProperty(RDF.type, OWL.Restriction) .addProperty(OWL.onProperty, prop) .addProperty(rs.getPredicate(), rs.getObject()); comprehension.put(restriction, comp); } } } } // Comprehend any intersectionOf lists. Introduce anon class which has the form // of the intersection expression. // Rewrite queries of the form (X intersectionOf Y) to the form // (X equivalentClass ?CC) (?CC intersectionOf Y) StmtIterator ii = conclusions.listStatements(null, OWL.intersectionOf, (RDFNode) null); List<Statement> intersections = new ArrayList<>(); while (ii.hasNext()) { intersections.add(ii.nextStatement()); } for (Statement is : intersections) { // Declare in the premises that such an intersection exists Resource comp = premises .createResource() .addProperty(RDF.type, OWL.Class) .addProperty( OWL.intersectionOf, mapList(premises, (Resource) is.getObject(), comprehension)); // Rewrite the conclusions to be a test for equivalence between the class being // queried and the comprehended interesection conclusions.remove(is); conclusions.add(is.getSubject(), OWL.equivalentClass, comp); } // Comprehend any oneOf lists StmtIterator io = conclusions.listStatements(null, OWL.oneOf, (RDFNode) null); while (io.hasNext()) { Statement s = io.nextStatement(); Resource comp = premises.createResource().addProperty(OWL.oneOf, s.getObject()); } }
/** * @return a new model in which all occurrences of the old namespace are replaced by the new one. * All replaced resources are summarized in the map if not null. If resourcesToIgnore != null, * ignore resources listed there. */ public static Model replaceNamespace(Model m, String o, String n, Map o2n, Set resourcesToIgnore) throws ModelException { Model res = m.create(); NodeFactory f = m.getNodeFactory(); Enumeration en = m.elements(); while (en.hasMoreElements()) { Statement st = (Statement) en.nextElement(); res.add(replaceNamespace(st, o, n, f, o2n, resourcesToIgnore)); } return res; }
/** returns true if old triples from r were removed */ public static boolean setUniqueObject( Model r, Resource subject, Resource predicate, RDFNode object) throws ModelException { Model old = r.find(subject, predicate, null); SetOperations.subtract(r, old); Statement stmt = get1(old); if (subject == null && stmt != null) subject = stmt.subject(); if (predicate == null && stmt != null) predicate = stmt.predicate(); r.add(r.getNodeFactory().createStatement(subject, predicate, object)); return !old.isEmpty(); }
/** * @return a new model in which all occurrences of the old resources are replaced by the new ones. * Returns number replacements done. */ public static int replaceResources(Model m, Map o2n) throws ModelException { NodeFactory f = m.getNodeFactory(); Enumeration en = m.elements(); Model toRemove = m.create(); Model toAdd = m.create(); while (en.hasMoreElements()) { Statement st = (Statement) en.nextElement(); Statement st_n = replaceResources(st, f, o2n); if (st_n != st) { // yes, pointer comparison toAdd.add(st_n); toRemove.add(st); } } SetOperations.subtract(m, toRemove); SetOperations.unite(m, toAdd); return toAdd.size(); }
/** * @return a new model in which all occurrences of the old resources are replaced by the new ones. * Returns number replacements done. */ public static int replaceResources(Model src, Model dest, Map o2n) throws ModelException { NodeFactory f = src.getNodeFactory(); Enumeration en = src.elements(); int replaced = 0; while (en.hasMoreElements()) { Statement st = (Statement) en.nextElement(); Statement st_n = replaceResources(st, f, o2n); dest.add(st_n); if (st_n != st) // yes, pointer comparison replaced++; } return replaced; }
public static void add(Model m, Resource subject, Resource predicate, RDFNode object) throws ModelException { m.add(m.getNodeFactory().createStatement(subject, predicate, object)); }