private boolean usesDeclaration(final Constraint constraint) { boolean usesDecl = false; final Declaration[] declarations = constraint.getRequiredDeclarations(); for (int j = 0; !usesDecl && j < declarations.length; j++) { usesDecl = (declarations[j].getPattern().getObjectType() == this.objectType); } return usesDecl; }
private void createConstraints( BuildContext context, BuildUtils utils, Pattern pattern, List<Constraint> alphaConstraints, List<Constraint> betaConstraints) { final List<?> constraints = pattern.getConstraints(); // check if cross products for identity patterns should be disabled checkRemoveIdentities(context, pattern, betaConstraints); // checks if this pattern is nested inside a NOT CE final boolean isNegative = isNegative(context); for (final Iterator<?> it = constraints.iterator(); it.hasNext(); ) { final Object object = it.next(); // Check if its a declaration if (object instanceof Declaration) { // nothing to be done continue; } final Constraint constraint = (Constraint) object; if (constraint.getType().equals(Constraint.ConstraintType.ALPHA)) { alphaConstraints.add(constraint); } else if (constraint.getType().equals(Constraint.ConstraintType.BETA)) { betaConstraints.add(constraint); if (isNegative && context.getRuleBase().getConfiguration().getEventProcessingMode() == EventProcessingOption.STREAM && pattern.getObjectType().isEvent() && constraint.isTemporal()) { checkDelaying(context, constraint); } } else { throw new RuntimeDroolsException( "Unknown constraint type: " + constraint.getType() + ". This is a bug. Please contact development team."); } } }
private void checkDelaying(final BuildContext context, final Constraint constraint) { if (constraint instanceof VariableConstraint) { // variable constraints always require a single declaration Declaration target = constraint.getRequiredDeclarations()[0]; if (target.isPatternDeclaration() && target.getPattern().getObjectType().isEvent()) { long uplimit = ((VariableConstraint) constraint).getInterval().getUpperBound(); Timer timer = context.getRule().getTimer(); DurationTimer durationTimer = new DurationTimer(uplimit); if (timer instanceof CompositeMaxDurationTimer) { // already a composite so just add ((CompositeMaxDurationTimer) timer).addDurationTimer(durationTimer); } else { if (timer == null) { // no timer exists, so ok on it's own timer = durationTimer; } else { // timer exists so we need to make a composite CompositeMaxDurationTimer temp = new CompositeMaxDurationTimer(); if (timer instanceof DurationTimer) { // previous timer was a duration, so add another DurationTimer temp.addDurationTimer((DurationTimer) timer); } else { // previous timer was not a duration, so set it as the delegate Timer. temp.setTimer(context.getRule().getTimer()); } // now add the new durationTimer temp.addDurationTimer(durationTimer); timer = temp; } // with the composite made, reset it on the Rule context.getRule().setTimer(timer); } } } }
/** * 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(); } }