Пример #1
0
  private int getSpecifity(final Pattern pattern) {
    int specificity = 0;
    for (Constraint constraint : pattern.getConstraints()) {
      if (!(constraint instanceof Declaration)) {
        specificity++;
      }
    }

    return specificity;
  }
Пример #2
0
  /** recurse through the rule condition elements updating the declaration objecs */
  private void processElement(
      final DeclarationScopeResolver resolver,
      final Stack<RuleConditionElement> contextStack,
      final RuleConditionElement element) {
    if (element instanceof Pattern) {
      Pattern pattern = (Pattern) element;
      for (RuleConditionElement ruleConditionElement : pattern.getNestedElements()) {
        processElement(resolver, contextStack, ruleConditionElement);
      }
      for (Constraint constraint : pattern.getConstraints()) {
        if (constraint instanceof Declaration) {
          continue;
        }
        replaceDeclarations(resolver, pattern, constraint);
      }

    } else if (element instanceof EvalCondition) {
      processEvalCondition(resolver, (EvalCondition) element);

    } else if (element instanceof Accumulate) {
      for (RuleConditionElement rce : element.getNestedElements()) {
        processElement(resolver, contextStack, rce);
      }
      Accumulate accumulate = (Accumulate) element;
      replaceDeclarations(resolver, accumulate);
      accumulate.resetInnerDeclarationCache();

    } else if (element instanceof From) {
      DataProvider provider = ((From) element).getDataProvider();
      Declaration[] decl = provider.getRequiredDeclarations();
      for (Declaration aDecl : decl) {
        Declaration resolved = resolver.getDeclaration(null, aDecl.getIdentifier());
        if (resolved != null && resolved != aDecl) {
          provider.replaceDeclaration(aDecl, resolved);
        } else if (resolved == null) {
          // it is probably an implicit declaration, so find the corresponding pattern
          Pattern old = aDecl.getPattern();
          Pattern current = resolver.findPatternByIndex(old.getIndex());
          if (current != null && old != current) {
            resolved = new Declaration(aDecl.getIdentifier(), aDecl.getExtractor(), current);
            provider.replaceDeclaration(aDecl, resolved);
          }
        }
      }

    } else if (element instanceof QueryElement) {
      QueryElement qe = (QueryElement) element;
      Pattern pattern = qe.getResultPattern();

      for (Entry<String, Declaration> entry : pattern.getInnerDeclarations().entrySet()) {
        Declaration resolved = resolver.getDeclaration(null, entry.getValue().getIdentifier());
        if (resolved != null && resolved != entry.getValue() && resolved.getPattern() != pattern) {
          entry.setValue(resolved);
        }
      }

      List<Integer> varIndexes = asList(qe.getVariableIndexes());
      for (int i = 0; i < qe.getArguments().length; i++) {
        if (!(qe.getArguments()[i] instanceof QueryArgument.Declr)) {
          continue;
        }
        Declaration declr = ((QueryArgument.Declr) qe.getArguments()[i]).getDeclaration();
        Declaration resolved = resolver.getDeclaration(null, declr.getIdentifier());
        if (resolved != declr && resolved.getPattern() != pattern) {
          qe.getArguments()[i] = new QueryArgument.Declr(resolved);
        }

        if (ClassObjectType.DroolsQuery_ObjectType.isAssignableFrom(
            resolved.getPattern().getObjectType())) {
          // if the resolved still points to DroolsQuery, we know this is the first unification
          // pattern, so redeclare it as the visible Declaration
          declr = pattern.addDeclaration(declr.getIdentifier());

          // this bit is different, notice its the ArrayElementReader that we wire up to, not the
          // declaration.
          ArrayElementReader reader =
              new ArrayElementReader(
                  new SelfReferenceClassFieldReader(Object[].class),
                  i,
                  resolved.getDeclarationClass());
          declr.setReadAccessor(reader);

          varIndexes.add(i);
        }
      }
      qe.setVariableIndexes(toIntArray(varIndexes));

    } else if (element instanceof ConditionalBranch) {
      processBranch(resolver, (ConditionalBranch) element);

    } else {
      contextStack.push(element);
      for (RuleConditionElement ruleConditionElement : element.getNestedElements()) {
        processElement(resolver, contextStack, ruleConditionElement);
      }
      contextStack.pop();
    }
  }
Пример #3
0
  /**
   * recurse through the rule condition elements updating the declaration objecs
   *
   * @param resolver
   * @param contextStack
   * @param element
   */
  private void processElement(
      final DeclarationScopeResolver resolver,
      final Stack contextStack,
      final RuleConditionElement element) {
    if (element instanceof Pattern) {
      Pattern pattern = (Pattern) element;
      for (Iterator it = pattern.getNestedElements().iterator(); it.hasNext(); ) {
        processElement(resolver, contextStack, (RuleConditionElement) it.next());
      }
      for (Constraint next : pattern.getConstraints()) {
        if (next instanceof Declaration) {
          continue;
        }
        Constraint constraint = (Constraint) next;
        Declaration[] decl = constraint.getRequiredDeclarations();
        for (int i = 0; i < decl.length; i++) {
          Declaration resolved = resolver.getDeclaration(null, decl[i].getIdentifier());

          if (constraint instanceof MvelConstraint
              && ((MvelConstraint) constraint).isUnification()) {
            if (ClassObjectType.DroolsQuery_ObjectType.isAssignableFrom(
                resolved.getPattern().getObjectType())) {
              Declaration redeclaredDeclr =
                  new Declaration(
                      resolved.getIdentifier(),
                      ((MvelConstraint) constraint).getFieldExtractor(),
                      pattern,
                      false);
              pattern.addDeclaration(redeclaredDeclr);
            } else {
              ((MvelConstraint) constraint).unsetUnification();
            }
          }

          if (resolved != null && resolved != decl[i] && resolved.getPattern() != pattern) {
            constraint.replaceDeclaration(decl[i], resolved);
          } else if (resolved == null) {
            // it is probably an implicit declaration, so find the corresponding pattern
            Pattern old = decl[i].getPattern();
            Pattern current = resolver.findPatternByIndex(old.getIndex());
            if (current != null && old != current) {
              resolved = new Declaration(decl[i].getIdentifier(), decl[i].getExtractor(), current);
              constraint.replaceDeclaration(decl[i], resolved);
            }
          }
        }
      }
    } else if (element instanceof EvalCondition) {
      Declaration[] decl = ((EvalCondition) element).getRequiredDeclarations();
      for (Declaration aDecl : decl) {
        Declaration resolved = resolver.getDeclaration(null, aDecl.getIdentifier());
        if (resolved != null && resolved != aDecl) {
          ((EvalCondition) element).replaceDeclaration(aDecl, resolved);
        }
      }
    } else if (element instanceof Accumulate) {
      for (RuleConditionElement rce : element.getNestedElements()) {
        processElement(resolver, contextStack, rce);
      }
      ((Accumulate) element).resetInnerDeclarationCache();
    } else if (element instanceof From) {
      DataProvider provider = ((From) element).getDataProvider();
      Declaration[] decl = provider.getRequiredDeclarations();
      for (Declaration aDecl : decl) {
        Declaration resolved = resolver.getDeclaration(null, aDecl.getIdentifier());
        if (resolved != null && resolved != aDecl) {
          provider.replaceDeclaration(aDecl, resolved);
        } else if (resolved == null) {
          // it is probably an implicit declaration, so find the corresponding pattern
          Pattern old = aDecl.getPattern();
          Pattern current = resolver.findPatternByIndex(old.getIndex());
          if (current != null && old != current) {
            resolved = new Declaration(aDecl.getIdentifier(), aDecl.getExtractor(), current);
            provider.replaceDeclaration(aDecl, resolved);
          }
        }
      }
    } else if (element instanceof QueryElement) {
      QueryElement qe = (QueryElement) element;
      Pattern pattern = qe.getResultPattern();

      for (Entry<String, Declaration> entry : pattern.getInnerDeclarations().entrySet()) {
        Declaration resolved = resolver.getDeclaration(null, entry.getValue().getIdentifier());
        if (resolved != null && resolved != entry.getValue() && resolved.getPattern() != pattern) {
          entry.setValue(resolved);
        }
      }

      List<Integer> varIndexes = ArrayUtils.asList(qe.getVariableIndexes());
      for (int i = 0; i < qe.getDeclIndexes().length; i++) {
        Declaration declr = (Declaration) qe.getArgTemplate()[qe.getDeclIndexes()[i]];
        Declaration resolved = resolver.getDeclaration(null, declr.getIdentifier());
        if (resolved != null && resolved != declr && resolved.getPattern() != pattern) {
          qe.getArgTemplate()[qe.getDeclIndexes()[i]] = resolved;
        }

        if (ClassObjectType.DroolsQuery_ObjectType.isAssignableFrom(
            resolved.getPattern().getObjectType())) {
          // if the resolved still points to DroolsQuery, we know this is the first unification
          // pattern, so redeclare it as the visible Declaration
          declr = pattern.addDeclaration(declr.getIdentifier());

          // this bit is different, notice its the ArrayElementReader that we wire up to, not the
          // declaration.
          ArrayElementReader reader =
              new ArrayElementReader(
                  new SelfReferenceClassFieldReader(Object[].class, "this"),
                  qe.getDeclIndexes()[i],
                  resolved.getExtractor().getExtractToClass());

          declr.setReadAccessor(reader);

          varIndexes.add(qe.getDeclIndexes()[i]);
        }
      }
      qe.setVariableIndexes(ArrayUtils.toIntArray(varIndexes));
    } else {
      contextStack.push(element);
      for (RuleConditionElement ruleConditionElement : element.getNestedElements()) {
        processElement(resolver, contextStack, ruleConditionElement);
      }
      contextStack.pop();
    }
  }