7 files changed, 62 insertions, 57 deletions

diff --git a/src/main/scala/rsacomb/RDFoxAxiomConverter.scala b/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
index 0a6272f..675ca7d 100644
--- a/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
+++ b/src/main/scala/rsacomb/RDFoxAxiomConverter.scala
@@ -3,8 +3,8 @@ package rsacomb
 import org.semanticweb.owlapi.model.{OWLAxiom, OWLSubClassOfAxiom, OWLEquivalentClassesAxiom}
 import org.semanticweb.owlapi.model.OWLAxiomVisitorEx
 
-import tech.oxfordsemantic.jrdfox.logic.Rule
-import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Literal, Individual}
+import tech.oxfordsemantic.jrdfox.logic.{Rule, BodyFormula}
+import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Literal}
 
 import scala.collection.JavaConverters._
 
diff --git a/src/main/scala/rsacomb/RDFoxClassExprConverter.scala b/src/main/scala/rsacomb/RDFoxClassExprConverter.scala
index 3e60461..bf026c3 100644
--- a/src/main/scala/rsacomb/RDFoxClassExprConverter.scala
+++ b/src/main/scala/rsacomb/RDFoxClassExprConverter.scala
@@ -5,8 +5,8 @@ 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.{AtomicFormula, Bind,BuiltinFunctionCall}
-import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Literal, Individual}
+import tech.oxfordsemantic.jrdfox.logic.{BindAtom, BuiltinFunctionCall, TupleTableName}
+import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Variable, Literal, Datatype}
 
 import rsacomb.SkolemStrategy
 import rsacomb.RDFoxRuleShards
@@ -39,7 +39,7 @@ class RDFoxClassExprConverter(term : Term, skolem : SkolemStrategy)
   override
   def visit(expr : OWLClass) : RDFoxRuleShards = {
     val name = expr.getIRI.getIRIString
-    val atom = List(Atom.create(Predicate.create(name), term))
+    val atom = List(Atom.create(TupleTableName.create(name), term))
     RDFoxRuleShards(atom,List())
   }
 
@@ -64,7 +64,7 @@ class RDFoxClassExprConverter(term : Term, skolem : SkolemStrategy)
                   .head // restricts to proper "nominals"
                   .asOWLNamedIndividual.getIRI.getIRIString
     val atom = List(Atom.create(
-      Predicate.create("owl:sameAs"), term, Individual.create(ind)
+      TupleTableName.create("owl:sameAs"), term, Literal.create(ind, Datatype.IRI_REFERENCE)
     ))
     RDFoxRuleShards(atom,List())
   }
@@ -77,12 +77,12 @@ class RDFoxClassExprConverter(term : Term, skolem : SkolemStrategy)
     val y = Variable.create("y")
         val (fun,term1) = skolem match {
       case SkolemStrategy.None => (List(),y)
-      case SkolemStrategy.Constant(c) => (List(), Individual.create(c))
+      case SkolemStrategy.Constant(c) => (List(), Literal.create(c, Datatype.IRI_REFERENCE))
       case SkolemStrategy.Standard(f) => 
         // At the time of writing the RDFox library does not have a
         // particular class for the "SKOLEM" operator and it is instead
         // a simple builtin function with a special name.
-        (List(Bind.create(BuiltinFunctionCall.create("SKOLEM",term),y)),y)
+        (List(BindAtom.create(BuiltinFunctionCall.create("SKOLEM",term),y)),y)
         }
     val classVisitor = new RDFoxClassExprConverter(term1,skolem)
     val classResult = expr.getFiller.accept(classVisitor)
@@ -108,7 +108,7 @@ class RDFoxClassExprConverter(term : Term, skolem : SkolemStrategy)
           .map(expr.getProperty.accept(_))
           .flatten
     RDFoxRuleShards(
-      List(Atom.create(Predicate.create("owl:sameAs"),vars(0),vars(1))),
+      List(Atom.create(TupleTableName.create("owl:sameAs"),vars(0),vars(1))),
       classResult.res ++ propertyResult
     )
   }
diff --git a/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala b/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala
index 2885ed9..8d472bf 100644
--- a/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala
+++ b/src/main/scala/rsacomb/RDFoxPropertyExprConverter.scala
@@ -3,7 +3,8 @@ package rsacomb
 import org.semanticweb.owlapi.model.{OWLPropertyExpression, OWLObjectProperty}
 import org.semanticweb.owlapi.model.OWLPropertyExpressionVisitorEx
 
-import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Literal}
+import tech.oxfordsemantic.jrdfox.logic.{TupleTableName}
+import tech.oxfordsemantic.jrdfox.logic.{Atom, Term, Variable, Literal}
 
 import rsacomb.SkolemStrategy
 
@@ -14,7 +15,7 @@ class RDFoxPropertyExprConverter(term1 : Term, term2 : Term, skolem : SkolemStra
   override
   def visit(expr : OWLObjectProperty) : List[Atom] = {
     val name = expr.getIRI.getIRIString
-    List(Atom.create(Predicate.create(name), term1, term2))
+    List(Atom.create(TupleTableName.create(name), term1, term2))
   }
 
   def doDefault(expr : OWLPropertyExpression) : List[Atom] = List()
diff --git a/src/main/scala/rsacomb/RDFoxRuleShards.scala b/src/main/scala/rsacomb/RDFoxRuleShards.scala
index bce31d2..8f72983 100644
--- a/src/main/scala/rsacomb/RDFoxRuleShards.scala
+++ b/src/main/scala/rsacomb/RDFoxRuleShards.scala
@@ -1,6 +1,6 @@
 package rsacomb
 
-import tech.oxfordsemantic.jrdfox.logic.{Rule, Atom, Literal}
+import tech.oxfordsemantic.jrdfox.logic.{Atom, BodyFormula}
 
-case class RDFoxRuleShards(res : List[Atom], ext : List[Literal])
+case class RDFoxRuleShards(res : List[Atom], ext : List[BodyFormula])
 
diff --git a/src/main/scala/rsacomb/RSAComb.scala b/src/main/scala/rsacomb/RSAComb.scala
index bc94a8d..16d7a04 100644
--- a/src/main/scala/rsacomb/RSAComb.scala
+++ b/src/main/scala/rsacomb/RSAComb.scala
@@ -15,8 +15,9 @@ import org.semanticweb.owlapi.model.parameters.Imports
 import tech.oxfordsemantic.jrdfox.Prefixes
 import tech.oxfordsemantic.jrdfox.client.{ConnectionFactory, ServerConnection, DataStoreConnection}
 import tech.oxfordsemantic.jrdfox.client.UpdateType
-import tech.oxfordsemantic.jrdfox.logic.{Rule, Atom, Literal, Predicate, Term, Variable}
-import tech.oxfordsemantic.jrdfox.logic.{Bind, BuiltinFunctionCall}
+import tech.oxfordsemantic.jrdfox.logic.{Rule, Atom, Literal, Term, Variable}
+import tech.oxfordsemantic.jrdfox.logic.{BuiltinFunctionCall, TupleTableName}
+import tech.oxfordsemantic.jrdfox.logic.{LogicFormat}
 
 import scala.collection.JavaConverters._
 
@@ -46,6 +47,9 @@ object RSA {
      * 2) call RDFox on the onto and compute materialization
      * 3) build graph from E(x,y) facts
      * 4) check if the graph is tree-like
+     *    ideally this annotates the graph with info about the reasons
+     *    why the ontology might not be RSA. This could help a second
+     *    step of approximation of an Horn-ALCHOIQ to RSA
      */
 
     /* Ontology axiom convertion into LP rules */
diff --git a/src/test/scala/rsacomb/OWLAxiomSpec.scala b/src/test/scala/rsacomb/OWLAxiomSpec.scala
index b6a44f4..8238536 100644
--- a/src/test/scala/rsacomb/OWLAxiomSpec.scala
+++ b/src/test/scala/rsacomb/OWLAxiomSpec.scala
@@ -8,8 +8,8 @@ import uk.ac.manchester.cs.owl.owlapi.{OWLClassImpl, OWLObjectSomeValuesFromImpl
 import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl}
 import org.semanticweb.owlapi.model.{OWLAxiom,IRI}
 
-import tech.oxfordsemantic.jrdfox.logic.{Rule,Bind,BuiltinFunctionCall}
-import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Individual}
+import tech.oxfordsemantic.jrdfox.logic.{Rule,BindAtom,BuiltinFunctionCall}
+import tech.oxfordsemantic.jrdfox.logic.{Atom, TupleTableName, Term, Variable, Literal, Datatype}
 
 object OWLAxiomSpec {
 
@@ -28,14 +28,14 @@ object OWLAxiomSpec {
   val term_x = Variable.create("x")
   val term_y = Variable.create("y")
   val term_z = Variable.create("z")
-  val term_c1 = Individual.create("internal:c_1")
-  val term_c2 = Individual.create("internal:c_2")
-  val term_alice = Individual.create("univ:alice")
+  val term_c1 = Literal.create("internal:c_1", Datatype.IRI_REFERENCE)
+  val term_c2 = Literal.create("internal:c_2", Datatype.IRI_REFERENCE)
+  val term_alice = Literal.create("univ:alice", Datatype.IRI_REFERENCE)
 
   // RDFox Predicates
-  val pred_sameAs = Predicate.create("owl:sameAs")
-  val pred_Professor = Predicate.create(iri_Professor.getIRIString)
-  val pred_hasSupervisor = Predicate.create(iri_hasSupervisor.getIRIString)
+  val pred_sameAs = TupleTableName.create("owl:sameAs")
+  val pred_Professor = TupleTableName.create(iri_Professor.getIRIString)
+  val pred_hasSupervisor = TupleTableName.create(iri_hasSupervisor.getIRIString)
 
   // OWL Classes
   // Name Class corresponding to
@@ -164,15 +164,15 @@ class OWLAxiomSpec
   it should "contain a conjuction of atoms (Student[?x],Worker[?x]) in the body of the rule" in {
     val result = convertAxiom(axiom_OWLSubClassOf1,term_x)
     val body = List(
-      Atom.create(Predicate.create(iri_Student.getIRIString),term_x),
-      Atom.create(Predicate.create(iri_Worker.getIRIString),term_x)
+      Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x),
+      Atom.create(TupleTableName.create(iri_Worker.getIRIString),term_x)
     )
     result.loneElement.getBody should contain theSameElementsAs body
   }
 
   it should "contain a single atom (PartTimeStudent[?x]) in the head of the rule" in {
     val result = convertAxiom(axiom_OWLSubClassOf1,term_x)
-    val head = Atom.create(Predicate.create(iri_PartTimeStudent.getIRIString),term_x)
+    val head = Atom.create(TupleTableName.create(iri_PartTimeStudent.getIRIString),term_x)
     result.loneElement.getHead.loneElement should be (head)
   }
 
@@ -188,17 +188,17 @@ class OWLAxiomSpec
   it should "contain a single atom (Student[?x]) in the body of the rule" in {
     val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString)
     val result = convertAxiom(axiom_OWLSubClassOf2,term_x,skolem)
-    val body = Atom.create(Predicate.create(iri_Student.getIRIString),term_x)
+    val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x)
     result.loneElement.getBody.loneElement should equal (body)
   }
 
   it should "contain a conjuction of atoms (hasSupervisor[?x,?c],Professor[?c]) in the head of the rule" in {
     val skolem = SkolemStrategy.Constant(axiom_OWLSubClassOf2.toString)
     val result = convertAxiom(axiom_OWLSubClassOf2,term_x,skolem)
-    val term_c = Individual.create(skolem.const)
+    val term_c = Literal.create(skolem.const, Datatype.IRI_REFERENCE)
     val head = List(
-      Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_c),
-      Atom.create(Predicate.create(iri_Professor.getIRIString),term_c)
+      Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_c),
+      Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_c)
     )
     result.loneElement.getHead should contain theSameElementsAs (head)
   }
@@ -215,14 +215,14 @@ class OWLAxiomSpec
   it should "contain an atom (Student[?x]) in the body of the rule" in {
     val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString)
     val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem)
-    val body = Atom.create(Predicate.create(iri_Student.getIRIString),term_x)
+    val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x)
     result.loneElement.getBody should contain (body)
   }
 
   it should "contain a built-in function call (BIND(?y,SKOLEM(?f,?x))) in the body of the rule" in {
     val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString)
     val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem)
-    val call = Bind.create(BuiltinFunctionCall.create("SKOLEM",term_x),term_y)
+    val call = BindAtom.create(BuiltinFunctionCall.create("SKOLEM",term_x),term_y)
     result.loneElement.getBody should contain (call)
   }
 
@@ -230,8 +230,8 @@ class OWLAxiomSpec
     val skolem = SkolemStrategy.Standard(axiom_OWLSubClassOf2.toString)
     val result = convertAxiom(axiom_OWLSubClassOf2, term_x, skolem)
     val head = List(
-      Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_y),
-      Atom.create(Predicate.create(iri_Professor.getIRIString),term_y)
+      Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y),
+      Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y)
     )
     result.loneElement.getHead should contain theSameElementsAs head
   }
@@ -245,15 +245,15 @@ class OWLAxiomSpec
   it should "contain a conjunction of atoms (hasSupervisor[?x,?y],Professor[?y]) in the body of the rule" in {
     val result = convertAxiom(axiom_OWLSubClassOf3,term_x)
     val body = List(
-      Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_y),
-      Atom.create(Predicate.create(iri_Professor.getIRIString),term_y)
+      Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y),
+      Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y)
     )
     result.loneElement.getBody should contain theSameElementsAs body
   }
 
   it should "contain a single atom (Student[?x]) in the head of the rule" in {
     val result = convertAxiom(axiom_OWLSubClassOf3, term_x)
-    val head = Atom.create(Predicate.create(iri_Student.getIRIString),term_x)
+    val head = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x)
     result.loneElement.getHead.loneElement should be (head)
   }
 
@@ -265,13 +265,13 @@ class OWLAxiomSpec
 
   it should "contain a single atoms (Student[?x]) in the body of the rule" in {
     val result = convertAxiom(axiom_OWLSubClassOf4,term_x)
-    val body = Atom.create(Predicate.create(iri_Student.getIRIString),term_x)
+    val body = Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x)
     result.loneElement.getBody.loneElement should be (body)
   }
 
   it should "contain a single atom (sameAs[?x,alice])) in the head of the rule" in {
     val result = convertAxiom(axiom_OWLSubClassOf4, term_x)
-    val head = Atom.create(Predicate.create(iri_sameAs.getIRIString),term_x,term_alice)
+    val head = Atom.create(TupleTableName.create(iri_sameAs.getIRIString),term_x,term_alice)
     result.loneElement.getHead.loneElement should be (head)
   }
 
@@ -284,18 +284,18 @@ class OWLAxiomSpec
   it should "contain a conjunction of atoms (...) in the body of the rule" in {
     val result = convertAxiom(axiom_OWLSubClassOf5,term_x)
     val body = List(
-      Atom.create(Predicate.create(iri_Student.getIRIString),term_x),
-      Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_y),
-      Atom.create(Predicate.create(iri_Professor.getIRIString),term_y),
-      Atom.create(Predicate.create(iri_hasSupervisor.getIRIString),term_x,term_z),
-      Atom.create(Predicate.create(iri_Professor.getIRIString),term_z)
+      Atom.create(TupleTableName.create(iri_Student.getIRIString),term_x),
+      Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_y),
+      Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_y),
+      Atom.create(TupleTableName.create(iri_hasSupervisor.getIRIString),term_x,term_z),
+      Atom.create(TupleTableName.create(iri_Professor.getIRIString),term_z)
     )
     result.loneElement.getBody should contain theSameElementsAs body
   }
 
   it should "contain a single atom (sameAs[?x,?z])) in the head of the rule" in {
     val result = convertAxiom(axiom_OWLSubClassOf5, term_x)
-    val head = Atom.create(Predicate.create(iri_sameAs.getIRIString),term_y,term_z)
+    val head = Atom.create(TupleTableName.create(iri_sameAs.getIRIString),term_y,term_z)
     result.loneElement.getHead.loneElement should be (head)
   }
 
diff --git a/src/test/scala/rsacomb/OWLClassSpec.scala b/src/test/scala/rsacomb/OWLClassSpec.scala
index df10e19..98e14cf 100644
--- a/src/test/scala/rsacomb/OWLClassSpec.scala
+++ b/src/test/scala/rsacomb/OWLClassSpec.scala
@@ -6,8 +6,8 @@ import uk.ac.manchester.cs.owl.owlapi.{OWLClassImpl, OWLObjectSomeValuesFromImpl
 import uk.ac.manchester.cs.owl.owlapi.{OWLObjectPropertyImpl}
 import org.semanticweb.owlapi.model.IRI
 
-import tech.oxfordsemantic.jrdfox.logic.{Bind,BuiltinFunctionCall}
-import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Individual}
+import tech.oxfordsemantic.jrdfox.logic.{BindAtom,BuiltinFunctionCall}
+import tech.oxfordsemantic.jrdfox.logic.{Atom, TupleTableName, Term, Variable, Literal, Datatype}
 
 import rsacomb.RDFoxRuleShards
 
@@ -25,14 +25,14 @@ object OWLClassSpec {
   // RDFox Terms
   val term_x = Variable.create("x")
   val term_y = Variable.create("y")
-  val term_c1 = Individual.create("internal:c_1")
-  val term_c2 = Individual.create("internal:c_2")
-  val term_alice = Individual.create("univ:alice")
+  val term_c1 = Literal.create("internal:c_1", Datatype.IRI_REFERENCE)
+  val term_c2 = Literal.create("internal:c_2", Datatype.IRI_REFERENCE)
+  val term_alice = Literal.create("univ:alice", Datatype.IRI_REFERENCE)
 
   // RDFox Predicates
-  val pred_sameAs = Predicate.create("owl:sameAs")
-  val pred_Professor = Predicate.create(iri_Professor.getIRIString)
-  val pred_hasSupervisor = Predicate.create(iri_hasSupervisor.getIRIString)
+  val pred_sameAs = TupleTableName.create("owl:sameAs")
+  val pred_Professor = TupleTableName.create(iri_Professor.getIRIString)
+  val pred_hasSupervisor = TupleTableName.create(iri_hasSupervisor.getIRIString)
 
   // OWL Classes
   // Name Class corresponding to
@@ -135,7 +135,7 @@ class OWLClassSpec
   it should "be converted into a single <owl:sameAs> Atom" in {
     val visitor = RDFoxClassExprConverter(term_x)
     val result = class_OWLObjectOneOf.accept(visitor)
-    result.res.loneElement should (be (a [Atom]) and have ('predicate (pred_sameAs)))
+    result.res.loneElement should (be (a [Atom]) and have ('tupleTableName (pred_sameAs)))
   }
 
   it should "have an empty extension list" in {
@@ -196,8 +196,8 @@ class OWLClassSpec
     val skolem = SkolemStrategy.Standard(class_OWLObjectSomeValuesFrom.toString)
     val visitor = RDFoxClassExprConverter(term_x,skolem)
     val result = class_OWLObjectSomeValuesFrom.accept(visitor)
-    result.ext.loneElement shouldBe a [Bind]
-    val builtin = result.ext.head.asInstanceOf[Bind].getBuiltinExpression
+    result.ext.loneElement shouldBe a [BindAtom]
+    val builtin = result.ext.head.asInstanceOf[BindAtom].getBuiltinExpression
     builtin should (be (a [BuiltinFunctionCall]) and have ('functionName ("SKOLEM")))
   }
 
@@ -241,7 +241,7 @@ class OWLClassSpec
   it should "have a single <owl:sameAs> Atom in the result list" in {
     val visitor = RDFoxClassExprConverter(term_x)
     val result = class_OWLObjectMaxCardinality.accept(visitor)
-    result.res.loneElement should (be (an [Atom]) and have ('predicate (pred_sameAs)))
+    result.res.loneElement should (be (an [Atom]) and have ('tupleTableName (pred_sameAs)))
   }
 
   it should "have two unary Atoms in its extension list" in {