Deleted unused classes.

2 files changed, 43 insertions, 43 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
index 20ae53b..3f1ed7e 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
@@ -1,13 +1,14 @@
 package uk.ac.ox.cs.pagoda.rules.approximators;
 
 import org.semanticweb.HermiT.model.*;
-import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
 import uk.ac.ox.cs.pagoda.multistage.MultiStageUpperProgram;
 import uk.ac.ox.cs.pagoda.rules.ExistConstantApproximator;
 import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
 import uk.ac.ox.cs.pagoda.util.tuples.TupleBuilder;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 
 /**
  * Approximates existential rules through a limited form of Skolemisation.
@@ -24,7 +25,6 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima
     private final int maxTermDepth;
     private final TupleDependentApproximator alternativeApproximator;
     private final SkolemTermsManager skolemTermsManager;
-    private Map<AnswerTupleID, Integer> mapIndividualsToDepth;
 
     public LimitedSkolemisationApproximator(int maxTermDepth) {
         this(maxTermDepth, new ExistConstantApproximator());
@@ -33,7 +33,6 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima
     public LimitedSkolemisationApproximator(int maxTermDepth, TupleDependentApproximator alternativeApproximator) {
         this.maxTermDepth = maxTermDepth;
         this.alternativeApproximator = alternativeApproximator;
-        this.mapIndividualsToDepth = new HashMap<>();
         this.skolemTermsManager = SkolemTermsManager.getInstance();
     }
 
@@ -144,7 +143,7 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima
     public int getMaxDepth(Tuple<Individual> violationTuple) {
         int maxDepth = 0;
         for (Individual individual : violationTuple)
-            maxDepth = Integer.max(maxDepth, skolemTermsManager.getDepth(individual));
+            maxDepth = Integer.max(maxDepth, skolemTermsManager.getDepthOf(individual));
 
         return maxDepth;
     }
diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java
index 0c12a27..368c014 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java
@@ -12,38 +12,56 @@ import java.util.Map;
  */
 public class SkolemTermsManager {
 
-    public static final String skolemisedIndividualPrefix = Namespace.PAGODA_ANONY + "individual";
+    public static final String SKOLEMISED_INDIVIDUAL_PREFIX = Namespace.PAGODA_ANONY + "individual";
 
     private static SkolemTermsManager skolemTermsManager;
 
-    private int individualCounter = 0;
-    private Map<DLClause, Integer> termNumber = new HashMap<>();
-    private Map<Individual, Integer> mapIndividualToDepth = new HashMap<>();
+    private int termsCounter = 0;
+    private Map<DLClause, Integer> mapClauseToId = new HashMap<>();
+    private Map<Individual, Integer> mapTermToDepth = new HashMap<>();
     private int dependenciesCounter = 0;
 
-    // replace with hashcode. in case of collision you get only a different upper bound model.
-    // or, better, use perfect hashing (i.e. devise an ad-hoc hash function without collisions)
+    // TODO replace with hashcode. in case of collision you get only a different upper bound model.
+    // TODO you can use a cash.
     private Map<Tuple<Individual>, Integer> mapDependencyToId = new HashMap<>();
 
+    private SkolemTermsManager() {
+    }
+
+    public static int indexOfSkolemisedIndividual(Atom atom) {
+        Term t;
+        for(int index = 0; index < atom.getArity(); ++index) {
+            t = atom.getArgument(index);
+            if(t instanceof Individual && ((Individual) t).getIRI().contains(SKOLEMISED_INDIVIDUAL_PREFIX))
+                return index;
+        }
+        return -1;
+    }
+
+    public static SkolemTermsManager getInstance() {
+        if(skolemTermsManager == null) skolemTermsManager = new SkolemTermsManager();
+        return skolemTermsManager;
+    }
+
     /**
      * Get a fresh Individual, unique for the clause, the offset and the dependency.
      * */
     public Individual getFreshIndividual(DLClause originalClause, int offset, Tuple<Individual> dependency) {
-        if (!termNumber.containsKey(originalClause)) {
-            termNumber.put(originalClause, individualCounter);
-            individualCounter += noOfExistential(originalClause);
+        if(!mapClauseToId.containsKey(originalClause)) {
+            mapClauseToId.put(originalClause, termsCounter);
+            termsCounter += noOfExistential(originalClause);
         }
         if (!mapDependencyToId.containsKey(dependency)) {
             mapDependencyToId.put(dependency, dependenciesCounter++);
         }
 
-        String termId = termNumber.get(originalClause) + offset + "_" + mapDependencyToId(dependency);
-        Individual newIndividual = Individual.create(skolemisedIndividualPrefix + termId);
+        String termId = mapClauseToId.get(originalClause) + offset + "_" + mapDependencyToId(dependency);
+        Individual newIndividual = Individual.create(SKOLEMISED_INDIVIDUAL_PREFIX + termId);
 
         int depth = 0;
         for (Individual individual : dependency)
             depth = Integer.max(depth, mapIndividualToDepth(individual));
-        mapIndividualToDepth.put(newIndividual, depth);
+        mapTermToDepth.put(newIndividual, depth);
 
         return newIndividual;
     }
@@ -52,14 +70,14 @@ public class SkolemTermsManager {
      * Get a fresh Individual, unique for the clause and the offset.
      * */
     public Individual getFreshIndividual(DLClause originalClause, int offset) {
-        if (!termNumber.containsKey(originalClause)) {
-            termNumber.put(originalClause, individualCounter);
-            individualCounter += noOfExistential(originalClause);
+        if(!mapClauseToId.containsKey(originalClause)) {
+            mapClauseToId.put(originalClause, termsCounter);
+            termsCounter += noOfExistential(originalClause);
         }
 
-        String termId = "" + termNumber.get(originalClause) + offset;
-        Individual newIndividual = Individual.create(skolemisedIndividualPrefix + termId);
-        mapIndividualToDepth.put(newIndividual, 0);
+        String termId = "" + mapClauseToId.get(originalClause) + offset;
+        Individual newIndividual = Individual.create(SKOLEMISED_INDIVIDUAL_PREFIX + termId);
+        mapTermToDepth.put(newIndividual, 0);
 
         return newIndividual;
     }
@@ -69,7 +87,7 @@ public class SkolemTermsManager {
      * <p>
      * The term must have been generated by this manager.
      * */
-    public int getDepth(Individual individual) {
+    public int getDepthOf(Individual individual) {
         return mapIndividualToDepth(individual);
     }
 
@@ -77,24 +95,7 @@ public class SkolemTermsManager {
      * Get the number of individuals generated by this manager.
      * */
     public int getNumberOfSkolemisedIndividual() {
-        return mapIndividualToDepth.keySet().size();
-        }
-
-    public static int indexOfSkolemisedIndividual(Atom atom) {
-        Term t;
-        for (int index = 0; index < atom.getArity(); ++index) {
-            t = atom.getArgument(index);
-            if (t instanceof Individual && ((Individual) t).getIRI().contains(skolemisedIndividualPrefix)) return index;
-        }
-        return -1;
-    }
-
-    private SkolemTermsManager() {
-    }
-
-    public static SkolemTermsManager getInstance() {
-        if (skolemTermsManager == null) skolemTermsManager = new SkolemTermsManager();
-        return skolemTermsManager;
+        return mapTermToDepth.keySet().size();
     }
 
     private int mapDependencyToId(Tuple<Individual> dependency) {
@@ -103,7 +104,7 @@ public class SkolemTermsManager {
     }
 
     private int mapIndividualToDepth(Individual dependency) {
-        if (mapIndividualToDepth.containsKey(dependency)) return mapIndividualToDepth.get(dependency);
+        if(mapTermToDepth.containsKey(dependency)) return mapTermToDepth.get(dependency);
         else return 0;
     }