public void update(
org.drools.FactHandle factHandle,
final Object object,
final long mask,
final Activation activation)
throws FactException {
try {
this.ruleBase.readLock();
this.lock.lock();
this.wm.startOperation();
this.ruleBase.executeQueuedActions();
InternalFactHandle handle = (InternalFactHandle) factHandle;
// the handle might have been disconnected, so reconnect if it has
if (handle.isDisconnected()) {
handle = this.objectStore.reconnect(factHandle);
}
final Object originalObject = handle.getObject();
if (handle.getEntryPoint() != this) {
throw new IllegalArgumentException(
"Invalid Entry Point. You updated the FactHandle on entry point '"
+ handle.getEntryPoint().getEntryPointId()
+ "' instead of '"
+ getEntryPointId()
+ "'");
}
final ObjectTypeConf typeConf = this.typeConfReg.getObjectTypeConf(this.entryPoint, object);
// only needed if we maintain tms, but either way we must get it before we do the retract
int status = -1;
if (typeConf.isTMSEnabled()) {
status = handle.getEqualityKey().getStatus();
}
if (handle.getId() == -1
|| object == null
|| (handle.isEvent() && ((EventFactHandle) handle).isExpired())) {
// the handle is invalid, most likely already retracted, so return and we cannot assert a
// null object
return;
}
if (activation != null) {
// release resources so that they can be GC'ed
activation.getPropagationContext().releaseResources();
}
if (originalObject != object
|| !AssertBehaviour.IDENTITY.equals(
this.ruleBase.getConfiguration().getAssertBehaviour())) {
this.objectStore.removeHandle(handle);
// set anyway, so that it updates the hashCodes
handle.setObject(object);
this.objectStore.addHandle(handle, object);
}
if (typeConf.isTMSEnabled()) {
// the hashCode and equality has changed, so we must update the
// EqualityKey
EqualityKey key = handle.getEqualityKey();
key.removeFactHandle(handle);
TruthMaintenanceSystem tms = wm.getTruthMaintenanceSystem();
// If the equality key is now empty, then remove it
if (key.isEmpty()) {
tms.remove(key);
}
// now use an existing EqualityKey, if it exists, else create a new one
key = tms.get(object);
if (key == null) {
key = new EqualityKey(handle, status);
tms.put(key);
} else {
key.addFactHandle(handle);
}
handle.setEqualityKey(key);
}
this.handleFactory.increaseFactHandleRecency(handle);
Rule rule = activation == null ? null : activation.getRule();
final PropagationContext propagationContext =
new PropagationContextImpl(
this.wm.getNextPropagationIdCounter(),
PropagationContext.MODIFICATION,
rule,
(activation == null) ? null : activation.getTuple(),
handle,
this.wm.agenda.getActiveActivations(),
this.wm.agenda.getDormantActivations(),
entryPoint,
mask);
this.entryPointNode.modifyObject(handle, propagationContext, typeConf, this.wm);
propagationContext.evaluateActionQueue(this.wm);
this.wm.workingMemoryEventSupport.fireObjectUpdated(
propagationContext, factHandle, originalObject, object, this.wm);
this.wm.executeQueuedActions();
if (rule == null) {
// This is not needed for internal WM actions as the firing rule will unstage
this.wm.getAgenda().unstageActivations();
}
} finally {
this.wm.endOperation();
this.lock.unlock();
this.ruleBase.readUnlock();
}
}
protected FactHandle insert(
final Object object,
final boolean dynamic,
boolean logical,
final Rule rule,
final Activation activation)
throws FactException {
if (object == null) {
// you cannot assert a null object
return null;
}
try {
this.wm.startOperation();
ObjectTypeConf typeConf = this.typeConfReg.getObjectTypeConf(this.entryPoint, object);
if (logical && !typeConf.isTMSEnabled()) {
enableTMS(object, typeConf);
}
InternalFactHandle handle = null;
if (this.wm.isSequential()) {
handle = createHandle(object, typeConf);
insert(handle, object, rule, activation, typeConf);
return handle;
}
try {
this.ruleBase.readLock();
this.lock.lock();
// check if the object already exists in the WM
handle = this.objectStore.getHandleForObject(object);
if (typeConf.isTMSEnabled()) {
EqualityKey key;
TruthMaintenanceSystem tms = wm.getTruthMaintenanceSystem();
if (handle == null) {
// lets see if the object is already logical asserted
key = tms.get(object);
} else {
// Object is already asserted, so check and possibly correct its
// status and then return the handle
key = handle.getEqualityKey();
if (key.getStatus() == EqualityKey.STATED) {
// return null as you cannot justify a stated object.
return handle;
}
if (!logical) {
// this object was previously justified, so we have to override it to stated
key.setStatus(EqualityKey.STATED);
tms.removeLogicalDependencies(handle);
} else {
// this was object is already justified, so just add new logical dependency
tms.addLogicalDependency(
handle, activation, activation.getPropagationContext(), rule);
}
return handle;
}
// At this point we know the handle is null
if (key == null) {
handle = createHandle(object, typeConf);
key = createEqualityKey(handle);
tms.put(key);
if (!logical) {
key.setStatus(EqualityKey.STATED);
} else {
key.setStatus(EqualityKey.JUSTIFIED);
tms.addLogicalDependency(
handle, activation, activation.getPropagationContext(), rule);
}
} else if (!logical) {
if (key.getStatus() == EqualityKey.JUSTIFIED) {
// Its previous justified, so switch to stated and remove logical dependencies
final InternalFactHandle justifiedHandle = key.getFactHandle();
tms.removeLogicalDependencies(justifiedHandle);
if (this.wm.discardOnLogicalOverride) {
// override, setting to new instance, and return
// existing handle
key.setStatus(EqualityKey.STATED);
handle = key.getFactHandle();
if (AssertBehaviour.IDENTITY.equals(
this.ruleBase.getConfiguration().getAssertBehaviour())) {
// as assertMap may be using an "identity"
// equality comparator,
// we need to remove the handle from the map,
// before replacing the object
// and then re-add the handle. Otherwise we may
// end up with a leak.
this.objectStore.updateHandle(handle, object);
}
return handle;
} else {
// override, then instantiate new handle for
// assertion
key.setStatus(EqualityKey.STATED);
handle = createHandle(object, typeConf);
handle.setEqualityKey(key);
key.addFactHandle(handle);
}
} else {
handle = createHandle(object, typeConf);
key.addFactHandle(handle);
handle.setEqualityKey(key);
}
} else {
if (key.getStatus() == EqualityKey.JUSTIFIED) {
// only add as logical dependency if this wasn't previously stated
tms.addLogicalDependency(
key.getFactHandle(), activation, activation.getPropagationContext(), rule);
return key.getFactHandle();
} else {
// You cannot justify a previously stated equality equal object, so return null
return null;
}
}
} else {
if (handle != null) {
return handle;
}
handle = createHandle(object, typeConf);
}
// if the dynamic parameter is true or if the user declared the fact type with the meta tag:
// @propertyChangeSupport
if (dynamic || typeConf.isDynamic()) {
addPropertyChangeListener(handle, dynamic);
}
insert(handle, object, rule, activation, typeConf);
} finally {
this.lock.unlock();
this.ruleBase.readUnlock();
}
return handle;
} finally {
this.wm.endOperation();
}
}
