/** 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));
}