Example #1
0
  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();
    }
  }
Example #2
0
  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();
    }
  }