From 4df351d3b1d11fc045005323c38ba3528de631ea Mon Sep 17 00:00:00 2001
From: Federico Igne <federico.igne@cs.ox.ac.uk>
Date: Wed, 18 Nov 2020 18:07:53 +0000
Subject: Rework RSA as a utility object

---
 src/main/scala/rsacomb/RSA.scala | 105 ++++++++++++++++++++++++++-------------
 1 file changed, 71 insertions(+), 34 deletions(-)

(limited to 'src/main/scala/rsacomb/RSA.scala')

diff --git a/src/main/scala/rsacomb/RSA.scala b/src/main/scala/rsacomb/RSA.scala
index b0e140b..1b2aa9c 100644
--- a/src/main/scala/rsacomb/RSA.scala
+++ b/src/main/scala/rsacomb/RSA.scala
@@ -1,11 +1,16 @@
-package rsacomb
+package rsacomb.util
 
 /* Java imports */
 import java.util.Map
 
 import tech.oxfordsemantic.jrdfox.formats.SPARQLParser
 import tech.oxfordsemantic.jrdfox.Prefixes
-import tech.oxfordsemantic.jrdfox.logic.expression.{Variable, IRI}
+import tech.oxfordsemantic.jrdfox.logic.datalog.{
+  TupleTableAtom,
+  TupleTableName,
+  Negation
+}
+import tech.oxfordsemantic.jrdfox.logic.expression.{Term, Variable, IRI}
 import org.semanticweb.owlapi.model.OWLOntology
 import org.semanticweb.owlapi.model.{
   OWLAxiom,
@@ -13,51 +18,83 @@ import org.semanticweb.owlapi.model.{
   OWLObjectPropertyExpression
 }
 
+import rsacomb.suffix.RSASuffix
+
 // Debug only
 import scala.collection.JavaConverters._
 
-object RSA extends RSAAxiom {
+object RSA {
 
   val Prefixes: Prefixes = new Prefixes()
-  Prefixes.declarePrefix(":", "http://example.com/rsa_example.owl#")
   Prefixes.declarePrefix("rsa:", "http://127.0.0.1/")
-  Prefixes.declarePrefix("rdf:", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
-  Prefixes.declarePrefix("rdfs:", "http://www.w3.org/2000/01/rdf-schema#")
-  Prefixes.declarePrefix("owl:", "http://www.w3.org/2002/07/owl#")
 
-  val EquivTo: IRI = this.rsa("EquivTo")
-  val Named: IRI = this.rsa("NAMED")
+  private def atom(name: IRI, vars: List[Term]) =
+    TupleTableAtom.create(TupleTableName.create(name.getIRI), vars: _*)
+
+  def PE(t1: Term, t2: Term) =
+    TupleTableAtom.rdf(t1, RSA("PE"), t2)
+
+  def U(t: Term) =
+    TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("U"))
+
+  def In(t: Term)(implicit set: Term) =
+    TupleTableAtom.rdf(t, RSA("In"), set)
+
+  def notIn(t: Term)(implicit set: Term) = Negation.create(In(t)(set))
 
-  // Counter used to implement a simple fresh variable generator
-  private var counter = -1;
+  def EquivTo(t1: Term, t2: Term) =
+    TupleTableAtom.rdf(t1, RSA("EquivTo"), t2)
 
-  def getFreshVariable(): Variable = {
-    counter += 1
-    Variable.create(f"I$counter%03d")
+  def QM(implicit variables: (List[Term], List[Term])) = {
+    val (answer, bounded) = variables
+    atom(RSA("QM"), answer ::: bounded)
   }
 
-  def base(name: Any): IRI =
-    IRI.create(
-      Prefixes.getPrefixIRIsByPrefixName.get(":").getIRI
-        + name.toString
-    )
+  def ID(t1: Term, t2: Term)(implicit variables: (List[Term], List[Term])) = {
+    val (answer, bounded) = variables
+    atom(RSA("ID"), (answer ::: bounded) :+ t1 :+ t2)
+  }
 
-  def rsa(name: Any): IRI =
-    IRI.create(
-      Prefixes.getPrefixIRIsByPrefixName.get("rsa:").getIRI
-        + name.toString
-    )
+  def Named(t: Term) =
+    TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("Named"))
+
+  def Thing(t: Term) =
+    TupleTableAtom.rdf(t, IRI.RDF_TYPE, IRI.THING)
 
-  def hashed(
-      cls1: OWLClass,
-      prop: OWLObjectPropertyExpression,
-      cls2: OWLClass
-  ): String =
-    (cls1, prop, cls2).hashCode.toString
+  def NI(t: Term) =
+    TupleTableAtom.rdf(t, IRI.RDF_TYPE, RSA("NI"))
 
-  def hashed(axiom: OWLAxiom): String = {
-    val (cls1, prop, cls2) = axiom.toTriple.get
-    this.hashed(cls1, prop, cls2)
+  def TQ(t1: Term, t2: Term, sx: RSASuffix)(implicit
+      variables: (List[Term], List[Term])
+  ) = {
+    val (answer, bounded) = variables
+    atom(RSA("TQ" :: sx), (answer ::: bounded) :+ t1 :+ t2)
   }
 
-} // object RSA
+  def AQ(t1: Term, t2: Term, sx: RSASuffix)(implicit
+      variables: (List[Term], List[Term])
+  ) = {
+    val (answer, bounded) = variables
+    atom(RSA("AQ" :: sx), (answer ::: bounded) :+ t1 :+ t2)
+  }
+
+  def FK(implicit variables: (List[Term], List[Term])) = {
+    val (answer, bounded) = variables
+    atom(RSA("FK"), answer ::: bounded)
+  }
+
+  def SP(implicit variables: (List[Term], List[Term])) = {
+    val (answer, bounded) = variables
+    atom(RSA("SP"), answer ::: bounded)
+  }
+
+  def Ans(implicit variables: (List[Term], List[Term])) = {
+    val (answer, _) = variables
+    atom(RSA("Ans"), answer)
+  }
+
+  def apply(name: Any): IRI =
+    IRI.create(
+      Prefixes.getPrefixIRIsByPrefixName.get("rsa:").getIRI + name.toString
+    )
+}
-- 
cgit v1.2.3