/**
* Update the program with the name given as argument using the data provided in the stream. This
* method will first calculate the difference between the previous version of the program and the
* new version of the program. It then updates the program in the database and notifies the engine
* of all removed and added rules.
*
* @throws IOException in case the stream cannot be read
* @throws SailException in case the program already exists
* @throws ParseException in case the program cannot be parsed
*/
public void updateProgram(String name, InputStream data)
throws IOException, SailException, ParseException {
KWRLProgramParserBase parser = new KWRLProgramParser(getValueFactory(), data);
Program p = parser.parseProgram();
p.setName(name);
updateProgram(p);
}
/**
* Add a program to the reasoner. The program is persisted to the database and the reasoning
* engine is notified of the added rules and immediately calculates the inferences. Inferencing in
* this case is synchronous, so the method only returns when the first round of reasoning is
* completed for all added rules.
*
* <p>If a program with this name already exists, a SailException is thrown. To update existing
* programs, please use updateProgram().
*
* @param program the program data in KWRL syntax
* @throws SailException in case the program already exists
*/
public void addProgram(Program program) throws SailException {
// store program in the database
try {
KiWiReasoningConnection connection = persistence.getConnection();
try {
// should not throw an exception and the program should have a database ID afterwards
connection.storeProgram(program);
connection.commit();
} finally {
connection.close();
}
} catch (SQLException ex) {
throw new SailException("cannot store program in database", ex);
}
engine.loadPrograms();
// now add all added rules to the reasoner
for (Rule rule : program.getRules()) {
engine.notifyAddRule(rule);
}
}
/**
* Update the program given as argument. This method will first calculate the difference between
* the previous version of the program and the new version of the program. It then updates the
* program in the database and notifies the engine of all removed and added rules.
*
* @param program the updated version of the program
* @throws SailException in case a database error occurs
*/
public void updateProgram(Program program) throws SailException {
Set<Rule> added = new HashSet<Rule>();
Set<Rule> removed = new HashSet<Rule>();
try {
KiWiReasoningConnection connection = persistence.getConnection();
try {
// load old version of program and calculate difference
Program old = connection.loadProgram(program.getName());
if (old != null) {
for (Rule r : old.getRules()) {
if (!program.getRules().contains(r)) {
removed.add(r);
}
}
for (Rule r : program.getRules()) {
if (!old.getRules().contains(r)) {
added.add(r);
}
}
}
// store program in the database
connection.updateProgram(program);
connection.commit();
} finally {
connection.close();
}
} catch (SQLException ex) {
throw new SailException("cannot store program in database", ex);
}
engine.loadPrograms();
// if rules have been removed, clean up
if (removed.size() > 0) {
engine.notifyRemoveRules();
}
// now add all added rules to the reasoner
for (Rule rule : added) {
engine.notifyAddRule(rule);
}
}
