Merge branch 'rdfox-converter' into master

1 files changed, 63 insertions, 43 deletions

diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
index 4dd554a..a965ef9 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
@@ -7,13 +7,15 @@ import java.util.stream.{Collectors, Stream}
 import java.io.File
 import org.semanticweb.owlapi.apibinding.OWLManager
 import org.semanticweb.owlapi.util.OWLOntologyMerger
-import org.semanticweb.owlapi.model.{OWLOntology, OWLAxiom}
+import org.semanticweb.owlapi.model.{OWLOntology, OWLAxiom, OWLLogicalAxiom}
 import org.semanticweb.owlapi.model.{
   OWLClass,
+  OWLClassExpression,
   OWLObjectProperty,
   OWLSubObjectPropertyOfAxiom,
   OWLObjectPropertyExpression,
   OWLObjectSomeValuesFrom,
+  OWLDataSomeValuesFrom,
   OWLSubClassOfAxiom
 }
 import org.semanticweb.owlapi.model.parameters.Imports
@@ -48,7 +50,7 @@ import org.semanticweb.owlapi.dlsyntax.renderer.DLSyntaxObjectRenderer
 import tech.oxfordsemantic.jrdfox.logic._
 import org.semanticweb.owlapi.model.OWLObjectInverseOf
 
-import uk.ac.ox.cs.rsacomb.converter.{RDFoxAxiomConverter, SkolemStrategy}
+import uk.ac.ox.cs.rsacomb.converter.{RDFoxConverter, SkolemStrategy}
 import uk.ac.ox.cs.rsacomb.suffix._
 import uk.ac.ox.cs.rsacomb.sparql._
 import uk.ac.ox.cs.rsacomb.util.{RDFoxUtil, RSA}
@@ -82,30 +84,28 @@ object RSAOntology {
 class RSAOntology(val ontology: OWLOntology) {
 
   import uk.ac.ox.cs.rsacomb.implicits.RSAAxiom._
+  import uk.ac.ox.cs.rsacomb.implicits.JavaCollections._
 
   // Gather TBox/RBox/ABox from original ontology
-  val tbox: List[OWLAxiom] =
+  val tbox: List[OWLLogicalAxiom] =
     ontology
       .tboxAxioms(Imports.INCLUDED)
       .collect(Collectors.toList())
-      .asScala
-      .toList
+      .collect { case a: OWLLogicalAxiom => a }
 
-  val rbox: List[OWLAxiom] =
+  val rbox: List[OWLLogicalAxiom] =
     ontology
       .rboxAxioms(Imports.INCLUDED)
       .collect(Collectors.toList())
-      .asScala
-      .toList
+      .collect { case a: OWLLogicalAxiom => a }
 
-  val abox: List[OWLAxiom] =
+  val abox: List[OWLLogicalAxiom] =
     ontology
       .aboxAxioms(Imports.INCLUDED)
       .collect(Collectors.toList())
-      .asScala
-      .toList
+      .collect { case a: OWLLogicalAxiom => a }
 
-  val axioms: List[OWLAxiom] = abox ::: tbox ::: rbox
+  val axioms: List[OWLLogicalAxiom] = abox ::: tbox ::: rbox
 
   /* Retrieve individuals in the original ontology
    */
@@ -152,28 +152,54 @@ class RSAOntology(val ontology: OWLOntology) {
     //println("\nUnsafe roles:")
     //println(unsafe)
 
+    object RSAConverter extends RDFoxConverter {
+
+      override def convert(
+          expr: OWLClassExpression,
+          term: Term,
+          unsafe: List[OWLObjectPropertyExpression],
+          skolem: SkolemStrategy,
+          suffix: RSASuffix
+      ): Shards =
+        (expr, skolem) match {
+
+          case (e: OWLObjectSomeValuesFrom, SkolemStrategy.Constant(c))
+              if unsafe contains e.getProperty => {
+            val (res, ext) = super.convert(e, term, unsafe, skolem, suffix)
+            (RSA.PE(term, c) :: RSA.U(c) :: res, ext)
+          }
+
+          case (e: OWLDataSomeValuesFrom, SkolemStrategy.Constant(c))
+              if unsafe contains e.getProperty => {
+            val (res, ext) = super.convert(e, term, unsafe, skolem, suffix)
+            (RSA.PE(term, c) :: RSA.U(c) :: res, ext)
+          }
+
+          case _ => super.convert(expr, term, unsafe, skolem, suffix)
+        }
+
+    }
+
     /* Ontology convertion into LP rules */
-    val datalog = for {
-      axiom <- axioms
-      visitor = new RDFoxAxiomConverter(
-        RSAOntology.genFreshVariable(),
-        unsafe,
-        SkolemStrategy.ConstantRSA(axiom.toString),
-        Empty
-      )
-      rule <- axiom.accept(visitor)
-    } yield rule
+    val term = RSAOntology.genFreshVariable()
+    val datalog = axioms
+      .map(a => {
+        val skolem = SkolemStrategy.Constant(a.toString)
+        RSAConverter.convert(a, term, unsafe, skolem, Empty)
+      })
+      .unzip
+    val facts = datalog._1.flatten
+    val rules = datalog._2.flatten
 
     /* DEBUG: print datalog rules */
-    println("\nDatalog roles:")
-    datalog.foreach(println)
+    //println("\nDatalog rules:")
+    //rules.foreach(println)
 
     // Open connection with RDFox
     val (server, data) = RDFoxUtil.openConnection("RSACheck")
-    // Add Data (hardcoded for now)
-    //data.importData(UpdateType.ADDITION, RSA.Prefixes, ":a a :A .")
 
     /* Add built-in rules
+     * TODO: substitute with RDFoxUtil.addRules
      */
     data.importData(
       UpdateType.ADDITION,
@@ -181,20 +207,11 @@ class RSAOntology(val ontology: OWLOntology) {
       "rsa:E[?X,?Y] :- rsa:PE[?X,?Y], rsa:U[?X], rsa:U[?Y] ."
     )
 
-    /* Add built-in rules
-     */
-    // data.importData(
-    //   UpdateType.ADDITION,
-    //   RSA.Prefixes,
-    //   "[?entity, a, ?superClass] :- [?entity, a, ?class], [?class, rdfs:subClassOf, ?superClass] ."
-    // )
-
-    /* Add ontology rules
-     */
-    data.addRules(datalog.asJava)
+    /* Add ontology facts and rules */
+    RDFoxUtil.addFacts(data, facts)
+    RDFoxUtil.addRules(data, rules)
 
-    /* Build graph
-     */
+    /* Build graph */
     val graph = this.rsaGraph(data);
     //println(graph)
 
@@ -267,8 +284,8 @@ class RSAOntology(val ontology: OWLOntology) {
   ): Graph[Resource, UnDiEdge] = {
     val query = "SELECT ?X ?Y WHERE { ?X rsa:E ?Y }"
     val answers = RDFoxUtil.submitQuery(data, query, RSA.Prefixes).get
-    var edges: Seq[UnDiEdge[Resource]] = answers.map {
-      case Seq(n1, n2) => UnDiEdge(n1, n2)
+    var edges: Seq[UnDiEdge[Resource]] = answers.map { case Seq(n1, n2) =>
+      UnDiEdge(n1, n2)
     }
     Graph(edges: _*)
   }
@@ -310,8 +327,11 @@ class RSAOntology(val ontology: OWLOntology) {
   def ask(query: ConjunctiveQuery): ConjunctiveQueryAnswers = {
     import implicits.JavaCollections._
     val (server, data) = RDFoxUtil.openConnection(RSAOntology.DataStore)
-    data.addRules(this.canonicalModel.rules)
-    data.addRules(this.filteringProgram(query).rules)
+    val filter = this.filteringProgram(query)
+    RDFoxUtil.addRules(data, this.canonicalModel.rules)
+    RDFoxUtil.addFacts(data, this.canonicalModel.facts)
+    RDFoxUtil.addRules(data, filter.rules)
+    RDFoxUtil.addFacts(data, filter.facts)
     val answers = RDFoxUtil
       .submitQuery(
         data,