DatalogEngine.java

package org.semanticweb.HermiT.datalog;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.semanticweb.HermiT.existentials.ExistentialExpansionStrategy;
import org.semanticweb.HermiT.model.Atom;
import org.semanticweb.HermiT.model.AtomicRole;
import org.semanticweb.HermiT.model.Concept;
import org.semanticweb.HermiT.model.DLClause;
import org.semanticweb.HermiT.model.DLOntology;
import org.semanticweb.HermiT.model.DataRange;
import org.semanticweb.HermiT.model.Term;
import org.semanticweb.HermiT.model.Variable;
import org.semanticweb.HermiT.tableau.DLClauseEvaluator;
import org.semanticweb.HermiT.tableau.ExtensionManager;
import org.semanticweb.HermiT.tableau.InterruptFlag;
import org.semanticweb.HermiT.tableau.Node;
import org.semanticweb.HermiT.tableau.Tableau;

public final class DatalogEngine {
    protected final InterruptFlag m_interruptFlag;
    protected final DLOntology m_dlOntology;
    protected final Map<Term,Node> m_termsToNodes;
    protected final Map<Node,Term> m_nodesToTerms;
    protected final Map<Term,Set<Term>> m_termsToEquivalenceClasses;
    protected final Map<Term,Term> m_termsToRepresentatives;
    protected ExtensionManager m_extensionManager;
    
    public DatalogEngine(DLOntology dlOntology) {
        for (DLClause dlClause : dlOntology.getDLClauses())
            if (dlClause.getHeadLength()>1)
                throw new IllegalArgumentException("The supplied DL ontology contains rules with disjunctive heads.");
        m_interruptFlag=new InterruptFlag(0);
        m_dlOntology=dlOntology;
        m_termsToNodes=new HashMap<Term,Node>();
        m_nodesToTerms=new HashMap<Node,Term>();
        m_termsToEquivalenceClasses=new HashMap<Term,Set<Term>>();
        m_termsToRepresentatives=new HashMap<Term,Term>();
    }
    public void interrupt() {
        m_interruptFlag.interrupt();
    }
    public boolean materialize() {
        if (m_extensionManager==null) {
            m_termsToNodes.clear();
            m_nodesToTerms.clear();
            m_termsToEquivalenceClasses.clear();
            m_termsToRepresentatives.clear();
            Tableau tableau=new Tableau(m_interruptFlag,null,NullExistentialExpansionStrategy.INSTANCE,false,m_dlOntology,null,new HashMap<String,Object>());
            Set<Atom> noAtoms=Collections.emptySet();
            tableau.isSatisfiable(true,false,noAtoms,noAtoms,noAtoms,noAtoms,m_termsToNodes,null,null);
            for (Map.Entry<Term,Node> entry : m_termsToNodes.entrySet())
                m_nodesToTerms.put(entry.getValue(),entry.getKey());
            m_extensionManager=tableau.getExtensionManager();
            Node node=tableau.getFirstTableauNode();
            while (node!=null) {
                Term term=m_nodesToTerms.get(node);
                Term canonicalTerm=m_nodesToTerms.get(node.getCanonicalNode());
                Set<Term> equivalenceClass=m_termsToEquivalenceClasses.get(canonicalTerm);
                if (equivalenceClass==null) {
                    equivalenceClass=new HashSet<Term>();
                    m_termsToEquivalenceClasses.put(canonicalTerm,equivalenceClass);
                }
                if (!term.equals(canonicalTerm))
                    m_termsToEquivalenceClasses.put(term,equivalenceClass);
                equivalenceClass.add(term);
                m_termsToRepresentatives.put(term,canonicalTerm);
                node=node.getNextTableauNode();
            }
        }
        return !m_extensionManager.containsClash();
    }
    public DLOntology getDLOntology() {
        return m_dlOntology;
    }
    public Set<Term> getEquivalenceClass(Term term) {
        return m_termsToEquivalenceClasses.get(term);
    }
    public Term getRepresentative(Term term) {
        return m_termsToRepresentatives.get(term);
    }
    
    protected static class NullExistentialExpansionStrategy implements ExistentialExpansionStrategy {
        public static final ExistentialExpansionStrategy INSTANCE=new NullExistentialExpansionStrategy();

        public void initialize(Tableau tableau) {
        }
        public void additionalDLOntologySet(DLOntology additionalDLOntology) {
        }
        public void additionalDLOntologyCleared() {
        }
        public void clear() {
        }
        public boolean expandExistentials(boolean finalChance) {
            return false;
        }
        public void assertionAdded(Concept concept,Node node,boolean isCore) {
        }
        public void assertionAdded(DataRange dataRange,Node node,boolean isCore) {
        }
        public void assertionCoreSet(Concept concept,Node node) {
        }
        public void assertionCoreSet(DataRange dataRange,Node node) {
        }
        public void assertionRemoved(Concept concept,Node node,boolean isCore) {
        }
        public void assertionRemoved(DataRange dataRange,Node node,boolean isCore) {
        }
        public void assertionAdded(AtomicRole atomicRole,Node nodeFrom,Node nodeTo,boolean isCore) {
        }
        public void assertionCoreSet(AtomicRole atomicRole,Node nodeFrom,Node nodeTo) {
        }
        public void assertionRemoved(AtomicRole atomicRole,Node nodeFrom,Node nodeTo,boolean isCore) {
        }
        public void nodesMerged(Node mergeFrom,Node mergeInto) {
        }
        public void nodesUnmerged(Node mergeFrom,Node mergeInto) {
        }
        public void nodeStatusChanged(Node node) {
        }
        public void nodeInitialized(Node node) {
        }
        public void nodeDestroyed(Node node) {
        }
        public void branchingPointPushed() {
        }
        public void backtrack() {
        }
        public void modelFound() {
        }
        public boolean isDeterministic() {
            return true;
        }
        public boolean isExact() {
            return true;
        }
        public void dlClauseBodyCompiled(List<DLClauseEvaluator.Worker> workers,DLClause dlClause,List<Variable> variables,Object[] valuesBuffer,boolean[] coreVariables) {
        }
    }
}