示例#1
0
  /**
   * forward an execute request a rule identified by its unique key
   *
   * @param key a string key identifying the rule instance to be fired
   * @param recipient the recipient of the method from which execution of the rule was triggered or
   *     null if it was a static method
   * @param args the arguments of the method from which execution of the rule was triggered
   */
  public static void execute(String key, Object recipient, Object[] args) throws ExecuteException {
    boolean enabled = isTriggeringEnabled();
    if (!enabled) {
      // we don't trigger code while we are doing rule housekeeping
      return;
    }

    // disable triggering until we get into actual rule code

    disableTriggersInternal();

    try {
      Rule rule = ruleKeyMap.get(key);
      if (Transformer.isVerbose()) {
        System.out.println("Rule.execute called for " + key);
      }

      // if the key is no longer present it just means the rule has been decommissioned so return
      if (rule == null) {
        if (Transformer.isVerbose()) {
          System.out.println("Rule.execute for decommissioned key " + key);
        }
        return;
      }

      rule.execute(recipient, args);
    } finally {
      // restore the status quo -- we must have been enabled if we got to this method
      enableTriggers();
    }
  }
示例#2
0
  public Object interpret(HelperAdapter helper) throws ExecuteException {
    Object recipientValue = null;
    try {
      if (recipient != null) {
        recipientValue = recipient.interpret(helper);
        if (recipientValue == null) {
          throw new ExecuteException(
              "MethodExpression.interpret : null recipient for method "
                  + token.getText()
                  + getPos());
        }
      }
      int argCount = arguments.size();

      Object[] argValues = new Object[argCount];
      for (int i = 0; i < argCount; i++) {
        argValues[i] = arguments.get(i).interpret(helper);
      }
      // execute setTriggering directly rather than via reflection
      // that way rule code switch off triggering for a rule injected
      // into code used by Method.invoke()
      if (method.equals(setTriggeringMethod)) {
        boolean setting = (Boolean) argValues[0];
        if (setting) {
          Rule.enableTriggers();
        } else {
          Rule.disableTriggers();
        }
        return true;
      }
      // we have to enable triggers whenever we call out to a method in case it contians a trigger
      // point
      // TODO - do we do this if the method is a built-in? i.e. if the target is an instance of the
      // helper class
      // TODO - this breaks the user disable option so fix it!
      Rule.enableTriggersInternal();
      return method.invoke(recipientValue, argValues);
    } catch (InvocationTargetException e) {
      Throwable th = e.getCause();
      if (th instanceof ExecuteException) {
        throw (ExecuteException) th;
      } else {
        throw new ExecuteException(
            "MethodExpression.interpret : exception invoking method " + token.getText() + getPos(),
            th);
      }
    } catch (ExecuteException e) {
      throw e;
    } catch (Exception e) {
      throw new ExecuteException(
          "MethodExpression.interpret : exception invoking method " + token.getText() + getPos(),
          e);
    } finally {
      // disable triggers again
      Rule.disableTriggersInternal();
    }
  }