Add versioning system for different versions of code

Later on this will allow us to select the algorithm from the command
line and compare performance easily.

6 files changed, 98 insertions, 33 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 42a5b87..b0b52c7 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
@@ -58,6 +58,7 @@ import tech.oxfordsemantic.jrdfox.logic._
 import org.semanticweb.owlapi.model.OWLObjectInverseOf
 
 import uk.ac.ox.cs.rsacomb.converter._
+import uk.ac.ox.cs.rsacomb.filtering.{FilteringProgram, FilterType}
 import uk.ac.ox.cs.rsacomb.suffix._
 import uk.ac.ox.cs.rsacomb.sparql._
 import uk.ac.ox.cs.rsacomb.util.{RDFoxUtil, RSA}
@@ -409,7 +410,7 @@ class RSAOntology(_ontology: File, val datafiles: File*) {
 
   def filteringProgram(query: ConjunctiveQuery): FilteringProgram =
     Logger.timed(
-      new FilteringProgram(query),
+      FilteringProgram(FilterType.FILTER_NAIVE)(query),
       "Generating filtering program",
       Logger.DEBUG
     )
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/filtering/FilteringProgram.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/filtering/FilteringProgram.scala
new file mode 100644
index 0000000..9c8cbaa
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/filtering/FilteringProgram.scala
@@ -0,0 +1,41 @@
+package uk.ac.ox.cs.rsacomb.filtering
+
+import tech.oxfordsemantic.jrdfox.logic.datalog.Rule
+import uk.ac.ox.cs.rsacomb.sparql.ConjunctiveQuery
+import uk.ac.ox.cs.rsacomb.util.Versioned
+
+sealed trait FilterType
+object FilterType {
+  case object FILTER_NAIVE extends FilterType
+  case object FILTER_REVISED_V1 extends FilterType
+}
+
+object FilteringProgram extends Versioned[FilterType] {
+
+  import FilterType._
+
+  type Result = (ConjunctiveQuery) => FilteringProgram
+
+  def apply(t: FilterType): (ConjunctiveQuery) => FilteringProgram =
+    t match {
+      case FILTER_NAIVE      => NaiveFilteringProgram(_)
+      case FILTER_REVISED_V1 => NaiveFilteringProgram(_)
+    }
+}
+
+/** Filtering Program generator
+  *
+  * Handles the conversion of a CQ into a set of logic rules,
+  * representing the filtering step of the RSA combined approach.
+  */
+trait FilteringProgram {
+
+  /** Query from which the filtering program is generated */
+  val query: ConjunctiveQuery
+
+  /** Collection of filtering program rules. */
+  def rules: List[Rule]
+
+  /** Pretty-print filtering rule */
+  override def toString(): String = rules mkString "\n"
+}
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/FilteringProgram.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/filtering/NaiveFilteringProgram.scala
index 06224e7..57898a8 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/FilteringProgram.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/filtering/NaiveFilteringProgram.scala
@@ -1,4 +1,4 @@
-package uk.ac.ox.cs.rsacomb
+package uk.ac.ox.cs.rsacomb.filtering
 
 //import scala.collection.JavaConverters._
 import tech.oxfordsemantic.jrdfox.logic.Datatype
@@ -14,17 +14,14 @@ import uk.ac.ox.cs.rsacomb.suffix.{Forward, Backward}
 import uk.ac.ox.cs.rsacomb.util.{RSA, RDFoxUtil}
 
 /** Factory for [[uk.ac.ox.cs.rsacomb.FilteringProgram FilteringProgram]] */
-object FilteringProgram {
+object NaiveFilteringProgram {
 
   /** Create a new FilteringProgram instance.
     *
     * @param query CQ to be converted into logic rules.
-    * @param constants constants in the original ontology. They will be
-    * used to initialize predicate `rsa:Named`.
     */
   def apply(query: ConjunctiveQuery): FilteringProgram =
-    new FilteringProgram(query)
-
+    new NaiveFilteringProgram(query)
 }
 
 /** Filtering Program generator
@@ -34,7 +31,8 @@ object FilteringProgram {
   *
   * Instances can be created using the companion object.
   */
-class FilteringProgram(query: ConjunctiveQuery) {
+class NaiveFilteringProgram(val query: ConjunctiveQuery)
+    extends FilteringProgram {
 
   /** Extends capabilities of
     * [[tech.oxfordsemantic.jrdfox.logic.datalog.TupleTableAtom TupleTableAtom]]
@@ -306,8 +304,4 @@ class FilteringProgram(query: ConjunctiveQuery) {
         r8a ::: r8b :: r8c :::
         r9 :: List()) map RDFoxUtil.reify
     }
-
-  /** Pretty-print filtering rule */
-  override def toString(): String = rules mkString "\n"
-
 }
diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/util/Versioned.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/util/Versioned.scala
new file mode 100644
index 0000000..aa2a963
--- /dev/null
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/util/Versioned.scala
@@ -0,0 +1,18 @@
+package uk.ac.ox.cs.rsacomb.util
+
+/** Utility to allow hussle free version switching of blocks of code
+  *
+  * This allows for example testing different implementations of a
+  * module or algorithm.
+  */
+trait Versioned[T] {
+
+  /** Type of the returned versioned object */
+  type Result
+
+  /** Returns correct instance of the versioned object
+    *
+    * @param t object uniquely identifing the requested instance.
+    */
+  def apply(t: T): Result
+}
diff --git a/src/test/scala/uk/ac/ox/cs/rsacomb/SuiteAll.scala b/src/test/scala/uk/ac/ox/cs/rsacomb/SuiteAll.scala
index 2162f8c..f32c088 100644
--- a/src/test/scala/uk/ac/ox/cs/rsacomb/SuiteAll.scala
+++ b/src/test/scala/uk/ac/ox/cs/rsacomb/SuiteAll.scala
@@ -2,16 +2,25 @@ package uk.ac.ox.cs.rsacomb
 
 import org.scalatest.Suites
 
-import uk.ac.ox.cs.rsacomb.converter.{OWLAxiomSpec, OWLClassSpec, RDFoxConverterSpec}
-import uk.ac.ox.cs.rsacomb.sparql.{ConjunctiveQueryAnswerSpec, ConjunctiveQuerySpec}
+import uk.ac.ox.cs.rsacomb.converter.{
+  OWLAxiomSpec,
+  OWLClassSpec,
+  RDFoxConverterSpec
+}
+import uk.ac.ox.cs.rsacomb.filtering.NaiveFilteringProgramSpec
+import uk.ac.ox.cs.rsacomb.sparql.{
+  ConjunctiveQueryAnswerSpec,
+  ConjunctiveQuerySpec
+}
 
-class SuiteAll extends Suites (
-    new Ontology1_CanonicalModelSpec,
-    new Ontology2_CanonicalModelSpec,
-    new FilteringProgramSpec,
-    new OWLAxiomSpec,
-    new OWLClassSpec,
-    new RDFoxConverterSpec,
-    new ConjunctiveQueryAnswerSpec,
-    new ConjunctiveQuerySpec
-)
+class SuiteAll
+    extends Suites(
+      new Ontology1_CanonicalModelSpec,
+      new Ontology2_CanonicalModelSpec,
+      new NaiveFilteringProgramSpec,
+      new OWLAxiomSpec,
+      new OWLClassSpec,
+      new RDFoxConverterSpec,
+      new ConjunctiveQueryAnswerSpec,
+      new ConjunctiveQuerySpec
+    )
diff --git a/src/test/scala/uk/ac/ox/cs/rsacomb/FilteringProgramSpecs.scala b/src/test/scala/uk/ac/ox/cs/rsacomb/filtering/FilteringProgramSpecs.scala
index 32ef8da..372b78c 100644
--- a/src/test/scala/uk/ac/ox/cs/rsacomb/FilteringProgramSpecs.scala
+++ b/src/test/scala/uk/ac/ox/cs/rsacomb/filtering/FilteringProgramSpecs.scala
@@ -1,12 +1,14 @@
-package uk.ac.ox.cs.rsacomb
+package uk.ac.ox.cs.rsacomb.filtering
 
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import tech.oxfordsemantic.jrdfox.logic.expression.IRI
-import uk.ac.ox.cs.rsacomb.FilteringProgram
+import uk.ac.ox.cs.rsacomb.filtering.{FilteringProgram, FilterType}
 import uk.ac.ox.cs.rsacomb.sparql.ConjunctiveQuery
 
-object FilteringProgramSpec {
+object NaiveFilteringProgramSpec {
+
+  val naive: FilterType = FilterType.FILTER_NAIVE
 
   val constants =
     List(IRI.create("_:iri1"), IRI.create("_:iri2"), IRI.create("_:iri3"))
@@ -61,31 +63,31 @@ object FilteringProgramSpec {
   """
 }
 
-class FilteringProgramSpec extends AnyFlatSpec with Matchers {
+class NaiveFilteringProgramSpec extends AnyFlatSpec with Matchers {
 
-  import FilteringProgramSpec._
+  import NaiveFilteringProgramSpec._
 
   "CQ 0" should "generate 27 rules and 3 facts" in {
     val cq = ConjunctiveQuery.parse(cq0).get
-    val filter = FilteringProgram(cq)
+    val filter = FilteringProgram(naive)(cq)
     filter.rules should have length 27
   }
 
   "CQ 1" should "generate 15 rules" in {
     val cq = ConjunctiveQuery.parse(cq1).get
-    val filter = FilteringProgram(cq)
+    val filter = FilteringProgram(naive)(cq)
     filter.rules should have length 15
   }
 
   "CQ 2" should "generate 51 rules" in {
     val cq = ConjunctiveQuery.parse(cq2).get
-    val filter = FilteringProgram(cq)
+    val filter = FilteringProgram(naive)(cq)
     filter.rules should have length 51
   }
 
   "BCQ 0" should "generate 46 rules" in {
     val cq = ConjunctiveQuery.parse(bcq0).get
-    val filter = FilteringProgram(cq)
+    val filter = FilteringProgram(naive)(cq)
     filter.rules should have length 43
   }