initial version

1 files changed, 67 insertions, 0 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/constraints/UnaryBottom.java b/src/uk/ac/ox/cs/pagoda/constraints/UnaryBottom.java
new file mode 100644
index 0000000..5339c50
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/constraints/UnaryBottom.java
@@ -0,0 +1,67 @@
+package uk.ac.ox.cs.pagoda.constraints;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Set;
+
+import org.semanticweb.HermiT.model.Atom;
+import org.semanticweb.HermiT.model.AtomicConcept;
+import org.semanticweb.HermiT.model.DLClause;
+import org.semanticweb.HermiT.model.Individual;
+import org.semanticweb.HermiT.model.Term;
+import org.semanticweb.HermiT.model.Variable;
+
+public class UnaryBottom implements BottomStrategy {
+        
+        @Override
+        public Collection<DLClause> process(Collection<DLClause> clauses) {
+                Collection<DLClause> ret = new LinkedList<DLClause>(); 
+                for (DLClause clause: clauses) 
+                        if (clause.getHeadLength() == 0) {
+                                ret.add(DLClause.create(getEmptyHead(pickRepresentative(clause.getBodyAtoms())), clause.getBodyAtoms()));
+                        }
+                        else 
+                                ret.add(clause); 
+                return ret;
+        }
+
+        protected Term pickRepresentative(Atom[] atoms) {
+                Term rep = null; 
+                Set<Variable> vars = new HashSet<Variable>(); 
+                for (Atom atom: atoms) {
+                        atom.getVariables(vars);
+                        for (Variable v: vars)
+                                if (rep == null || ((Variable) rep).getName().compareTo(v.getName()) > 0)
+                                        rep = v;
+                        vars.clear(); 
+                }
+                if (rep != null) return rep; 
+                
+                Set<Individual> inds = new HashSet<Individual>(); 
+                for (Atom atom: atoms) {
+                        atom.getIndividuals(inds);
+                        for (Individual i: inds)
+                                if (rep == null || ((Individual) rep).getIRI().compareTo(i.getIRI()) > 0)
+                                        rep = i;
+                        inds.clear();
+                }
+                
+                return rep;
+        }
+
+        @Override
+        public boolean isBottomRule(DLClause clause) {
+                return clause.getHeadLength() == 1 && clause.getHeadAtom(0).getDLPredicate().equals(AtomicConcept.NOTHING);
+        }
+
+        public Atom[] getEmptyHead(Term t) {
+                return new Atom[] {Atom.create(AtomicConcept.NOTHING, t)};
+        }
+
+        @Override
+        public int getBottomNumber() {
+                return 1;
+        }
+
+}