public WorkingMemory newWorkingMemory(InputStream stream, boolean keepReference)
throws IOException, ClassNotFoundException {
final ObjectInputStreamWithLoader streamWithLoader =
new ObjectInputStreamWithLoader(stream, this.packageClassLoader);
AbstractWorkingMemory workingMemory = (AbstractWorkingMemory) streamWithLoader.readObject();
workingMemory.setRuleBase(this);
return workingMemory;
}
/**
* Add a <code>Package</code> to the network. Iterates through the <code>Package</code> adding
* Each individual <code>Rule</code> to the network. Before update network each referenced <code>
* WorkingMemory</code> is locked.
*
* @param pkg The package to add.
* @throws PackageIntegrationException
* @throws RuleIntegrationException if an error prevents complete construction of the network for
* the <code>Rule</code>.
* @throws FactException
* @throws InvalidPatternException
*/
public void addPackage(final Package newPkg) throws PackageIntegrationException {
newPkg.checkValidity();
final Package pkg = (Package) this.pkgs.get(newPkg.getName());
// Iterate each workingMemory and lock it
// This is so we don't update the Rete network during propagation
for (final Iterator it = this.workingMemories.keySet().iterator(); it.hasNext(); ) {
final AbstractWorkingMemory workingMemory = (AbstractWorkingMemory) it.next();
workingMemory.getLock().lock();
}
if (pkg != null) {
mergePackage(pkg, newPkg);
} else {
this.pkgs.put(newPkg.getName(), newPkg);
}
final Map newGlobals = newPkg.getGlobals();
// Check that the global data is valid, we cannot change the type
// of an already declared global variable
for (final Iterator it = newGlobals.keySet().iterator(); it.hasNext(); ) {
final String identifier = (String) it.next();
final Class type = (Class) newGlobals.get(identifier);
if (this.globals.containsKey(identifier) && !this.globals.get(identifier).equals(type)) {
throw new PackageIntegrationException(pkg);
}
}
this.globals.putAll(newGlobals);
final Rule[] rules = newPkg.getRules();
for (int i = 0; i < rules.length; ++i) {
addRule(rules[i]);
}
this.packageClassLoader.addClassLoader(newPkg.getPackageCompilationData().getClassLoader());
// Iterate each workingMemory and attempt to fire any rules, that were activated as a result
// of the new rule addition. Unlock after fireAllRules();
for (final Iterator it = this.workingMemories.keySet().iterator(); it.hasNext(); ) {
final AbstractWorkingMemory workingMemory = (AbstractWorkingMemory) it.next();
workingMemory.fireAllRules();
workingMemory.getLock().unlock();
}
}
public void removeRule(final String packageName, final String ruleName) {
final Package pkg = (Package) this.pkgs.get(packageName);
final Rule rule = pkg.getRule(ruleName);
// Iterate each workingMemory and lock it
// This is so we don't update the Rete network during propagation
for (final Iterator it = this.workingMemories.keySet().iterator(); it.hasNext(); ) {
final AbstractWorkingMemory workingMemory = (AbstractWorkingMemory) it.next();
workingMemory.getLock().lock();
}
removeRule(rule);
pkg.removeRule(rule);
// Iterate and unlock
for (final Iterator it = this.workingMemories.keySet().iterator(); it.hasNext(); ) {
final AbstractWorkingMemory workingMemory = (AbstractWorkingMemory) it.next();
workingMemory.getLock().unlock();
}
}
public void removePackage(final String packageName) {
final Package pkg = (Package) this.pkgs.get(packageName);
// Iterate each workingMemory and lock it
// This is so we don't update the Rete network during propagation
for (final Iterator it = this.workingMemories.keySet().iterator(); it.hasNext(); ) {
final AbstractWorkingMemory workingMemory = (AbstractWorkingMemory) it.next();
workingMemory.getLock().lock();
}
final Rule[] rules = pkg.getRules();
for (int i = 0; i < rules.length; ++i) {
removeRule(rules[i]);
}
this.packageClassLoader.removeClassLoader(pkg.getPackageCompilationData().getClassLoader());
pkg.clear();
// getting the list of referenced globals
final Set referencedGlobals = new HashSet();
for (final Iterator it = this.pkgs.values().iterator(); it.hasNext(); ) {
final org.drools.rule.Package pkgref = (org.drools.rule.Package) it.next();
if (pkgref != pkg) {
referencedGlobals.addAll(pkgref.getGlobals().keySet());
}
}
// removing globals declared inside the package that are not shared
for (final Iterator it = pkg.getGlobals().keySet().iterator(); it.hasNext(); ) {
final String globalName = (String) it.next();
if (!referencedGlobals.contains(globalName)) {
this.globals.remove(globalName);
}
}
// removing the package itself from the list
this.pkgs.remove(pkg.getName());
// Iterate and unlock
for (final Iterator it = this.workingMemories.keySet().iterator(); it.hasNext(); ) {
final AbstractWorkingMemory workingMemory = (AbstractWorkingMemory) it.next();
workingMemory.getLock().unlock();
}
}
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();
}
}
