1 files changed, 31 insertions, 15 deletions

diff --git a/src/main/scala/rsacomb/RDFoxAxiomConverter.scala b/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
index 675ca7d..0a79823 100644
--- a/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
+++ b/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
@@ -1,35 +1,39 @@
 package rsacomb
 
-import org.semanticweb.owlapi.model.{OWLAxiom, OWLSubClassOfAxiom, OWLEquivalentClassesAxiom}
+import org.semanticweb.owlapi.model.{OWLAxiom, OWLSubClassOfAxiom, OWLEquivalentClassesAxiom, OWLObjectPropertyExpression}
 import org.semanticweb.owlapi.model.OWLAxiomVisitorEx
 
 import tech.oxfordsemantic.jrdfox.logic.{Rule, BodyFormula}
-import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Literal}
+import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Variable, Literal}
+import tech.oxfordsemantic.jrdfox.logic.{TupleTableName}
 
 import scala.collection.JavaConverters._
 
 import rsacomb.SkolemStrategy
 import rsacomb.RDFoxRuleShards
+import org.semanticweb.owlapi.model.OWLSubObjectPropertyOfAxiom
+import org.semanticweb.owlapi.model.OWLObjectProperty
 
 object RDFoxAxiomConverter {
 
-  def apply(term : Term, skolem : SkolemStrategy) : RDFoxAxiomConverter =
-        new RDFoxAxiomConverter(term, skolem)
-
-  def apply(term : Term) : RDFoxAxiomConverter =
-        new RDFoxAxiomConverter(term, SkolemStrategy.None)
+  def apply(
+    term : Term = Variable.create("x"),
+    skolem : SkolemStrategy = SkolemStrategy.None,
+    unsafe : List[OWLObjectPropertyExpression] = List()
+  ) : RDFoxAxiomConverter =
+          new RDFoxAxiomConverter(term, skolem, unsafe)
 
 } // object RDFoxAxiomConverter
 
-class RDFoxAxiomConverter(term : Term, skolem : SkolemStrategy)
+class RDFoxAxiomConverter(term : Term, skolem : SkolemStrategy, unsafe : List[OWLObjectPropertyExpression])
   extends OWLAxiomVisitorEx[List[Rule]]
 {
 
   override
   def visit(axiom : OWLSubClassOfAxiom) : List[Rule] = {
     // Skolemization is needed only for the head of an axiom
-    val subVisitor = new RDFoxClassExprConverter(term,SkolemStrategy.None)
-    val superVisitor = new RDFoxClassExprConverter(term, skolem)
+    val subVisitor = new RDFoxClassExprConverter(term,SkolemStrategy.None, unsafe)
+    val superVisitor = new RDFoxClassExprConverter(term, skolem, unsafe)
     // Each visitor returns a `RDFoxRuleShards`, a tuple (res,ext):
     // - the `res` List is a list of atoms resulting from the conversion
     //   of the axiom.
@@ -46,11 +50,23 @@ class RDFoxAxiomConverter(term : Term, skolem : SkolemStrategy)
 
   override
   def visit(axiom : OWLEquivalentClassesAxiom) : List[Rule] = {
-        for {
-          axiom1 <- axiom.asPairwiseAxioms.asScala.toList
-          axiom2 <- axiom1.asOWLSubClassOfAxioms.asScala.toList
-          rule   <- axiom2.accept(this)
-        } yield rule
+    for {
+      axiom1 <- axiom.asPairwiseAxioms.asScala.toList
+      axiom2 <- axiom1.asOWLSubClassOfAxioms.asScala.toList
+      rule   <- axiom2.accept(this)
+    } yield rule
+  }
+
+  override
+  def visit(axiom : OWLSubObjectPropertyOfAxiom) : List[Rule] = {
+    // TODO: variables needs to be handled at visitor level. Hardcoding
+    // the name of the varibles might lead to errors for complex cases.
+    val term1 = Variable.create("y")
+    val subVisitor = new RDFoxPropertyExprConverter(term,term1,SkolemStrategy.None)
+    val superVisitor = new RDFoxPropertyExprConverter(term,term1,skolem)
+    val body: List[BodyFormula] = axiom.getSubProperty.accept(subVisitor)
+    val head: List[Atom] = axiom.getSuperProperty.accept(superVisitor)
+    List(Rule.create(head.asJava,body.asJava))
   }
 
   def doDefault(axiom : OWLAxiom) : List[Rule] = List()