public static void readTruthMaintenanceSystem(MarshallerReaderContext context)
throws IOException {
ObjectInputStream stream = context.stream;
TruthMaintenanceSystem tms = context.wm.getTruthMaintenanceSystem();
while (stream.readShort() == PersisterEnums.EQUALITY_KEY) {
int status = stream.readInt();
int factHandleId = stream.readInt();
InternalFactHandle handle = (InternalFactHandle) context.handles.get(factHandleId);
// ObjectTypeConf state is not marshalled, so it needs to be re-determined
ObjectTypeConf typeConf =
context
.wm
.getObjectTypeConfigurationRegistry()
.getObjectTypeConf(context.wm.getEntryPoint(), handle.getObject());
if (!typeConf.isTMSEnabled()) {
typeConf.enableTMS();
}
EqualityKey key = new EqualityKey(handle, status);
handle.setEqualityKey(key);
while (stream.readShort() == PersisterEnums.FACT_HANDLE) {
factHandleId = stream.readInt();
handle = (InternalFactHandle) context.handles.get(factHandleId);
key.addFactHandle(handle);
handle.setEqualityKey(key);
}
tms.put(key);
}
}
public void dispose() {
if (dynamicFacts != null) {
// first we check for facts that were inserted into the working memory
// using the old API and setting a per instance dynamic flag and remove the
// session from the listeners list in the bean
for (InternalFactHandle handle : dynamicFacts) {
removePropertyChangeListener(handle, false);
}
dynamicFacts = null;
}
for (ObjectTypeConf conf : this.typeConfReg.values()) {
// then, we check if any of the object types were configured using the
// @propertyChangeSupport annotation, and clean them up
if (conf.isDynamic() && conf.isSupportsPropertyChangeListeners()) {
// it is enough to iterate the facts on the concrete object type nodes
// only, as the facts will always be in their concrete object type nodes
// even if they were also asserted into higher level OTNs as well
ObjectTypeNode otn = conf.getConcreteObjectTypeNode();
final ObjectHashSet memory =
((ObjectTypeNodeMemory) this.getInternalWorkingMemory().getNodeMemory(otn)).memory;
Iterator it = memory.iterator();
for (ObjectEntry entry = (ObjectEntry) it.next();
entry != null;
entry = (ObjectEntry) it.next()) {
InternalFactHandle handle = (InternalFactHandle) entry.getValue();
removePropertyChangeListener(handle, false);
}
}
}
}
/**
* TMS will be automatically enabled when the first logical insert happens.
*
* <p>We will take all the already asserted objects of the same type and initialize the equality
* map.
*
* @param object the logically inserted object.
* @param conf the type's configuration.
*/
private void enableTMS(Object object, ObjectTypeConf conf) {
final Rete source = this.ruleBase.getRete();
final ClassObjectType cot = new ClassObjectType(object.getClass());
final Map<ObjectType, ObjectTypeNode> map = source.getObjectTypeNodes(EntryPoint.DEFAULT);
final ObjectTypeNode node = map.get(cot);
final ObjectHashSet memory = ((ObjectTypeNodeMemory) this.wm.getNodeMemory(node)).memory;
// All objects of this type that are already there were certainly stated,
// since this method call happens at the first logical insert, for any given type.
org.drools.core.util.Iterator it = memory.iterator();
for (Object obj = it.next(); obj != null; obj = it.next()) {
org.drools.core.util.ObjectHashSet.ObjectEntry holder =
(org.drools.core.util.ObjectHashSet.ObjectEntry) obj;
InternalFactHandle handle = (InternalFactHandle) holder.getValue();
if (handle != null) {
EqualityKey key = createEqualityKey(handle);
key.setStatus(EqualityKey.STATED);
this.wm.getTruthMaintenanceSystem().put(key);
}
}
// Enable TMS for this type.
conf.enableTMS();
}
public static void readFactHandles(MarshallerReaderContext context, ObjectStore objectStore)
throws IOException, ClassNotFoundException {
ObjectInputStream stream = context.stream;
InternalWorkingMemory wm = context.wm;
int size = stream.readInt();
// load the handles
InternalFactHandle[] handles = new InternalFactHandle[size];
for (int i = 0; i < size; i++) {
InternalFactHandle handle = readFactHandle(context);
context.handles.put(handle.getId(), handle);
handles[i] = handle;
if (handle.getObject() != null) {
objectStore.addHandle(handle, handle.getObject());
}
readRightTuples(handle, context);
}
readLeftTuples(context); // object store
if (stream.readBoolean()) {
readLeftTuples(context); // activation fact handles
}
// add handles to object type nodes
for (InternalFactHandle factHandle : handles) {
Object object = factHandle.getObject();
EntryPoint ep =
((InternalWorkingMemoryEntryPoint) factHandle.getEntryPoint()).getEntryPoint();
ObjectTypeConf typeConf =
((InternalWorkingMemoryEntryPoint) factHandle.getEntryPoint())
.getObjectTypeConfigurationRegistry()
.getObjectTypeConf(ep, object);
ObjectTypeNode[] cachedNodes = typeConf.getObjectTypeNodes();
for (int i = 0, length = cachedNodes.length; i < length; i++) {
ObjectHashSet set = (ObjectHashSet) wm.getNodeMemory(cachedNodes[i]);
set.add(factHandle, false);
}
}
}
public void retract(
final org.drools.FactHandle factHandle,
final boolean removeLogical,
final boolean updateEqualsMap,
final Rule rule,
final Activation activation)
throws FactException {
if (factHandle == null) {
throw new IllegalArgumentException("FactHandle cannot be null ");
}
try {
this.ruleBase.readLock();
this.lock.lock();
this.wm.startOperation();
this.ruleBase.executeQueuedActions();
InternalFactHandle handle = (InternalFactHandle) factHandle;
if (handle.getId() == -1) {
// can't retract an already retracted handle
return;
}
// the handle might have been disconnected, so reconnect if it has
if (handle.isDisconnected()) {
handle = this.objectStore.reconnect(handle);
}
if (handle.getEntryPoint() != this) {
throw new IllegalArgumentException(
"Invalid Entry Point. You updated the FactHandle on entry point '"
+ handle.getEntryPoint().getEntryPointId()
+ "' instead of '"
+ getEntryPointId()
+ "'");
}
final Object object = handle.getObject();
final ObjectTypeConf typeConf = this.typeConfReg.getObjectTypeConf(this.entryPoint, object);
if (typeConf.isSupportsPropertyChangeListeners()) {
removePropertyChangeListener(handle, true);
}
if (activation != null) {
// release resources so that they can be GC'ed
activation.getPropagationContext().releaseResources();
}
final PropagationContext propagationContext =
new PropagationContextImpl(
this.wm.getNextPropagationIdCounter(),
PropagationContext.RETRACTION,
rule,
(activation == null) ? null : activation.getTuple(),
handle,
this.wm.agenda.getActiveActivations(),
this.wm.agenda.getDormantActivations(),
this.entryPoint);
this.entryPointNode.retractObject(handle, propagationContext, typeConf, this.wm);
if (typeConf.isTMSEnabled()) {
TruthMaintenanceSystem tms = wm.getTruthMaintenanceSystem();
// Update the equality key, which maintains a list of stated
// FactHandles
final EqualityKey key = handle.getEqualityKey();
// Its justified so attempt to remove any logical dependencies
// for
// the handle
if (key.getStatus() == EqualityKey.JUSTIFIED) {
tms.removeLogicalDependencies(handle);
}
key.removeFactHandle(handle);
handle.setEqualityKey(null);
// If the equality key is now empty, then remove it
if (key.isEmpty()) {
tms.remove(key);
}
}
propagationContext.evaluateActionQueue(this.wm);
this.wm.workingMemoryEventSupport.fireObjectRetracted(
propagationContext, handle, object, this.wm);
this.objectStore.removeHandle(handle);
this.handleFactory.destroyFactHandle(handle);
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();
}
}
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();
}
}