/**
* 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());
}
}
protected static void addDomainTypes(Model result, Model schema) {
for (StmtIterator it = schema.listStatements(ANY, RDFS.domain, ANY); it.hasNext(); ) {
Statement s = it.nextStatement();
Property property = s.getSubject().as(Property.class);
RDFNode type = s.getObject();
for (StmtIterator x = result.listStatements(ANY, property, ANY); x.hasNext(); ) {
Statement t = x.nextStatement();
result.add(t.getSubject(), RDF.type, type);
}
}
}
protected static void addRangeTypes(Model result, Model schema) {
Model toAdd = ModelFactory.createDefaultModel();
for (StmtIterator it = schema.listStatements(ANY, RDFS.range, ANY); it.hasNext(); ) {
Statement s = it.nextStatement();
RDFNode type = s.getObject();
Property property = s.getSubject().as(Property.class);
for (StmtIterator x = result.listStatements(ANY, property, ANY); x.hasNext(); ) {
RDFNode ob = x.nextStatement().getObject();
if (ob.isResource()) toAdd.add((Resource) ob, RDF.type, type);
}
}
result.add(toAdd);
}
public void testQuintetOfQuadlets() {
Resource rs = model.createResource();
rs.addProperty(RDF.type, RDF.Statement);
model.createResource().addProperty(RDF.value, rs);
rs.addProperty(RDF.subject, model.createResource());
rs.addProperty(RDF.predicate, model.createProperty("http://example.org/foo"));
rs.addProperty(RDF.object, model.createResource());
rs.addProperty(RDF.object, model.createResource());
StmtIterator it = model.listStatements();
while (it.hasNext()) {
Statement s = it.nextStatement();
assertFalse(s.getObject().equals(s.getSubject()));
}
}
/**
* Answer the shortest path from the <code>start</code> resource to the <code>end</code> RDF node,
* such that every step on the path is accepted by the given filter. A path is a {@link List} of
* RDF {@link Statement}s. The subject of the first statement in the list is <code>start</code>,
* and the object of the last statement in the list is <code>end</code>.
*
* <p>The <code>onPath</code> argument is a {@link Filter}, which accepts a statement and returns
* true if the statement should be considered to be on the path. To search for an unconstrained
* path, pass {@link Filter#any} as an argument. To search for a path whose predicates match a
* fixed restricted set of property names, pass an instance of {@link PredicatesFilter}.
*
* <p>If there is more than one path of minimal length from <code>start</code> to <code>end</code>
* , this method returns an arbitrary one. The algorithm is blind breadth-first search, with loop
* detection.
*
* @param m The model in which we are seeking a path
* @param start The starting resource
* @param end The end, or goal, node
* @param onPath A filter which determines whether a given statement can be considered part of the
* path
* @return A path, consisting of a list of statements whose first subject is <code>start</code>,
* and whose last object is <code>end</code>, or null if no such path exists.
*/
public static Path findShortestPath(
Model m, Resource start, RDFNode end, Filter<Statement> onPath) {
List<Path> bfs = new LinkedList<Path>();
Set<Resource> seen = new HashSet<Resource>();
// initialise the paths
for (Iterator<Statement> i = m.listStatements(start, null, (RDFNode) null).filterKeep(onPath);
i.hasNext(); ) {
bfs.add(new Path().append(i.next()));
}
// search
Path solution = null;
while (solution == null && !bfs.isEmpty()) {
Path candidate = bfs.remove(0);
if (candidate.hasTerminus(end)) {
solution = candidate;
} else {
Resource terminus = candidate.getTerminalResource();
if (terminus != null) {
seen.add(terminus);
// breadth-first expansion
for (Iterator<Statement> i = terminus.listProperties().filterKeep(onPath);
i.hasNext(); ) {
Statement link = i.next();
// no looping allowed, so we skip this link if it takes us to a node we've seen
if (!seen.contains(link.getObject())) {
bfs.add(candidate.append(link));
}
}
}
}
}
return solution;
}
public static void main(String[] args) {
List<String> obj = new ArrayList<String>();
Scanner input = new Scanner(System.in);
System.out.print("Enter URI: ");
String userIn = input.nextLine();
// create an empty Model
Model model = ModelFactory.createDefaultModel();
// read the RDF/XML file
model.read(userIn);
// write it to standard out
// model.write(System.out);
// list the statements in the Model
StmtIterator iter = model.listStatements();
System.out.println();
// print out the predicate, subject and object of each statement
while (iter.hasNext()) {
Statement stmt = iter.nextStatement(); // get next statement
Resource subject = stmt.getSubject(); // get the subject
Property predicate = stmt.getPredicate(); // get the predicate
RDFNode object = stmt.getObject(); // get the object
System.out.print(subject.toString());
System.out.print(" -> " + predicate.toString() + " -> ");
if (object instanceof Resource) {
System.out.print(object.toString() + "\n");
} else {
// object is a literal
System.out.print(" \"" + object.toString() + "\"\n");
}
}
/* for(int i = 0; i < (obj.size()); i++){
String sparqlQueryString1=
"SELECT ?s ?o "+
"WHERE {"+
"?s ?p ?o ."+
"?o <bif:contains> \""+obj.get(i)+"\" ."+
"}"+
"limit 10";
Query query = QueryFactory.create(sparqlQueryString1);
QueryExecution qexec = QueryExecutionFactory.sparqlService("http://pubmed.bio2rdf.org/sparql", query);
ResultSet results = qexec.execSelect();
System.out.println("Query: "+obj.get(i));
ResultSetFormatter.out(System.out, results, query);
qexec.close() ;
} */
}
protected static void addSubclassesFrom(Model result, Model schema) {
for (StmtIterator it = schema.listStatements(ANY, RDFS.subClassOf, ANY); it.hasNext(); ) {
Statement s = it.nextStatement();
if (s.getSubject().isURIResource() && s.getObject().isURIResource()) result.add(s);
}
}
/**
* Add to <code>classes</code> the subject and object of the statement <code>xSubClassOfY</code>.
*/
private static void addClasses(Set<RDFNode> classes, Statement xSubClassOfY) {
classes.add(xSubClassOfY.getSubject());
classes.add(xSubClassOfY.getObject());
}