public int compare(org.drools.core.spi.Activation o1, org.drools.core.spi.Activation o2) {
int result = o1.getRule().getName().compareTo(o2.getRule().getName());
if (result == 0) {
LeftTuple t1 = o1.getTuple();
LeftTuple t2 = o2.getTuple();
while (result == 0 && t1 != null && t2 != null) {
if (t1.getLastHandle() != null && t2.getLastHandle() != null) {
// can be null for eval, not and exists that have no right input
result = t1.getLastHandle().getId() - t2.getLastHandle().getId();
}
t1 = t1.getParent();
t2 = t2.getParent();
}
}
return result;
}
public static Tuple writeTuple(LeftTuple tuple) {
ProtobufMessages.Tuple.Builder _tb = ProtobufMessages.Tuple.newBuilder();
for (LeftTuple entry = tuple; entry != null; entry = entry.getParent()) {
InternalFactHandle handle = entry.getLastHandle();
if (handle != null) {
// can be null for eval, not and exists that have no right input
_tb.addHandleId(handle.getId());
}
}
return _tb.build();
}
/**
* Fire this item.
*
* @param activation The activation to fire
* @throws org.drools.core.spi.ConsequenceException If an error occurs while attempting to fire
* the consequence.
*/
public synchronized void fireActivation(final Activation activation) throws ConsequenceException {
// We do this first as if a node modifies a fact that causes a recursion
// on an empty pattern
// we need to make sure it re-activates
this.workingMemory.startOperation();
isFiringActivation = true;
try {
final EventSupport eventsupport = (EventSupport) this.workingMemory;
eventsupport
.getAgendaEventSupport()
.fireBeforeActivationFired(activation, this.workingMemory);
if (activation.getActivationGroupNode() != null) {
// We know that this rule will cancel all other activations in the group
// so lets remove the information now, before the consequence fires
final InternalActivationGroup activationGroup =
activation.getActivationGroupNode().getActivationGroup();
activationGroup.removeActivation(activation);
clearAndCancelActivationGroup(activationGroup);
}
activation.setQueued(false);
try {
this.knowledgeHelper.setActivation(activation);
if (log.isTraceEnabled()) {
log.trace("Fire \"{}\" \n{}", activation.getRule().getName(), activation.getTuple());
}
activation.getConsequence().evaluate(this.knowledgeHelper, this.workingMemory);
this.knowledgeHelper.cancelRemainingPreviousLogicalDependencies();
this.knowledgeHelper.reset();
} catch (final Exception e) {
if (this.legacyConsequenceExceptionHandler != null) {
this.legacyConsequenceExceptionHandler.handleException(activation, this.workingMemory, e);
} else if (this.consequenceExceptionHandler != null) {
this.consequenceExceptionHandler.handleException(
activation, this.workingMemory.getKnowledgeRuntime(), e);
} else {
throw new RuntimeException(e);
}
} finally {
if (activation.getFactHandle() != null) {
// update the Activation in the WM
InternalFactHandle factHandle = activation.getFactHandle();
workingMemory
.getEntryPointNode()
.modifyActivation(factHandle, activation.getPropagationContext(), workingMemory);
activation.getPropagationContext().evaluateActionQueue(workingMemory);
}
// if the tuple contains expired events
for (LeftTuple tuple = activation.getTuple(); tuple != null; tuple = tuple.getParent()) {
if (tuple.getLastHandle() == null) {
// can be null for eval, not and exists that have no right input
continue;
}
if (tuple.getLastHandle().isEvent()) {
EventFactHandle handle = (EventFactHandle) tuple.getLastHandle();
// decrease the activation count for the event
handle.decreaseActivationsCount();
// handles "expire" only in stream mode.
if (handle.isExpired()) {
if (handle.getActivationsCount() <= 0) {
// and if no more activations, retract the handle
handle.getEntryPoint().retract(handle);
}
}
}
}
}
eventsupport.getAgendaEventSupport().fireAfterActivationFired(activation, this.workingMemory);
unstageActivations();
} finally {
isFiringActivation = false;
if (mustNotifyHalt) {
mustNotifyHalt = false;
notifyHalt();
}
this.workingMemory.endOperation();
}
}