Esempio n. 1
0
  public void execute(Map<String, Object> context, List<String[]> args) {
    BuildContext buildContext = (BuildContext) context.get("BuildContext");

    if (args.size() != 0) {
      String[] a = args.get(0);
      String name = a[0].trim();
      String leftInput = a[1].trim();
      String rightInput = a[2].trim();

      Class cls = null;

      LeftTupleSource leftTupleSource;
      if (leftInput.startsWith("mock")) {
        leftTupleSource = new MockTupleSource(buildContext.getNextId());
      } else {
        leftTupleSource = (LeftTupleSource) context.get(leftInput);
      }

      ObjectSource rightObjectSource;
      if (rightInput.startsWith("mock")) {
        String type = rightInput.substring(5, rightInput.length() - 1);
        try {
          cls = reteTesterHelper.getTypeResolver().resolveType(type);
        } catch (ClassNotFoundException e) {
          throw new RuntimeException(e);
        }
        rightObjectSource = new MockObjectSource(buildContext.getNextId());
      } else {
        rightObjectSource = (ObjectSource) context.get(rightInput);
        ObjectSource source = rightObjectSource;
        while (!(source instanceof ObjectTypeNode)) {
          source = source.getParentObjectSource();
        }
        cls = ((ClassObjectType) ((ObjectTypeNode) source).getObjectType()).getClassType();
      }

      List<BetaNodeFieldConstraint> list = new ArrayList<BetaNodeFieldConstraint>();
      for (int i = 1; i < args.size(); i++) {
        a = args.get(i);
        String fieldName = a[0].trim();
        String operator = a[1].trim();
        String var = a[2].trim();

        Declaration declr = (Declaration) context.get(var);

        BetaNodeFieldConstraint betaConstraint;
        try {
          betaConstraint =
              this.reteTesterHelper.getBoundVariableConstraint(cls, fieldName, declr, operator);
          list.add(betaConstraint);
        } catch (IntrospectionException e) {
          throw new IllegalArgumentException();
        }
      }

      BetaConstraints constraints;
      switch (list.size()) {
        case 0:
          constraints = new EmptyBetaConstraints();
          break;
        case 1:
          constraints =
              new SingleBetaConstraints(
                  list.get(0), buildContext.getKnowledgeBase().getConfiguration());
          break;
        case 2:
          constraints =
              new DoubleBetaConstraints(
                  list.toArray(new BetaNodeFieldConstraint[2]),
                  buildContext.getKnowledgeBase().getConfiguration());
          break;
        case 3:
          constraints =
              new TripleBetaConstraints(
                  list.toArray(new BetaNodeFieldConstraint[2]),
                  buildContext.getKnowledgeBase().getConfiguration());
          break;
        case 4:
          constraints =
              new QuadroupleBetaConstraints(
                  list.toArray(new BetaNodeFieldConstraint[2]),
                  buildContext.getKnowledgeBase().getConfiguration());
          break;
        default:
          constraints =
              new DefaultBetaConstraints(
                  list.toArray(new BetaNodeFieldConstraint[2]),
                  buildContext.getKnowledgeBase().getConfiguration());
          break;
      }

      NotNode notNode =
          new NotNode(
              buildContext.getNextId(),
              leftTupleSource,
              rightObjectSource,
              constraints,
              buildContext);
      notNode.attach(buildContext);
      context.put(name, notNode);

    } else {
      throw new IllegalArgumentException("Cannot arguments " + args);
    }
  }
Esempio n. 2
0
  public void execute(Map<String, Object> context, List<String[]> args) {
    BuildContext buildContext = (BuildContext) context.get("BuildContext");

    if (args.size() >= 1) {

      // The first argument list is the node parameters
      String[] a = args.get(0);
      String name = a[0];
      String leftInput = a[1];
      String rightInput = a[2];
      String sourceType = a[3];
      String expr = a[4];

      Class cls = null;

      LeftTupleSource leftTupleSource;
      if (leftInput.startsWith("mock")) {
        leftTupleSource = new MockTupleSource(buildContext.getNextId());
      } else {
        leftTupleSource = (LeftTupleSource) context.get(leftInput);
      }

      ObjectSource rightObjectSource;
      if (rightInput.startsWith("mock")) {
        String type = rightInput.substring(5, rightInput.length() - 1);
        try {
          cls = reteTesterHelper.getTypeResolver().resolveType(type);
        } catch (ClassNotFoundException e) {
          throw new RuntimeException(e);
        }
        rightObjectSource = new MockObjectSource(buildContext.getNextId());
      } else {
        rightObjectSource = (ObjectSource) context.get(rightInput);
        ObjectSource source = rightObjectSource;
        while (!(source instanceof ObjectTypeNode)) {
          source = source.getParentObjectSource();
        }
        cls = ((ClassObjectType) ((ObjectTypeNode) source).getObjectType()).getClassType();
      }

      Pattern sourcePattern;
      Pattern resultPattern;
      try {
        sourcePattern = reteTesterHelper.getPattern(0, sourceType);

        // we always use the accumulate function "sum", so return type is always Number
        resultPattern =
            reteTesterHelper.getPattern(buildContext.getNextId(), Number.class.getName());
      } catch (Exception e) {
        throw new IllegalArgumentException(
            "Not possible to process arguments: " + Arrays.toString(a));
      }

      List<BetaNodeFieldConstraint> list = new ArrayList<BetaNodeFieldConstraint>();

      AlphaNodeFieldConstraint[] alphaResultConstraint = new AlphaNodeFieldConstraint[0];
      // the following arguments are constraints
      for (int i = 1; i < args.size(); i++) {
        a = args.get(i);
        String type = a[0];
        String fieldName = a[1];
        String operator = a[2];
        String val = a[3];

        if ("source".equals(type)) {
          Declaration declr = (Declaration) context.get(val);
          try {
            BetaNodeFieldConstraint sourceBetaConstraint =
                this.reteTesterHelper.getBoundVariableConstraint(cls, fieldName, declr, operator);
            list.add(sourceBetaConstraint);
          } catch (IntrospectionException e) {
            throw new IllegalArgumentException();
          }
        } else if ("result".equals(type)) {
          alphaResultConstraint = new AlphaNodeFieldConstraint[1];
          try {
            alphaResultConstraint[0] =
                this.reteTesterHelper.getLiteralConstraint(resultPattern, fieldName, operator, val);
          } catch (IntrospectionException e) {
            throw new IllegalArgumentException(
                "Unable to configure alpha constraint: " + Arrays.toString(a), e);
          }
        }
      }

      BetaConstraints betaSourceConstraints;
      switch (list.size()) {
        case 0:
          betaSourceConstraints = new EmptyBetaConstraints();
          break;
        case 1:
          betaSourceConstraints =
              new SingleBetaConstraints(
                  list.get(0), buildContext.getKnowledgeBase().getConfiguration());
          break;
        case 2:
          betaSourceConstraints =
              new DoubleBetaConstraints(
                  list.toArray(new BetaNodeFieldConstraint[2]),
                  buildContext.getKnowledgeBase().getConfiguration());
          break;
        case 3:
          betaSourceConstraints =
              new TripleBetaConstraints(
                  list.toArray(new BetaNodeFieldConstraint[2]),
                  buildContext.getKnowledgeBase().getConfiguration());
          break;
        case 4:
          betaSourceConstraints =
              new QuadroupleBetaConstraints(
                  list.toArray(new BetaNodeFieldConstraint[2]),
                  buildContext.getKnowledgeBase().getConfiguration());
          break;
        default:
          betaSourceConstraints =
              new DefaultBetaConstraints(
                  list.toArray(new BetaNodeFieldConstraint[2]),
                  buildContext.getKnowledgeBase().getConfiguration());
          break;
      }

      MVELDialectRuntimeData data =
          (MVELDialectRuntimeData)
              buildContext
                  .getKnowledgeBase()
                  .getPackage(buildContext.getRule().getPackageName())
                  .getDialectRuntimeRegistry()
                  .getDialectData("mvel");
      data.onAdd(null, buildContext.getKnowledgeBase().getRootClassLoader());
      // MvelD data = (MVELDialectRuntimeData) buildContext.getRuleBase().getPackage(
      // buildContext.getRule().getName() ).getDialectRuntimeRegistry().getDialectData( "mvel" );

      NodeTestCase testCase = (NodeTestCase) context.get("TestCase");

      try {
        for (String imp : testCase.getImports()) {
          if (imp.endsWith(".*")) {
            data.addPackageImport(imp.substring(0, imp.lastIndexOf('.')));
          } else {
            // classImports.add( imp );
            cls = data.getRootClassLoader().loadClass(imp);
            data.addImport(cls.getSimpleName(), cls);
          }
        }
      } catch (Exception e) {
        throw new RuntimeException("Unable to load class", e);
      }

      Declaration decl = (Declaration) context.get(expr);
      // build an external function executor
      MVELCompilationUnit compilationUnit =
          new MVELCompilationUnit(
              name,
              expr,
              new String[] {}, // global identifiers
              new EvaluatorWrapper[] {}, // operator identifiers
              new Declaration[] {}, // previous declarations
              new Declaration[] {decl}, // local declarations
              new String[] {}, // other identifiers
              new String[] {
                "this", "drools", "kcontext", "rule", decl.getIdentifier()
              }, // input identifiers
              new String[] {
                Object.class.getName(),
                KnowledgeHelper.class.getName(),
                KnowledgeHelper.class.getName(),
                Rule.class.getName(),
                decl.getValueType().getClassType().getName()
              }, // input types
              4,
              false,
              false);

      AccumulateFunction accFunction = new SumAccumulateFunction();

      Accumulator accumulator = new MVELAccumulatorFunctionExecutor(compilationUnit, accFunction);
      ((MVELCompileable) accumulator).compile(data);

      Accumulate accumulate =
          new SingleAccumulate(
              sourcePattern,
              new Declaration[] {}, // required declaration
              accumulator);
      AccumulateNode accNode =
          new AccumulateNode(
              buildContext.getNextId(),
              leftTupleSource,
              rightObjectSource,
              alphaResultConstraint,
              betaSourceConstraints,
              new EmptyBetaConstraints(),
              accumulate,
              false,
              buildContext);

      accNode.attach(buildContext);
      context.put(name, accNode);

    } else {
      StringBuilder msgBuilder = new StringBuilder();
      msgBuilder.append("Can not parse AccumulateNode step arguments: \n");
      for (String[] arg : args) {
        msgBuilder.append("    ");
        msgBuilder.append(Arrays.toString(arg));
        msgBuilder.append("\n");
      }
      throw new IllegalArgumentException(msgBuilder.toString());
    }
  }