From 0ccecbe8718c90201700897ee33e9082b7bfce50 Mon Sep 17 00:00:00 2001
From: Federico Igne <federico.igne@cs.ox.ac.uk>
Date: Wed, 15 Jul 2020 17:48:11 +0100
Subject: Rename source code directory structure

---
 .../scala/example/RDFoxClassExprConverter.scala    | 119 ---------------------
 1 file changed, 119 deletions(-)
 delete mode 100644 src/main/scala/example/RDFoxClassExprConverter.scala

(limited to 'src/main/scala/example/RDFoxClassExprConverter.scala')

diff --git a/src/main/scala/example/RDFoxClassExprConverter.scala b/src/main/scala/example/RDFoxClassExprConverter.scala
deleted file mode 100644
index 3e60461..0000000
--- a/src/main/scala/example/RDFoxClassExprConverter.scala
+++ /dev/null
@@ -1,119 +0,0 @@
-package rsacomb
-
-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.{AtomicFormula, Bind,BuiltinFunctionCall}
-import tech.oxfordsemantic.jrdfox.logic.{Atom, Predicate, Term, Variable, Literal, Individual}
-
-import rsacomb.SkolemStrategy
-import rsacomb.RDFoxRuleShards
-
-object RDFoxClassExprConverter {
-
-  def apply(term : Term, skolem : SkolemStrategy) : RDFoxClassExprConverter =
-	new RDFoxClassExprConverter(term, skolem)
-
-  def apply(term : Term) : RDFoxClassExprConverter =
-	new RDFoxClassExprConverter(term, SkolemStrategy.None)
-
-  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, skolem : SkolemStrategy)
-  extends OWLClassExpressionVisitorEx[RDFoxRuleShards]
-{
-
-  // OWLClass
-  override
-  def visit(expr : OWLClass) : RDFoxRuleShards = {
-    val name = expr.getIRI.getIRIString
-    val atom = List(Atom.create(Predicate.create(name), term))
-    RDFoxRuleShards(atom,List())
-  }
-
-  // OWLObjectIntersectionOf
-  override
-  def visit(expr : OWLObjectIntersectionOf) : RDFoxRuleShards = {
-    val visitor = new RDFoxClassExprConverter(term,skolem)
-    // 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,skolem)
-    // 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.getIRIString
-    val atom = List(Atom.create(
-      Predicate.create("owl:sameAs"), term, Individual.create(ind)
-    ))
-    RDFoxRuleShards(atom,List())
-  }
-
-  // OWLObjectSomeValuesFrom
-  override
-  def visit(expr : OWLObjectSomeValuesFrom) : RDFoxRuleShards = {
-    // TODO: variables needs to be handled at visitor level. Hardcoding
-    // the name of the varibles might lead to errors for complex cases.
-    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.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)
-	}
-    val classVisitor = new RDFoxClassExprConverter(term1,skolem)
-    val classResult = expr.getFiller.accept(classVisitor)
-    val propertyVisitor = new RDFoxPropertyExprConverter(term, term1, skolem)
-    val propertyResult = expr.getProperty.accept(propertyVisitor)
-    RDFoxRuleShards(
-      classResult.res ++ propertyResult,
-      fun ++ classResult.ext
-    )
-  }
-
-  // OWLObjectMaxCardinality
-  override
-  def visit(expr : OWLObjectMaxCardinality) : RDFoxRuleShards = {
-    // TODO: again, no hardcoded variables
-    val vars = List(Variable.create("y"),Variable.create("z"))
-    val classResult = RDFoxClassExprConverter.merge(
-      vars.map(new RDFoxClassExprConverter(_,skolem))
-          .map(expr.getFiller.accept(_))
-    )
-    val propertyResult = 
-      vars.map(new RDFoxPropertyExprConverter(term,_,skolem))
-          .map(expr.getProperty.accept(_))
-          .flatten
-    RDFoxRuleShards(
-      List(Atom.create(Predicate.create("owl:sameAs"),vars(0),vars(1))),
-      classResult.res ++ propertyResult
-    )
-  }
-	
-  def doDefault(expr : OWLClassExpression) : RDFoxRuleShards =
-    RDFoxRuleShards(List(),List())
-
-} // class RDFoxClassExprConverter
-- 
cgit v1.2.3