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);
    }
  }
Esempio n. 2
0
 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);
       }
     }
   }
 }
Esempio n. 3
0
  /**
   * 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);
      }
    }
  }
Esempio n. 5
0
  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();
    }
  }
Esempio n. 6
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();
    }
  }
Esempio n. 7
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();
    }
  }