fr.lirmm.graphik.integraal.forward_chaining.BreadthFirstChase Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of integraal-graal-ruleset-analysis Show documentation
Show all versions of integraal-graal-ruleset-analysis Show documentation
Rule base analysis for InteGraal. This is imported from Graal
The newest version!
/*
* Copyright (C) Inria Sophia Antipolis - Méditerranée / LIRMM
* (Université de Montpellier & CNRS) (2014 - 2017)
*
* Contributors :
*
* Clément SIPIETER
* Mélanie KÖNIG
* Swan ROCHER
* Jean-François BAGET
* Michel LECLÈRE
* Marie-Laure MUGNIER
*
*
* This file is part of Graal
*
*/
public class BreadthFirstChase extends AbstractChase {
private IndexedByBodyPredicatesRuleSet ruleSet;
private AtomSet atomSet;
private InMemoryAtomSet tmpData = new DefaultInMemoryAtomSet();
private Map rulesToCheck;
private Map nextRulesToCheck;
// /////////////////////////////////////////////////////////////////////////
// CONSTRUCTORS
// /////////////////////////////////////////////////////////////////////////
public BreadthFirstChase(Iterator rules, AtomSet atomSet) {
super(new RestrictedChaseRuleApplier());
this.atomSet = atomSet;
this.ruleSet = new IndexedByBodyPredicatesRuleSet();
init(rules);
}
public BreadthFirstChase(Iterable rules, AtomSet atomSet) {
super(new RestrictedChaseRuleApplier());
this.atomSet = atomSet;
this.ruleSet = new IndexedByBodyPredicatesRuleSet();
init(rules.iterator());
}
public BreadthFirstChase(Iterator rules, AtomSet atomSet, RuleApplier ruleApplier) {
super(ruleApplier);
this.atomSet = atomSet;
this.ruleSet = new IndexedByBodyPredicatesRuleSet();
init(rules);
}
public BreadthFirstChase(Iterable rules, AtomSet atomSet, RuleApplier ruleApplier) {
this(rules.iterator(), atomSet, ruleApplier);
}
public BreadthFirstChase(Iterable rules, AtomSet atomSet, Homomorphism solver) {
this(rules, atomSet, new DefaultRuleApplier(solver));
}
public BreadthFirstChase(Iterable rules, AtomSet atomSet, ChaseHaltingCondition haltingCondition) {
this(rules, atomSet, new DefaultRuleApplier(haltingCondition));
}
public BreadthFirstChase(Iterable rules, AtomSet atomSet, Homomorphism solver,
ChaseHaltingCondition haltingCondition) {
this(rules, atomSet, new DefaultRuleApplier(solver, haltingCondition));
}
public BreadthFirstChase(Iterable rules, AtomSet atomSet, RulesCompilation compilation) {
this(rules, atomSet, new DefaultRuleApplierWithCompilation(compilation));
}
public BreadthFirstChase(Iterator rules, AtomSet atomSet, RulesCompilation compilation) {
this(rules, atomSet, new DefaultRuleApplierWithCompilation(compilation));
}
public BreadthFirstChase(Iterable rules, AtomSet atomSet, RulesCompilation compilation,
HomomorphismWithCompilation h) {
this(rules, atomSet, new DefaultRuleApplierWithCompilation(h, compilation));
}
private void init(Iterator rules) {
this.nextRulesToCheck = new TreeMap();
while (rules.hasNext()) {
Rule r = rules.next();
this.ruleSet.add(r);
this.nextRulesToCheck.put(r, atomSet);
}
}
// /////////////////////////////////////////////////////////////////////////
// PUBLICS METHODS
// /////////////////////////////////////////////////////////////////////////
@Override
public void next() throws ChaseException {
this.rulesToCheck = this.nextRulesToCheck;
this.nextRulesToCheck = new TreeMap();
try {
if (!this.rulesToCheck.isEmpty()) {
if (this.getProfiler().isProfilingEnabled()) {
this.getProfiler().start("saturationTime");
}
for (Entry e : this.rulesToCheck.entrySet()) {
String key = null;
Rule rule = e.getKey();
AtomSet data = e.getValue();
if (this.getProfiler().isProfilingEnabled()) {
key = "Rule " + rule.getLabel() + " application time";
this.getProfiler().clear(key);
this.getProfiler().trace(rule.toString());
this.getProfiler().start(key);
}
CloseableIterator it = this.getRuleApplier().delegatedApply(rule, data, this.atomSet);
tmpData.addAll(it); // extension locale
it.close();
if (this.getProfiler().isProfilingEnabled()) {
this.getProfiler().stop(key);
}
}
this.dispatchNewData(this.tmpData); // met à jour les prochaines règles à appliquer et leur champ d'application (cas des linéaires)
this.atomSet.addAll(this.tmpData); // extension globale
this.tmpData.clear();
if (this.getProfiler().isProfilingEnabled()) {
this.getProfiler().stop("saturationTime");
}
}
} catch (Exception e) {
throw new ChaseException("An error occured during saturation step.", e);
}
}
@Override
public boolean hasNext() {
return !this.nextRulesToCheck.isEmpty();
}
// /////////////////////////////////////////////////////////////////////////
// PRIVATE CLASS
// /////////////////////////////////////////////////////////////////////////
protected void dispatchNewData(InMemoryAtomSet newData) throws ChaseException {
CloseableIteratorWithoutException it = newData.iterator();
while (it.hasNext()) {
Atom a = it.next();
Predicate p = a.getPredicate();
for (Rule r : ruleSet.getRulesByBodyPredicate(p)) {
if (linearRuleCheck(r)) {
AtomSet set = nextRulesToCheck.get(r);
if (set == null) {
set = new DefaultInMemoryGraphStore();
nextRulesToCheck.put(r, set);
}
try {
set.add(a);
} catch (AtomSetException e) {
throw new ChaseException("Exception while adding data into a tmp store", e);
}
} else {
nextRulesToCheck.put(r, atomSet);
}
}
}
}
private static boolean linearRuleCheck(Rule r) {
CloseableIteratorWithoutException it = r.getBody().iterator();
if (it.hasNext()) {
it.next();
} else {
return false;
}
return !it.hasNext();
}
}