/**
* 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());
}
}
/**
* Index all the resources in a Jena Model to ES
*
* @param model the model to index
* @param bulkRequest a BulkRequestBuilder
* @param getPropLabel if set to true all URI property values will be indexed as their label. The
* label is taken as the value of one of the properties set in {@link #uriDescriptionList}.
*/
private void addModelToES(Model model, BulkRequestBuilder bulkRequest, boolean getPropLabel) {
long startTime = System.currentTimeMillis();
long bulkLength = 0;
HashSet<Property> properties = new HashSet<Property>();
StmtIterator it = model.listStatements();
while (it.hasNext()) {
Statement st = it.nextStatement();
Property prop = st.getPredicate();
String property = prop.toString();
if (rdfPropList.isEmpty()
|| (isWhitePropList && rdfPropList.contains(property))
|| (!isWhitePropList && !rdfPropList.contains(property))
|| (normalizeProp.containsKey(property))) {
properties.add(prop);
}
}
ResIterator resIt = model.listSubjects();
while (resIt.hasNext()) {
Resource rs = resIt.nextResource();
Map<String, ArrayList<String>> jsonMap = getJsonMap(rs, properties, model, getPropLabel);
bulkRequest.add(
client.prepareIndex(indexName, typeName, rs.toString()).setSource(mapToString(jsonMap)));
bulkLength++;
// We want to execute the bulk for every DEFAULT_BULK_SIZE requests
if (bulkLength % EEASettings.DEFAULT_BULK_SIZE == 0) {
BulkResponse bulkResponse = bulkRequest.execute().actionGet();
// After executing, flush the BulkRequestBuilder.
bulkRequest = client.prepareBulk();
if (bulkResponse.hasFailures()) {
processBulkResponseFailure(bulkResponse);
}
}
}
// Execute remaining requests
if (bulkRequest.numberOfActions() > 0) {
BulkResponse response = bulkRequest.execute().actionGet();
// Handle failure by iterating through each bulk response item
if (response.hasFailures()) {
processBulkResponseFailure(response);
}
}
// Show time taken to index the documents
logger.info(
"Indexed {} documents on {}/{} in {} seconds",
bulkLength,
indexName,
typeName,
(System.currentTimeMillis() - startTime) / 1000.0);
}
@Override
public boolean accept(Statement s) {
return m_preds.contains(s.getPredicate());
}
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() ;
} */
}