Reorganize project with Java-like folder structure

5 files changed, 383 insertions, 0 deletions

diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxAxiomConverter.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxAxiomConverter.scala
new file mode 100644
index 0000000..a8d1ffd
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxAxiomConverter.scala
@@ -0,0 +1,105 @@
+package uk.ac.ox.cs.rsacomb.converter
+
+import org.semanticweb.owlapi.model.{
+  OWLAxiom,
+  OWLSubClassOfAxiom,
+  OWLEquivalentClassesAxiom,
+  OWLObjectPropertyExpression
+}
+import org.semanticweb.owlapi.model.OWLAxiomVisitorEx
+
+import tech.oxfordsemantic.jrdfox.logic.datalog.{
+  Rule,
+  BodyFormula,
+  TupleTableAtom,
+  TupleTableName
+}
+import tech.oxfordsemantic.jrdfox.logic.expression.{
+  Term,
+  IRI,
+  Variable,
+  Literal
+}
+
+import scala.collection.JavaConverters._
+
+import org.semanticweb.owlapi.model.OWLSubObjectPropertyOfAxiom
+import org.semanticweb.owlapi.model.OWLObjectProperty
+import org.semanticweb.owlapi.model.OWLClassAssertionAxiom
+
+import uk.ac.ox.cs.rsacomb.RSAOntology
+import uk.ac.ox.cs.rsacomb.suffix.{RSASuffix, Empty}
+
+object RDFoxAxiomConverter {
+
+  def apply(
+      term: Term,
+      unsafe: List[OWLObjectPropertyExpression],
+      skolem: SkolemStrategy = SkolemStrategy.None,
+      suffix: RSASuffix = Empty
+  ): RDFoxAxiomConverter =
+    new RDFoxAxiomConverter(term, unsafe, skolem, suffix)
+
+} // object RDFoxAxiomConverter
+
+class RDFoxAxiomConverter(
+    term: Term,
+    unsafe: List[OWLObjectPropertyExpression],
+    skolem: SkolemStrategy,
+    suffix: RSASuffix
+) 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, unsafe, SkolemStrategy.None, suffix)
+    val superVisitor = new RDFoxClassExprConverter(term, unsafe, skolem, suffix)
+    // Each visitor returns a `RDFoxRuleShards`, a tuple (res,ext):
+    // - the `res` List is a list of atoms resulting from the conversion
+    //   of the axiom.
+    // - for some Class Expressions appearing in the head of an Axiom,
+    //   the conversion might produce atoms that need to appear in the
+    //   body (and not in the head) of the rule. This is what the `ext`
+    //   List is for.
+    val sub = axiom.getSubClass.accept(subVisitor)
+    val sup = axiom.getSuperClass.accept(superVisitor)
+    val head = sup.res.asJava
+    val body = (sub.res ++ sup.ext).asJava
+    List(Rule.create(head, body))
+  }
+
+  override def visit(axiom: OWLEquivalentClassesAxiom): List[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] = {
+    val term1 = RSAOntology.genFreshVariable()
+    val subVisitor =
+      new RDFoxPropertyExprConverter(term, term1, suffix)
+    val superVisitor = new RDFoxPropertyExprConverter(term, term1, suffix)
+    val body: List[BodyFormula] = axiom.getSubProperty.accept(subVisitor)
+    val head: List[TupleTableAtom] = axiom.getSuperProperty.accept(superVisitor)
+    List(Rule.create(head.asJava, body.asJava))
+  }
+
+  override def visit(axiom: OWLClassAssertionAxiom): List[Rule] = {
+    val ind = axiom.getIndividual
+    if (ind.isNamed) {
+      val term = IRI.create(ind.asOWLNamedIndividual().getIRI.getIRIString)
+      val cls = axiom.getClassExpression
+      val visitor =
+        new RDFoxClassExprConverter(term, unsafe, SkolemStrategy.None, suffix)
+      val shard = cls.accept(visitor)
+      List(Rule.create(shard.res.asJava, shard.ext.asJava))
+    } else {
+      List()
+    }
+  }
+
+  def doDefault(axiom: OWLAxiom): List[Rule] = List()
+
+} // class RDFoxAxiomConverter
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxClassExprConverter.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxClassExprConverter.scala
new file mode 100644
index 0000000..c151c9a
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxClassExprConverter.scala
@@ -0,0 +1,160 @@
+package uk.ac.ox.cs.rsacomb.converter
+
+import scala.collection.JavaConverters._
+import java.util.stream.{Stream, Collectors}
+
+import org.semanticweb.owlapi.model.{
+  OWLClassExpression,
+  OWLClass,
+  OWLObjectSomeValuesFrom,
+  OWLObjectIntersectionOf,
+  OWLObjectOneOf,
+  OWLObjectMaxCardinality
+}
+import org.semanticweb.owlapi.model.OWLClassExpressionVisitorEx
+import tech.oxfordsemantic.jrdfox.logic.Datatype
+import tech.oxfordsemantic.jrdfox.logic.datalog.{
+  BindAtom,
+  TupleTableName,
+  TupleTableAtom
+}
+import tech.oxfordsemantic.jrdfox.logic.expression.{
+  Term,
+  Literal,
+  Variable,
+  FunctionCall,
+  IRI
+}
+
+import org.semanticweb.owlapi.model.OWLObjectPropertyExpression
+import org.semanticweb.owlapi.model.OWLObjectProperty
+
+import uk.ac.ox.cs.rsacomb.RSAOntology
+import uk.ac.ox.cs.rsacomb.suffix.{RSASuffix, Empty}
+import uk.ac.ox.cs.rsacomb.util.RSA
+
+object RDFoxClassExprConverter {
+
+  def apply(
+      term: Term,
+      unsafe: List[OWLObjectPropertyExpression] = List(),
+      skolem: SkolemStrategy = SkolemStrategy.None,
+      suffix: RSASuffix = Empty
+  ): RDFoxClassExprConverter =
+    new RDFoxClassExprConverter(term, unsafe, skolem, suffix)
+
+  def merge(rules: List[RDFoxRuleShards]): RDFoxRuleShards = {
+    rules.foldLeft(RDFoxRuleShards(List(), List())) { (r1, r2) =>
+      RDFoxRuleShards(
+        r1.res ++ r2.res,
+        r1.ext ++ r2.ext
+      )
+    }
+  }
+
+} // object RDFoxClassExprConverter
+
+class RDFoxClassExprConverter(
+    term: Term,
+    unsafe: List[OWLObjectPropertyExpression],
+    skolem: SkolemStrategy,
+    suffix: RSASuffix
+) extends OWLClassExpressionVisitorEx[RDFoxRuleShards] {
+
+  import uk.ac.ox.cs.rsacomb.implicits.RDFox._
+
+  // OWLClass
+  override def visit(expr: OWLClass): RDFoxRuleShards = {
+    val iri: IRI = if (expr.isTopEntity()) IRI.THING else expr.getIRI()
+    val atom = List(TupleTableAtom.rdf(term, IRI.RDF_TYPE, iri))
+    RDFoxRuleShards(atom, List())
+  }
+
+  // OWLObjectIntersectionOf
+  override def visit(expr: OWLObjectIntersectionOf): RDFoxRuleShards = {
+    val visitor = new RDFoxClassExprConverter(term, unsafe, skolem, suffix)
+    // TODO: maybe using `flatMap` instead of `merge` + `map` works as well
+    RDFoxClassExprConverter.merge(
+      expr.asConjunctSet.asScala.toList
+        .map((e: OWLClassExpression) => e.accept(visitor))
+    )
+  }
+
+  // OWLObjectOneOf
+  override def visit(expr: OWLObjectOneOf): RDFoxRuleShards = {
+    val visitor = RDFoxClassExprConverter(term, unsafe, skolem, suffix)
+    // TODO: review nominal handling. Here we are taking "just" one
+    val ind = expr.individuals
+      .collect(Collectors.toList())
+      .asScala
+      .filter(_.isOWLNamedIndividual)
+      .head // restricts to proper "nominals"
+      .asOWLNamedIndividual
+      .getIRI
+    val atom = List(
+      TupleTableAtom.rdf(term, IRI.SAME_AS, ind)
+    )
+    RDFoxRuleShards(atom, List())
+  }
+
+  // OWLObjectSomeValuesFrom
+  override def visit(expr: OWLObjectSomeValuesFrom): RDFoxRuleShards = {
+    val y = RSAOntology.genFreshVariable()
+    // Here we are assuming a role name
+    val prop = expr.getProperty()
+    // Computes the result of rule skolemization. Depending on the used
+    // technique it might involve the introduction of additional atoms,
+    // and/or fresh constants and variables.
+    val (head, body, term1) = skolem match {
+      case SkolemStrategy.None        => (List(), List(), y)
+      case SkolemStrategy.Constant(c) => (List(), List(), c)
+      case SkolemStrategy.ConstantRSA(c) => {
+        if (unsafe.contains(prop))
+          (List(RSA.PE(term, c), RSA.U(c)), List(), c)
+        else
+          (List(), List(), c)
+      }
+      case SkolemStrategy.Standard(f) => {
+        (
+          List(),
+          List(BindAtom.create(FunctionCall.create("SKOLEM", f, term), y)),
+          y
+        )
+      }
+    }
+    val classVisitor =
+      new RDFoxClassExprConverter(term1, unsafe, skolem, suffix)
+    val classResult = expr.getFiller.accept(classVisitor)
+    val propertyVisitor = new RDFoxPropertyExprConverter(term, term1, suffix)
+    val propertyResult = expr.getProperty.accept(propertyVisitor)
+    RDFoxRuleShards(
+      classResult.res ++ propertyResult ++ head,
+      classResult.ext ++ body
+    )
+  }
+
+  // OWLObjectMaxCardinality
+  override def visit(expr: OWLObjectMaxCardinality): RDFoxRuleShards = {
+    // TODO: again, no hardcoded variables
+    val vars =
+      List(RSAOntology.genFreshVariable(), RSAOntology.genFreshVariable())
+    val classResult = RDFoxClassExprConverter.merge(
+      vars
+        .map(new RDFoxClassExprConverter(_, unsafe, skolem, suffix))
+        .map(expr.getFiller.accept(_))
+    )
+    val propertyResult =
+      vars
+        .map(new RDFoxPropertyExprConverter(term, _, suffix))
+        .map(expr.getProperty.accept(_))
+        .flatten
+    RDFoxRuleShards(
+      List(TupleTableAtom.rdf(vars(0), IRI.SAME_AS, vars(1))),
+      classResult.res ++ propertyResult
+    )
+  }
+
+  def doDefault(expr: OWLClassExpression): RDFoxRuleShards =
+    RDFoxRuleShards(List(), List())
+
+} // class RDFoxClassExprConverter
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxPropertyExprConverter.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxPropertyExprConverter.scala
new file mode 100644
index 0000000..94c7887
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxPropertyExprConverter.scala
@@ -0,0 +1,35 @@
+package uk.ac.ox.cs.rsacomb.converter
+
+import org.semanticweb.owlapi.model.{OWLPropertyExpression, OWLObjectProperty}
+import org.semanticweb.owlapi.model.OWLPropertyExpressionVisitorEx
+
+import tech.oxfordsemantic.jrdfox.logic.datalog.TupleTableAtom
+import tech.oxfordsemantic.jrdfox.logic.expression.{Term, IRI, Literal}
+
+import org.semanticweb.owlapi.model.OWLObjectInverseOf
+
+import uk.ac.ox.cs.rsacomb.suffix.{RSASuffix, Inverse}
+
+class RDFoxPropertyExprConverter(
+    term1: Term,
+    term2: Term,
+    suffix: RSASuffix
+) extends OWLPropertyExpressionVisitorEx[List[TupleTableAtom]] {
+
+  // Automatically converts OWLAPI types into RDFox equivalent types.
+  import uk.ac.ox.cs.rsacomb.implicits.RDFox._
+
+  override def visit(expr: OWLObjectProperty): List[TupleTableAtom] = {
+    val base = expr.getIRI.getIRIString
+    val pred = IRI.create(base :: suffix)
+    List(TupleTableAtom.rdf(term1, pred, term2))
+  }
+
+  override def visit(expr: OWLObjectInverseOf): List[TupleTableAtom] = {
+    val visitor = new RDFoxPropertyExprConverter(term1, term2, suffix + Inverse)
+    expr.getInverse.accept(visitor)
+  }
+
+  def doDefault(expr: OWLPropertyExpression): List[TupleTableAtom] = List()
+
+} // class RDFoxPropertyExprConverter
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxRuleShards.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxRuleShards.scala
new file mode 100644
index 0000000..c88cf3c
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/RDFoxRuleShards.scala
@@ -0,0 +1,5 @@
+package uk.ac.ox.cs.rsacomb.converter
+
+import tech.oxfordsemantic.jrdfox.logic.datalog.{TupleTableAtom, BodyFormula}
+
+case class RDFoxRuleShards(res: List[TupleTableAtom], ext: List[BodyFormula])
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/converter/SkolemStrategy.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/SkolemStrategy.scala
new file mode 100644
index 0000000..0d72226
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/converter/SkolemStrategy.scala
@@ -0,0 +1,78 @@
+package uk.ac.ox.cs.rsacomb.converter
+
+import tech.oxfordsemantic.jrdfox.logic.Datatype
+import tech.oxfordsemantic.jrdfox.logic.expression.{Literal, IRI}
+
+sealed trait SkolemStrategy
+
+object SkolemStrategy {
+  // TODO: might want to use something else other than `hashCode` as a
+  // function to generate a fresh function/constant
+
+  /* No skolemization at all.
+   *
+   * From
+   *    ∃R.A ⊑ B
+   * to
+   *    R(x,y), B(y) -> B(x)
+   */
+  case object None extends SkolemStrategy
+
+  /* Functional skolemization
+   *
+   * From
+   *    A ⊑ ∃R.B
+   * to
+   *    A(x) -> R(x,f(x)), B(f(x))
+   * for f, fresh function associated with the input axiom
+   *
+   * In RDFox this can represented combining the BIND operator with the
+   * SKOLEM operator as such:
+   *    A(x), BIND(y, SKOLEM("f", x)) -> R(x,y), B(y)
+   * The first argument of a SKOLEM call is a literal string (ideally
+   * identifing the simulated function name).
+   *
+   * NOTE: this requirement for the SKOLEM operator is not enforced by
+   * RDFox, that will fail silently if omitted.
+   */
+  case class Standard(func: Literal) extends SkolemStrategy
+  object Standard {
+    def apply(axiom: String) =
+      new Standard(
+        Literal.create(genFunctionString(axiom), Datatype.XSD_STRING)
+      )
+    def genFunctionString(str: String) = "f_" ++ str.hashCode.toString
+  }
+
+  /* Constant skolemization
+   *
+   * From
+   *    A ⊑ ∃R.B
+   * to
+   *    A(y) -> R(x,c), B(c)
+   * for c, fresh constant associated with the input axiom
+   */
+  case class Constant(const: IRI) extends SkolemStrategy
+  object Constant {
+    def apply(axiom: String) =
+      new Constant(IRI.create(genConstantString(axiom)))
+    def genConstantString(str: String) = "c_" ++ str.hashCode.toString
+  }
+
+  /* (RSA) Constant skolemization
+   * This is a special skolemization option to introduce additional atoms for RSA
+   * checking algorithm.
+   *
+   * From
+   *    A ⊑ ∃R.B
+   * to
+   *    A(y) -> R(x,c), PE(x,c), B(c)
+   * for c, fresh constant associated with the input axiom and PE an internal predicate.
+   */
+  case class ConstantRSA(const: IRI) extends SkolemStrategy
+  object ConstantRSA {
+    def apply(axiom: String) =
+      new ConstantRSA(IRI.create(genConstantString(axiom)))
+    def genConstantString(str: String) = "c_" ++ str.hashCode.toString
+  }
+}