public int compare(org.drools.core.spi.Activation o1, org.drools.core.spi.Activation o2) {
   int result = o1.getRule().getName().compareTo(o2.getRule().getName());
   if (result == 0) {
     LeftTuple t1 = o1.getTuple();
     LeftTuple t2 = o2.getTuple();
     while (result == 0 && t1 != null && t2 != null) {
       if (t1.getLastHandle() != null && t2.getLastHandle() != null) {
         // can be null for eval, not and exists that have no right input
         result = t1.getLastHandle().getId() - t2.getLastHandle().getId();
       }
       t1 = t1.getParent();
       t2 = t2.getParent();
     }
   }
   return result;
 }
 public static Tuple writeTuple(LeftTuple tuple) {
   ProtobufMessages.Tuple.Builder _tb = ProtobufMessages.Tuple.newBuilder();
   for (LeftTuple entry = tuple; entry != null; entry = entry.getParent()) {
     InternalFactHandle handle = entry.getLastHandle();
     if (handle != null) {
       // can be null for eval, not and exists that have no right input
       _tb.addHandleId(handle.getId());
     }
   }
   return _tb.build();
 }
Exemple #3
0
  /**
   * Fire this item.
   *
   * @param activation The activation to fire
   * @throws org.drools.core.spi.ConsequenceException If an error occurs while attempting to fire
   *     the consequence.
   */
  public synchronized void fireActivation(final Activation activation) throws ConsequenceException {
    // We do this first as if a node modifies a fact that causes a recursion
    // on an empty pattern
    // we need to make sure it re-activates
    this.workingMemory.startOperation();
    isFiringActivation = true;
    try {
      final EventSupport eventsupport = (EventSupport) this.workingMemory;

      eventsupport
          .getAgendaEventSupport()
          .fireBeforeActivationFired(activation, this.workingMemory);

      if (activation.getActivationGroupNode() != null) {
        // We know that this rule will cancel all other activations in the group
        // so lets remove the information now, before the consequence fires
        final InternalActivationGroup activationGroup =
            activation.getActivationGroupNode().getActivationGroup();
        activationGroup.removeActivation(activation);
        clearAndCancelActivationGroup(activationGroup);
      }
      activation.setQueued(false);

      try {

        this.knowledgeHelper.setActivation(activation);
        if (log.isTraceEnabled()) {
          log.trace("Fire \"{}\" \n{}", activation.getRule().getName(), activation.getTuple());
        }
        activation.getConsequence().evaluate(this.knowledgeHelper, this.workingMemory);
        this.knowledgeHelper.cancelRemainingPreviousLogicalDependencies();
        this.knowledgeHelper.reset();
      } catch (final Exception e) {
        if (this.legacyConsequenceExceptionHandler != null) {
          this.legacyConsequenceExceptionHandler.handleException(activation, this.workingMemory, e);
        } else if (this.consequenceExceptionHandler != null) {
          this.consequenceExceptionHandler.handleException(
              activation, this.workingMemory.getKnowledgeRuntime(), e);
        } else {
          throw new RuntimeException(e);
        }
      } finally {
        if (activation.getFactHandle() != null) {
          // update the Activation in the WM
          InternalFactHandle factHandle = activation.getFactHandle();
          workingMemory
              .getEntryPointNode()
              .modifyActivation(factHandle, activation.getPropagationContext(), workingMemory);
          activation.getPropagationContext().evaluateActionQueue(workingMemory);
        }
        // if the tuple contains expired events
        for (LeftTuple tuple = activation.getTuple(); tuple != null; tuple = tuple.getParent()) {
          if (tuple.getLastHandle() == null) {
            // can be null for eval, not and exists that have no right input
            continue;
          }
          if (tuple.getLastHandle().isEvent()) {
            EventFactHandle handle = (EventFactHandle) tuple.getLastHandle();
            // decrease the activation count for the event
            handle.decreaseActivationsCount();
            // handles "expire" only in stream mode.
            if (handle.isExpired()) {
              if (handle.getActivationsCount() <= 0) {
                // and if no more activations, retract the handle
                handle.getEntryPoint().retract(handle);
              }
            }
          }
        }
      }

      eventsupport.getAgendaEventSupport().fireAfterActivationFired(activation, this.workingMemory);

      unstageActivations();
    } finally {
      isFiringActivation = false;
      if (mustNotifyHalt) {
        mustNotifyHalt = false;
        notifyHalt();
      }
      this.workingMemory.endOperation();
    }
  }