/**
* Constructor.
*
* @param engine the engine which is calling this interpreter
* @param goal the query to be satisfied
* @param clauses the set of code blocks needed to implement this goal
* @param isTop true if this is a top level call from the outside iterator, false means it is an
* internal generator call which means we don't need to insert an tabled call
*/
public LPInterpreter(
LPBRuleEngine engine, TriplePattern goal, List<RuleClauseCode> clauses, boolean isTop) {
this.engine = engine;
this.goal = goal; // Used for debug only
// Construct dummy top environemnt which is a call into the clauses for this goal
if (engine.getDerivationLogging()) {
envFrame = new EnvironmentFrameWithDerivation(RuleClauseCode.returnCodeBlock);
} else {
envFrame = new EnvironmentFrame(RuleClauseCode.returnCodeBlock);
}
envFrame.allocate(RuleClauseCode.MAX_PERMANENT_VARS);
HashMap<Node, Node> mappedVars = new HashMap<>();
envFrame.pVars[0] = argVars[0] = standardize(goal.getSubject(), mappedVars);
envFrame.pVars[1] = argVars[1] = standardize(goal.getPredicate(), mappedVars);
envFrame.pVars[2] = argVars[2] = standardize(goal.getObject(), mappedVars);
if (engine.getDerivationLogging()) {
((EnvironmentFrameWithDerivation) envFrame).initDerivationRecord(argVars);
}
if (clauses != null && clauses.size() > 0) {
if (isTop && engine.getRuleStore().isTabled(goal)) {
setupTabledCall(0, 0);
// setupClauseCall(0, 0, clauses);
} else {
setupClauseCall(0, 0, clauses, goal.isGround());
}
}
// TripleMatchFrame tmFrame = new TripleMatchFrame(this);
topTMFrame = new TopLevelTripleMatchFrame(this, goal);
topTMFrame.linkTo(cpFrame);
topTMFrame.setContinuation(0, 0);
cpFrame = topTMFrame;
}
public void addTriple(Entity subject, String predicat, Entity Object) {
TriplePattern j = new TriplePattern();
j.setSubject(subject);
j.setPredicate(predicat);
j.setObject(Object);
TripleList.add(j);
}
/**
* Extended find interface used in situations where the implementator may or may not be able to
* answer the complete query. It will attempt to answer the pattern but if its answers are not
* known to be complete then it will also pass the request on to the nested Finder to append more
* results.
*
* @param pattern a TriplePattern to be matched against the data
* @param continuation either a Finder or a normal Graph which will be asked for additional match
* results if the implementor may not have completely satisfied the query.
*/
@Override
public ExtendedIterator<Triple> findWithContinuation(TriplePattern pattern, Finder continuation) {
if (graph == null) return new NullIterator<Triple>();
if (continuation == null) {
return graph.find(pattern.asTripleMatch());
} else {
return graph.find(pattern.asTripleMatch()).andThen(continuation.find(pattern));
}
}
/** Return a dereferenced copy of a triple. */
public static Triple deref(TriplePattern t) {
if (t == null) return null;
return new Triple(deref(t.getSubject()), deref(t.getPredicate()), deref(t.getObject()));
}
/** Return true if the given pattern occurs somewhere in the find sequence. */
@Override
public boolean contains(TriplePattern pattern) {
return graph.contains(pattern.getSubject(), pattern.getPredicate(), pattern.getObject());
}
/**
* Basic pattern lookup interface.
*
* @param pattern a TriplePattern to be matched against the data
* @return a ClosableIterator over all Triples in the data set that match the pattern
*/
@Override
public ExtendedIterator<Triple> find(TriplePattern pattern) {
if (graph == null) return new NullIterator<Triple>();
return graph.find(pattern.asTripleMatch());
}
public void addTriple(TriplePattern i) {
TriplePattern j = new TriplePattern();
j.setSubject(i.getSubject());
j.setPredicate(i.getPredicate());
j.setObject(i.getObject());
j.setPropertySet(i.getPropertySet());
j.setHasSetOfProperties(i.getHasSetOfProperties());
TripleList.add(j);
}
