Deleted unused classes.

1 files changed, 123 insertions, 124 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java
index 2143b03..d96c747 100644
--- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java
@@ -17,95 +17,98 @@ import java.util.Set;
 
 public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
 
+        private Set<DLClause> disjunctiveRules = new HashSet<DLClause>();
+        private Variable X = Variable.create("X"), Y = Variable.create("Y");
+        private String bottomTrackingProgram = null;
+        
         public TrackingRuleEncoderDisjVar1(UpperDatalogProgram program, BasicQueryEngine store) {
                 super(program, store);
         }
         
-        private Set<DLClause> disjunctiveRules = new HashSet<DLClause>();
-
         @Override
         public boolean encodingRules() {
                 if (super.encodingRules()) {
                         processDisjunctiveRules();
-                        return true; 
+                        return true;
                 }
-                return false; 
+                return false;
         }
         
         @Override
         protected void encodingRule(DLClause clause) {
                 if (currentQuery.isBottom()) {
 //                      super.encodingRule(clause);
-                        encodingBottomQueryClause(clause); 
-                        return ; 
+                        encodingBottomQueryClause(clause);
+                        return;
                 }
-                
+
                 DLClause original = program.getCorrespondingClause(clause);
                 if (original.getHeadLength() <= 1) {
                         super.encodingRule(clause);
-                } 
+                }
                 else {
                         if (!DLClauseHelper.hasSubsetBodyAtoms(clause, original))
                                 super.encodingRule(clause);
                         addDisjunctiveRule(original);
                 }
-                        
+
         }
-        
 
         private void processDisjunctiveRules() {
                 for (DLClause clause: disjunctiveRules)
                         encodingDisjunctiveRule(clause);
         }
-        
+
         private Atom getAuxiliaryAtom(Atom headAtom) {
-                DLPredicate p = headAtom.getDLPredicate(); 
+                DLPredicate p = headAtom.getDLPredicate();
                 if (p instanceof AtLeast || p instanceof AtLeast) {
-                        return Atom.create(generateAuxiliaryRule((AtLeast) p, true), headAtom.getArgument(0)); 
+                        return Atom.create(generateAuxiliaryRule((AtLeast) p, true), headAtom.getArgument(0));
                 }
-                if (p instanceof AtomicConcept) 
-                        return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0)); 
-                if (p instanceof AtomicRole) 
+                if(p instanceof AtomicConcept)
+                        return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0));
+                if(p instanceof AtomicRole)
                         return Atom.create(generateAuxiliaryRule((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Equality || p instanceof AnnotatedEquality) 
-                        return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); 
-                if (p instanceof Inequality) 
-                        return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1)); 
+                if(p instanceof Equality || p instanceof AnnotatedEquality)
+                        return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
+                if(p instanceof Inequality)
+                        return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1));
 
                 return null;
         }
 
         private Atom getTrackingAtom(Atom headAtom) {
-                DLPredicate p = headAtom.getDLPredicate(); 
+                DLPredicate p = headAtom.getDLPredicate();
                 if (p instanceof AtLeast) {
-                        p = Normalisation.toAtLeastConcept((AtLeast) p); 
-                        return Atom.create(getTrackingDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom.getArgument(0)); 
+                        p = Normalisation.toAtLeastConcept((AtLeast) p);
+                        return Atom.create(getTrackingDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom
+                                        .getArgument(0));
                 }
-                if (p instanceof AtomicConcept) 
+                if(p instanceof AtomicConcept)
                         return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0));
-                if (p instanceof AtomicRole) 
+                if(p instanceof AtomicRole)
                         return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Equality || p instanceof AnnotatedEquality) 
-                        return Atom.create(getTrackingDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); 
-                if (p instanceof Inequality) 
+                if(p instanceof Equality || p instanceof AnnotatedEquality)
+                        return Atom.create(getTrackingDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
+                if(p instanceof Inequality)
                         return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
 
                 return null;
         }
 
         private Atom getGapAtom(Atom headAtom) {
-                DLPredicate p = headAtom.getDLPredicate(); 
+                DLPredicate p = headAtom.getDLPredicate();
                 if (p instanceof AtLeast) {
-                        p = Normalisation.toAtLeastConcept((AtLeast) p); 
-                        return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom.getArgument(0)); 
+                        p = Normalisation.toAtLeastConcept((AtLeast) p);
+                        return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom
+                                        .getArgument(0));
                 }
-                if (p instanceof AtomicConcept) 
+                if(p instanceof AtomicConcept)
                         return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0));
-                if (p instanceof AtomicRole) 
+                if(p instanceof AtomicRole)
                         return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
-                if (p instanceof Equality || p instanceof AnnotatedEquality) 
-                        return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); 
-                if (p instanceof Inequality) 
+                if(p instanceof Equality || p instanceof AnnotatedEquality)
+                        return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1));
+                if(p instanceof Inequality)
                         return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1));
                 if (p instanceof DatatypeRestriction)
                         return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0));
@@ -115,71 +118,71 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
 
         private void encodingDisjunctiveRule(DLClause clause) {
                 int headLength = clause.getHeadLength();
-                
+
                 Atom[] auxAtoms = new Atom[headLength];
                 for (int i = 0; i < headLength; ++i)
                         auxAtoms[i] = getAuxiliaryAtom(clause.getHeadAtom(i));
-                
+
                 Atom[] trackingAtoms = new Atom[headLength];
                 for (int i = 0; i < headLength; ++i)
                         trackingAtoms[i] = getTrackingAtom(clause.getHeadAtom(i));
-                
+
                 Atom[] gapAtoms = new Atom[headLength];
                 for (int i = 0; i < headLength; ++i)
                         gapAtoms[i] = getGapAtom(clause.getHeadAtom(i));
-                
+
                 Atom[] bodyAtoms = clause.getBodyAtoms();
-                
+
                 LinkedList<Atom> newHeadAtoms = new LinkedList<Atom>();
-                DLPredicate selected = AtomicConcept.create(getSelectedPredicate()); 
+                DLPredicate selected = AtomicConcept.create(getSelectedPredicate());
                 newHeadAtoms.add(Atom.create(selected, getIndividual4GeneralRule(clause)));
-                
+
                 for (Atom atom: bodyAtoms) {
                         Atom newAtom = Atom.create(
-                                        getTrackingDLPredicate(atom.getDLPredicate()), 
+                                        getTrackingDLPredicate(atom.getDLPredicate()),
                                         DLClauseHelper.getArguments(atom));
                         newHeadAtoms.add(newAtom);
                 }
 
                 DLClause newClause;
-                int index; 
+                int index;
                 for (int j = 0; j < headLength; ++j) {
                         Atom[] newBodyAtoms = new Atom[headLength * 2 + bodyAtoms.length];
-                        index = 0; 
+                        index = 0;
                         for (int i = 0; i < headLength; ++i, ++index)
-                                newBodyAtoms[index] = gapAtoms[i]; 
+                                newBodyAtoms[index] = gapAtoms[i];
                         for (int i = 0; i < headLength; ++i, ++index)
                                 if (i != j)
                                         newBodyAtoms[index] = auxAtoms[i];
-                                else 
-                                        newBodyAtoms[index] = trackingAtoms[i]; 
-                        
+                                else
+                                        newBodyAtoms[index] = trackingAtoms[i];
+
                         for (int i = 0; i < bodyAtoms.length; ++i, ++index)
-                                newBodyAtoms[index] = bodyAtoms[i]; 
-                        
+                                newBodyAtoms[index] = bodyAtoms[i];
+
                         for (Atom atom: newHeadAtoms) {
-                                newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms); 
+                                newClause = DLClause.create(new Atom[]{atom}, newBodyAtoms);
                                 addTrackingClause(newClause);
                         }
                 }
         }
         
         private void addTrackingClause(DLClause clause) {
-                trackingClauses.add(clause); 
+                trackingClauses.add(clause);
         }
 
         private void addDisjunctiveRule(DLClause clause) {
                 disjunctiveRules.add(clause);
         }
-        
+
         private DLPredicate getAuxPredicate(DLPredicate p) {
                 if (p instanceof AtLeastConcept) {
                         StringBuilder builder = new StringBuilder(
                                         Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p));
-                        builder.append("_AUXa").append(currentQuery.getQueryID()); 
-                        return AtomicConcept.create(builder.toString()); 
+                        builder.append("_AUXa").append(currentQuery.getQueryID());
+                        return AtomicConcept.create(builder.toString());
                 }
-                
+
                 return getDLPredicate(p, "_AUXa" + currentQuery.getQueryID());
         }
 
@@ -188,120 +191,118 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
         }
 
         private DLPredicate generateAuxiliaryRule(AtLeast p1, boolean withAux) {
-                AtLeastConcept p = Normalisation.toAtLeastConcept(p1); 
-                
-                int num = p.getNumber(); 
-                Variable[] Ys = new Variable[num]; 
+                AtLeastConcept p = Normalisation.toAtLeastConcept(p1);
+
+                int num = p.getNumber();
+                Variable[] Ys = new Variable[num];
                 if (num > 1)
-                        for (int i = 0; i < num; ++i) 
+                        for(int i = 0; i < num; ++i)
                                 Ys[i] = Variable.create("Y" + (i + 1));
-                else 
-                        Ys[0] = Y; 
-                
-                Collection<Atom> expandedAtom = new LinkedList<Atom>(); 
-                Collection<Atom> representativeAtom = new LinkedList<Atom>(); 
+                else
+                        Ys[0] = Y;
+
+                Collection<Atom> expandedAtom = new LinkedList<Atom>();
+                Collection<Atom> representativeAtom = new LinkedList<Atom>();
                 if (p.getOnRole() instanceof AtomicRole) {
-                        AtomicRole r = (AtomicRole) p.getOnRole(); 
-                        for (int i = 0; i < num; ++i) 
+                        AtomicRole r = (AtomicRole) p.getOnRole();
+                        for(int i = 0; i < num; ++i)
                                 expandedAtom.add(Atom.create(r, X, Ys[i]));
-                        representativeAtom.add(Atom.create(r, X, Ys[0])); 
+                        representativeAtom.add(Atom.create(r, X, Ys[0]));
                 }
                 else {
-                        AtomicRole r = ((InverseRole) p.getOnRole()).getInverseOf(); 
-                        for (int i = 0; i < num; ++i) 
+                        AtomicRole r = ((InverseRole) p.getOnRole()).getInverseOf();
+                        for(int i = 0; i < num; ++i)
                                 expandedAtom.add(Atom.create(r, Ys[i], X));
-                        representativeAtom.add(Atom.create(r, Ys[0], X)); 
+                        representativeAtom.add(Atom.create(r, Ys[0], X));
                 }
-                
+
                 if (num > 1) {
-                        representativeAtom.add(Atom.create(Inequality.INSTANCE, Ys[0], Ys[1])); 
+                        representativeAtom.add(Atom.create(Inequality.INSTANCE, Ys[0], Ys[1]));
                 }
                 for (int i = 0; i < num; ++i)
                         for (int j = i + 1; j < num; ++j)
-                                expandedAtom.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j])); 
-                
+                                expandedAtom.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j]));
+
                 if (!p.getToConcept().equals(AtomicConcept.THING)) {
-                        AtomicConcept c; 
-                        if (p.getToConcept() instanceof AtomicConcept) 
+                        AtomicConcept c;
+                        if(p.getToConcept() instanceof AtomicConcept)
                                 c = (AtomicConcept) p.getToConcept();
                         else {
                                 c = OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept());
                         }
                         for (int i = 0; i < num; ++i)
-                                expandedAtom.add(Atom.create(c, Ys[i])); 
+                                expandedAtom.add(Atom.create(c, Ys[i]));
                         representativeAtom.add(Atom.create(c, Ys[0]));
                 }
 
                 AtomicConcept ac = AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct(p));
-                DLPredicate trackingPredicate = getTrackingDLPredicate(ac); 
-                DLPredicate gapPredicate = getGapDLPredicate(ac); 
+                DLPredicate trackingPredicate = getTrackingDLPredicate(ac);
+                DLPredicate gapPredicate = getGapDLPredicate(ac);
                 DLPredicate auxPredicate = withAux ? getAuxPredicate(p) : null;
-                
+
                 for (Atom atom: representativeAtom) {
-                        Atom[] bodyAtoms = new Atom[expandedAtom.size() + 1]; 
+                        Atom[] bodyAtoms = new Atom[expandedAtom.size() + 1];
                         if (atom.getArity() == 1)
                                 bodyAtoms[0] = Atom.create(getTrackingDLPredicate(atom.getDLPredicate()), atom.getArgument(0));
-                        else 
+                        else
                                 bodyAtoms[0] = Atom.create(getTrackingDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1));
-                        int i = 0; 
+                        int i = 0;
                         for (Atom bodyAtom: expandedAtom)
-                                bodyAtoms[++i] = bodyAtom;  
+                                bodyAtoms[++i] = bodyAtom;
                         addTrackingClause(DLClause.create(new Atom[] {Atom.create(trackingPredicate, X)}, bodyAtoms));
-                        
-                        bodyAtoms = new Atom[expandedAtom.size() + 1]; 
+
+                        bodyAtoms = new Atom[expandedAtom.size() + 1];
                         if (atom.getArity() == 1)
                                 bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0));
-                        else 
+                        else
                                 bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1));
-                        i = 0; 
+                        i = 0;
                         for (Atom bodyAtom: expandedAtom)
-                                bodyAtoms[++i] = bodyAtom;  
+                                bodyAtoms[++i] = bodyAtom;
                         addTrackingClause(DLClause.create(new Atom[] {Atom.create(gapPredicate, X)}, bodyAtoms));
-                        
+
                         if (withAux) {
-                                bodyAtoms = new Atom[expandedAtom.size() + 1]; 
+                                bodyAtoms = new Atom[expandedAtom.size() + 1];
                                 bodyAtoms[0] = getAuxiliaryAtom(atom);
-                                i = 0; 
+                                i = 0;
                                 for (Atom bodyAtom: expandedAtom)
-                                        bodyAtoms[++i] = bodyAtom;  
+                                        bodyAtoms[++i] = bodyAtom;
                                 addTrackingClause(DLClause.create(new Atom[] {Atom.create(auxPredicate, X)}, bodyAtoms));
                         }
                 }
-                
+
                 return withAux ? auxPredicate : trackingPredicate;
         }
 
         private DLPredicate generateAuxiliaryRule(AtomicRole p) {
-                if (currentQuery.isBottom()) 
+                if(currentQuery.isBottom())
                         return getTrackingDLPredicate(p);
-                
-                DLPredicate ret = getAuxPredicate(p); 
+
+                DLPredicate ret = getAuxPredicate(p);
                 Atom[] headAtom = new Atom[] {Atom.create(ret, X, Y)};
 
                 addTrackingClause(
-                                DLClause.create(headAtom, new Atom[] {Atom.create(getTrackingDLPredicate(p), X, Y)})); 
+                                DLClause.create(headAtom, new Atom[]{Atom.create(getTrackingDLPredicate(p), X, Y)}));
                 addTrackingClause(
-                                DLClause.create(headAtom, new Atom[] {Atom.create(getTrackingBottomDLPredicate(p), X, Y)})); 
-                
-                return ret; 
+                                DLClause.create(headAtom, new Atom[]{Atom.create(getTrackingBottomDLPredicate(p), X, Y)}));
+
+                return ret;
         }
-        
-        private Variable X = Variable.create("X"), Y = Variable.create("Y"); 
 
         private DLPredicate generateAuxiliaryRule(AtomicConcept p) {
                 if (currentQuery.isBottom())
-                        return getTrackingDLPredicate(p); 
-                
-                DLPredicate ret = getAuxPredicate(p); 
-                Atom[] headAtom = new Atom[] {Atom.create(ret, X)}; 
+                        return getTrackingDLPredicate(p);
+
+                DLPredicate ret = getAuxPredicate(p);
+                Atom[] headAtom = new Atom[]{Atom.create(ret, X)};
                 addTrackingClause(
-                                DLClause.create(headAtom, 
-                                                new Atom[] { Atom.create(getTrackingDLPredicate(p), X)})); 
+                                DLClause.create(headAtom,
+                                                                new Atom[]{Atom.create(getTrackingDLPredicate(p), X)}));
                 addTrackingClause(
-                                DLClause.create(headAtom, 
+                                DLClause.create(headAtom,
                                                 new Atom[] { Atom.create(getTrackingBottomDLPredicate(p), X)}));
-                
-                return ret; 
+
+                return ret;
         }
 
         private DLPredicate generateAuxiliaryRule(Equality instance) {
@@ -309,20 +310,18 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
         }
 
         private DLPredicate generateAuxiliaryRule(Inequality instance) {
-                return generateAuxiliaryRule(AtomicRole.create(Namespace.INEQUALITY)); 
+                return generateAuxiliaryRule(AtomicRole.create(Namespace.INEQUALITY));
         }
-        
+
         @Override
         public String getTrackingProgram() {
                 StringBuilder sb = getTrackingProgramBody();
                 if (currentQuery.isBottom())
-                        sb.append(getBottomTrackingProgram()); 
-                sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText()); 
-                return sb.toString(); 
+                        sb.append(getBottomTrackingProgram());
+                sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText());
+                return sb.toString();
         }
 
-        private String bottomTrackingProgram = null; 
-
         private String getBottomTrackingProgram() {
                 if (bottomTrackingProgram != null) return bottomTrackingProgram.replace("_tn", getTrackingPredicate(""));  
                 
@@ -350,7 +349,7 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap {
 //              for (Atom tAtom: clause.getHeadAtoms()) {
 //                      for (int i = 0; i < tAtom.getArity(); ++i)
 //                              if ((t = tAtom.getArgument(i)) instanceof Individual) 
-//                                      if (((Individual) t).getIRI().startsWith(OverApproxExist.skolemisedIndividualPrefix))
+//                                      if (((Individual) t).getIRI().startsWith(OverApproxExist.SKOLEMISED_INDIVIDUAL_PREFIX))
 //                                              clause = program.getCorrespondingClause(clause);                                
 //              }