fr.lirmm.graphik.integraal.rulesetanalyser.graph.MarkedVariableSet 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 }
* @author Swan Rocher
*
*/
public class MarkedVariableSet {
private LinkedList markedRuleSet;
private Map> map;
private Queue markedPosition;
public static class MarkedRule {
public MarkedRule(Rule rule) {
this.rule = rule;
this.markedVars = new TreeSet();
}
public Rule rule;
public Set markedVars;
}
// /////////////////////////////////////////////////////////////////////////
// CONSTRUCTOR
// /////////////////////////////////////////////////////////////////////////
public MarkedVariableSet(Iterable rules) {
this.markedPosition = new LinkedList();
this.markedRuleSet = new LinkedList();
for (Rule r : rules) {
this.markedRuleSet.add(new MarkedRule(r));
}
map = new HashMap>();
process();
}
// /////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS
// /////////////////////////////////////////////////////////////////////////
public Collection getMarkedRuleCollection() {
return this.markedRuleSet;
}
// /////////////////////////////////////////////////////////////////////////
// PRIVATE METHODS
// /////////////////////////////////////////////////////////////////////////
private void process() {
firstStep();
secondStep();
}
/**
* for each rule Ri and for each variable v occuring in its body, if v does
* not occur in all atoms of its head, mark (each occurrence of) v in its
* body;
*/
private void firstStep() {
for (MarkedRule markedRule : this.markedRuleSet) {
// put rule in the map
CloseableIteratorWithoutException it = markedRule.rule.getHead().iterator();
while (it.hasNext()) {
Atom atom = it.next();
Predicate p = atom.getPredicate();
LinkedList set = map.get(p);
if (set == null) {
set = new LinkedList();
map.put(p, set);
}
set.add(markedRule);
}
// mark the rule
testRule(markedRule);
}
}
private void testRule(MarkedRule mrule) {
Set bodyVars = mrule.rule.getBody().getVariables();
for (Term v : bodyVars) {
CloseableIteratorWithoutException it = mrule.rule.getHead().iterator();
while (it.hasNext()) {
Atom a = it.next();
if (!a.getTerms().contains(v)) {
mark(v, mrule);
}
}
}
}
private void mark(Term v, MarkedRule mrule) {
if (!mrule.markedVars.contains(v)) {
mrule.markedVars.add(v);
CloseableIteratorWithoutException it = mrule.rule.getBody().iterator();
while (it.hasNext()) {
Atom a = it.next();
int i = 0;
for (Term t : a) {
if (v.equals(t)) {
this.markedPosition.add(new PredicatePosition(a
.getPredicate(), i));
}
++i;
}
}
}
}
/**
* apply until a fixpoint is reached: for each rule Ri, if a marked variable
* v appears at position p[k] in its body, then for each rule Rj (including
* i = j) and for each variable x appearing at position p[k] in the head of
* Rj, mark each occurence of x in the body of Rj.
*/
private void secondStep() {
LinkedList mrList;
PredicatePosition mpos;
Term v;
while (!this.markedPosition.isEmpty()) {
mpos = this.markedPosition.poll();
mrList = this.map.get(mpos.predicate);
if (mrList != null) {
for (MarkedRule mr : mrList) {
CloseableIteratorWithoutException it = mr.rule.getHead().iterator();
while (it.hasNext()) {
Atom a = it.next();
if (a.getPredicate().equals(mpos.predicate)) {
v = a.getTerm(mpos.position);
if (v.isVariable()) {
this.mark(v, mr);
}
}
}
}
}
}
}
}