fr.lirmm.graphik.integraal.homomorphism.PureHomomorphismImpl 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
* The Backtrack algorithm is efficient for simple facts of small size. This is
* used in particular during query rewriting by PURE to test redundancy (indeed,
* rewritings are small in size).
*
*/
class PureHomomorphismImpl extends AbstractProfilable {
// attribute for homomorphism computation
private ArrayList sourceCopy;
private AtomSet target;
private RulesCompilation compilation;
private ArrayList currentImagesPerLevel;
private ArrayList> availableImage;
private ArrayList currentSubstitutionPerLevel;
private final Substitution initialSubstitution;
// /////////////////////////////////////////////////////////////////////////
// CONSTRUCTOR
// /////////////////////////////////////////////////////////////////////////
public PureHomomorphismImpl(InMemoryAtomSet source, AtomSet target, RulesCompilation compilation, Substitution s) {
this.compilation = compilation;
this.target = target;
this.sourceCopy = new ArrayList();
CloseableIteratorWithoutException it = source.iterator();
while (it.hasNext()) {
// copy source atoms (those of the query)
this.sourceCopy.add(it.next());
}
int size = this.sourceCopy.size();
this.availableImage = new ArrayList>(size);
this.currentImagesPerLevel = new ArrayList(size);
this.currentSubstitutionPerLevel = new ArrayList(size + 1);
for (int i = 0; i < size; ++i) {
this.currentImagesPerLevel.add(-1);
this.availableImage.add(null);
this.currentSubstitutionPerLevel.add(null);
}
this.currentSubstitutionPerLevel.add(null);
this.currentSubstitutionPerLevel.set(0, new TreeMapSubstitution());
this.initialSubstitution = s;
}
// /////////////////////////////////////////////////////////////////////////
// METHODS
// /////////////////////////////////////////////////////////////////////////
/**
* @return true if there exist a homomorphism.
* @throws HomomorphismException
*/
public boolean exist() throws HomomorphismException {
// check if the query is empty
if (sourceCopy == null || !sourceCopy.iterator().hasNext()) {
return true;
}
// /////////////////////////////////////////////////////////////////////
// Initialisation
Profiler profiler = this.getProfiler();
profiler.start("preprocessing time");
boolean res = this.initialiseHomomorphism();
profiler.stop("preprocessing time");
if (res) {
profiler.start("backtracking time");
res = this.backtrack();
profiler.stop("backtracking time");
}
return res;
}
// /////////////////////////////////////////////////////////////////////////
// PRIVATE METHODS
// /////////////////////////////////////////////////////////////////////////
/**
* Initialise attribute for homomorphism
*
* @throws HomomorphismException
*/
protected boolean initialiseHomomorphism() throws HomomorphismException {
try {
return initialiseAvailableImage(this.target);
} catch (IteratorException e) {
throw new HomomorphismException("An errors occurs while initializing available images for homomorphism", e);
}
}
protected boolean backtrack() {
int level = 0;
boolean foundImage;
Substitution nextCandidate;
// can backtrack and all the atom have not been associate
while (level >= 0 && level < this.sourceCopy.size()) {
nextCandidate = this.getNextCandidate(level);
if (nextCandidate != null) {// try next candidate
foundImage = this.checkCurrentCandidate(level, nextCandidate);
if (foundImage) {// need go to the next atom
level++;
}
} else { // need backtrack
level--;
}
}
return !(level < 0);
}
/**
* Return true if the current image of the given atom is possible and
* compute the current substitution else return false
*
*/
protected boolean checkCurrentCandidate(int level, Substitution candidate) {
Substitution newSub = Substitutions.add(currentSubstitutionPerLevel.get(level), candidate);
if (newSub != null) {
this.currentSubstitutionPerLevel.set(level + 1, newSub);
return true;
} else {
return false;
}
}
/**
* Check if the given atom has a next image available if it has : increment
* currentImage for the given atom and return true if has not : reset
* current image for the given atom and return false
*/
protected Substitution getNextCandidate(int level) {
Integer numCurrentImage = this.currentImagesPerLevel.get(level);
numCurrentImage++;
// if there is a next image in the available image
List images = this.availableImage.get(level);
if (numCurrentImage < images.size()) {
this.currentImagesPerLevel.set(level, numCurrentImage);
return images.get(numCurrentImage);
} else {
this.currentImagesPerLevel.set(level, -1);
return null;
}
}
/**
* Found the possible image of each atom in the source fact into the atoms
* of the target fact
*
* @throws IteratorException
*/
protected boolean initialiseAvailableImage(CloseableIterable target) throws IteratorException {
for (int i = 0; i < this.sourceCopy.size(); ++i) {
Atom atomSource = this.sourceCopy.get(i);
List images = new ArrayList();
CloseableIterator it = target.iterator();
while (it.hasNext()) {
Atom im = it.next();
for (Substitution s : this.compilation.homomorphism(atomSource, im, this.initialSubstitution)) {
images.add(s);
}
}
it.close();
if (images.isEmpty()) {
return false;
}
this.availableImage.set(i, images);
}
return true;
}
}