public static QuantifiedExpressionNode newQuantifiedExpression(ParserRuleContext ctx, QuantifiedExpressionNode.Quantifier quant, ListNode list, BaseNode expr) { return new QuantifiedExpressionNode( ctx, quant, list, expr ); }
@Override public Boolean evaluate(EvaluationContext ctx) { if( quantifier == Quantifier.SOME || quantifier == Quantifier.EVERY ) { return iterateContexts( ctx, iterationContexts, expression, quantifier ); } ctx.notifyEvt( astEvent(Severity.ERROR, Msg.createMessage(Msg.IS_NULL, "Quantifier")) ); return null; }
private QEIteration[] initializeContexts(EvaluationContext ctx, List<IterationContextNode> iterationContexts) { QEIteration[] ictx = new QEIteration[iterationContexts.size()]; int i = 0; for ( IterationContextNode icn : iterationContexts ) { ictx[i] = createQuantifiedExpressionIterationContext( ctx, icn ); if( i < ictx.length - 1 ) { // initalize all contexts except the very last one, as it will be initialized in the nextIteration() method setValueIntoContext( ctx, ictx[i] ); } i++; } return ictx; }
@Override public DirectCompilerResult visit(QuantifiedExpressionNode n) { DirectCompilerResult expr = n.getExpression().accept(this); HashSet<FieldDeclaration> fds = new HashSet<>(); Expressions.NamedLambda namedLambda = Expressions.namedLambda( expr.getExpression(), n.getExpression().getText()); fds.add(namedLambda.field()); fds.addAll(expr.getFieldDeclarations()); List<Expression> expressions = n.getIterationContexts() .stream() .map(iter -> iter.accept(this)) .peek(r -> fds.addAll(r.getFieldDeclarations())) .map(DirectCompilerResult::getExpression) .collect(Collectors.toList()); // .satisfies(expr) return DirectCompilerResult.of( Expressions.quantifier(n.getQuantifier(), namedLambda.name(), expressions), expr.resultType, fds); }
private Boolean iterateContexts(EvaluationContext ctx, List<IterationContextNode> iterationContexts, BaseNode expression, Quantifier quantifier ) { try { ctx.enterFrame(); QEIteration[] ictx = initializeContexts(ctx, iterationContexts); while ( nextIteration( ctx, ictx ) ) { Boolean result = (Boolean) expression.evaluate( ctx ); if ( result != null && result.equals( quantifier.positiveTest() ) ) { return quantifier.positiveTest(); } } return quantifier.defaultValue(); } finally { ctx.exitFrame(); } }
public static boolean nextIteration(EvaluationContext ctx, QEIteration[] ictx) { int i = ictx.length-1; while ( i >= 0 && i < ictx.length ) { if ( ictx[i].hasNextValue() ) { setValueIntoContext( ctx, ictx[i] ); i++; } else { i--; } } return i >= 0; }
private Boolean iterateContexts(EvaluationContext ctx, List<IterationContextCompiled> iterationContexts, Function<EvaluationContext, Object> expression, Quantifier quantifier) { try { ctx.enterFrame(); QEIteration[] ictx = initializeContexts(ctx, iterationContexts); while (QuantifiedExpressionNode.nextIteration(ctx, ictx)) { Boolean result = (Boolean) expression.apply(ctx); if (result != null && result.equals(quantifier.positiveTest())) { return quantifier.positiveTest(); } } return quantifier.defaultValue(); } finally { ctx.exitFrame(); } }
@Test public void testQuantifiedExpressionSome() { String inputExpression = "some item in order.items satisfies item.price > 100"; BaseNode someBase = parse( inputExpression ); assertThat( someBase, is( instanceOf( QuantifiedExpressionNode.class ) ) ); assertThat( someBase.getText(), is( inputExpression ) ); assertThat( someBase.getResultType(), is( BuiltInType.BOOLEAN ) ); QuantifiedExpressionNode someExpr = (QuantifiedExpressionNode) someBase; assertThat( someExpr.getQuantifier(), is( QuantifiedExpressionNode.Quantifier.SOME ) ); assertThat( someExpr.getIterationContexts().size(), is( 1 ) ); assertThat( someExpr.getIterationContexts().get( 0 ).getText(), is( "item in order.items" ) ); assertThat( someExpr.getExpression().getText(), is( "item.price > 100" ) ); }
private QEIteration[] initializeContexts(EvaluationContext ctx, List<IterationContextCompiled> iterationContexts) { QEIteration[] ictx = new QEIteration[iterationContexts.size()]; int i = 0; for (IterationContextCompiled icn : iterationContexts) { ictx[i] = createQuantifiedExpressionIterationContext(ctx, icn); if (i < ictx.length - 1) { // initalize all contexts except the very last one, as it will be initialized in the nextIteration() method QuantifiedExpressionNode.setValueIntoContext(ctx, ictx[i]); } i++; } return ictx; }
@Test public void testQuantifiedExpressionEvery() { String inputExpression = "every item in order.items satisfies item.price > 100"; BaseNode everyBase = parse( inputExpression ); assertThat( everyBase, is( instanceOf( QuantifiedExpressionNode.class ) ) ); assertThat( everyBase.getText(), is( inputExpression ) ); assertThat( everyBase.getResultType(), is( BuiltInType.BOOLEAN ) ); QuantifiedExpressionNode everyExpr = (QuantifiedExpressionNode) everyBase; assertThat( everyExpr.getQuantifier(), is( QuantifiedExpressionNode.Quantifier.EVERY ) ); assertThat( everyExpr.getIterationContexts().size(), is( 1 ) ); assertThat( everyExpr.getIterationContexts().get( 0 ).getText(), is( "item in order.items" ) ); assertThat( everyExpr.getExpression().getText(), is( "item.price > 100" ) ); }