Many little changes.

5 files changed, 122 insertions, 5 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/rules/Program.java b/src/uk/ac/ox/cs/pagoda/rules/Program.java
index 85000e3..a0edf85 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/Program.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/Program.java
@@ -316,9 +316,10 @@ protected PredicateDependency dependencyGraph;
         private Atom getAtom(OWLObjectPropertyExpression exp, Variable x, Variable y) {
                 if(exp instanceof OWLObjectProperty)
                         return Atom.create(AtomicRole.create(((OWLObjectProperty) exp).toStringID()), x, y);
-                OWLObjectInverseOf inverseOf;
-                if(exp instanceof OWLObjectInverseOf && (inverseOf =
-                                (OWLObjectInverseOf) exp).getInverse() instanceof OWLObjectProperty)
+                // TODO fixed, test it
+                OWLObjectPropertyExpression inverseOf;
+                if(exp instanceof OWLObjectInverseOf && (inverseOf = (
+                                (OWLObjectInverseOf) exp).getInverse()) instanceof OWLObjectProperty)
                         return Atom.create(AtomicRole.create(((OWLObjectProperty) inverseOf).toStringID()), x, y);
                 return null;
         }
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 dfe1e59..d694b61 100644
--- a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
+++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java
@@ -64,14 +64,14 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima
 
     private Collection<DLClause> overApprox(DLClause clause, DLClause originalClause, Collection<Tuple<Individual>> violationTuples) {
         ArrayList<DLClause> result = new ArrayList<>();
-        for(Tuple<Individual> violationTuple : violationTuples)
+        for(Tuple<Individual> violationTuple : violationTuples) {
             if(getMaxDepth(violationTuple) < maxTermDepth) {
                 result.addAll(getGroundSkolemisation(clause, originalClause, violationTuple));
                 Utility.logDebug("Approximating maximal individual by a constant in rule:" + originalClause);
             }
             else
                 result.addAll(alternativeApproximator.convert(clause, originalClause, null));
-
+        }
 
         return result;
     }
diff --git a/src/uk/ac/ox/cs/pagoda/rules/clauses/Clause.java b/src/uk/ac/ox/cs/pagoda/rules/clauses/Clause.java
new file mode 100644
index 0000000..2adb66b
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/rules/clauses/Clause.java
@@ -0,0 +1,100 @@
+package uk.ac.ox.cs.pagoda.rules.clauses;
+
+public class Clause {
+
+//    public static final String IF = ":-";
+//    public static final String OR = "|";
+//    public static final String AND = ",";
+//
+//    protected final List<List<Atom>> head;
+//    protected final List<Atom> body;
+//
+//    protected Clause(Atom[] headAtoms, Atom[] bodyAtoms) {
+//        this.head = Collections.singletonList(Arrays.asList(headAtoms));
+//        this.body= Arrays.asList(bodyAtoms);
+//    }
+//
+//    protected Clause(String s) {
+//        this.headAtoms = null;
+//        this.bodyAtoms = null;
+//    }
+//
+//    public int getHeadLength() {
+//        return headAtoms.length;
+//    }
+//
+//    public Atom getHeadAtom(int atomIndex) {
+//        return headAtoms[atomIndex];
+//    }
+//
+//    public Atom[] getHeadAtoms() {
+//        return headAtoms.clone();
+//    }
+//
+//    public int getBodyLength() {
+//        return bodyAtoms.length;
+//    }
+//
+//    public Atom getBodyAtom(int atomIndex) {
+//        return bodyAtoms[atomIndex];
+//    }
+//
+//    public Atom[] getBodyAtoms() {
+//        return bodyAtoms.clone();
+//    }
+//
+//    public String toString(Prefixes prefixes) {
+//        StringBuilder buffer = new StringBuilder();
+//        for(int headIndex = 0; headIndex < headAtoms.length; headIndex++) {
+//            if(headIndex != 0)
+//                buffer.append(" ").append(OR).append(" ");
+//            buffer.append(headAtoms[headIndex].toString(prefixes));
+//        }
+//        buffer.append(" ").append(IF).append(" ");
+//        for(int bodyIndex = 0; bodyIndex < bodyAtoms.length; bodyIndex++) {
+//            if(bodyIndex != 0)
+//                buffer.append(AND).append(" ");
+//            buffer.append(bodyAtoms[bodyIndex].toString(prefixes));
+//        }
+//        return buffer.toString();
+//    }
+//
+//    public String toString() {
+//        return toString(Prefixes.STANDARD_PREFIXES);
+//    }
+//
+//    protected static InterningManager<? extends Clause> s_interningManager = new InterningManager<Clause>() {
+//        protected boolean equal(Clause object1, Clause object2) {
+//            if(object1.head.length != object2.headAtoms.length
+//                    || object1.bodyAtoms.length != object2.bodyAtoms.length)
+//                return false;
+//            for(int index = object1.headAtoms.length - 1; index >= 0; --index)
+//                if(object1.headAtoms[index] != object2.headAtoms[index])
+//                    return false;
+//            for(int index = object1.bodyAtoms.length - 1; index >= 0; --index)
+//                if(object1.bodyAtoms[index] != object2.bodyAtoms[index])
+//                    return false;
+//            return true;
+//        }
+//
+//        protected int getHashCode(Clause object) {
+//            int hashCode = 0;
+//            for(int index = object.bodyAtoms.length - 1; index >= 0; --index)
+//                hashCode += object.bodyAtoms[index].hashCode();
+//            for(int index = object.headAtoms.length - 1; index >= 0; --index)
+//                hashCode += object.headAtoms[index].hashCode();
+//            return hashCode;
+//        }
+//    };
+//
+//    /**
+//     * Creates a clause from a string.
+//     *
+//     * @param s
+//     * @return
+//     */
+//    public static Clause create(String s) {
+//        return s_interningManager.intern(new Clause(s));
+//    }
+
+}
diff --git a/src/uk/ac/ox/cs/pagoda/rules/clauses/Conjunction.java b/src/uk/ac/ox/cs/pagoda/rules/clauses/Conjunction.java
new file mode 100644
index 0000000..91bb3e7
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/rules/clauses/Conjunction.java
@@ -0,0 +1,4 @@
+package uk.ac.ox.cs.pagoda.rules.clauses;
+
+public class Conjunction {
+}
diff --git a/src/uk/ac/ox/cs/pagoda/rules/clauses/DLClause.java b/src/uk/ac/ox/cs/pagoda/rules/clauses/DLClause.java
new file mode 100644
index 0000000..7394be0
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/rules/clauses/DLClause.java
@@ -0,0 +1,12 @@
+package uk.ac.ox.cs.pagoda.rules.clauses;
+
+public class DLClause extends Clause {
+
+//    private DLClause(Atom[] headAtoms, Atom[] bodyAtoms) {
+//        super(headAtoms, bodyAtoms);
+//    }
+//
+//    public static DLClause create(Atom[] headAtoms, Atom[] bodyAtoms) {
+//        return s_interningManager.intern(new DLClause(headAtoms, bodyAtoms));
+//    }
+}