public static IterationContextNode newIterationContextNode(ParserRuleContext ctx, NameDefNode name, BaseNode expr, BaseNode rangeEndExpr) { return new IterationContextNode(ctx, name, expr, rangeEndExpr); }
private ForIteration createQuantifiedExpressionIterationContext(EvaluationContext ctx, IterationContextNode icn) { ForIteration fi = null; String name = icn.evaluateName( ctx ); Object result = icn.evaluate( ctx ); Object rangeEnd = icn.evaluateRangeEnd(ctx); if (rangeEnd == null) { Iterable values = result instanceof Iterable ? (Iterable) result : Collections.singletonList(result); fi = new ForIteration(name, values); } else { valueMustBeANumber(ctx, result); BigDecimal start = (BigDecimal) result; valueMustBeANumber(ctx, rangeEnd); BigDecimal end = (BigDecimal) rangeEnd; fi = new ForIteration(name, start, end); } return fi; }
private QEIteration createQuantifiedExpressionIterationContext(EvaluationContext ctx, IterationContextNode icn) { String name = icn.evaluateName( ctx ); Object result = icn.evaluate( ctx ); Iterable values = result instanceof Iterable ? (Iterable) result : Collections.singletonList( result ); QEIteration qei = new QEIteration( name, values ); return qei; }
@Override public DirectCompilerResult visit(IterationContextNode n) { DirectCompilerResult iterName = n.getName().accept(this); DirectCompilerResult iterExpr = n.getExpression().accept(this); n.getName().getText()); Expressions.NamedLambda exprLambda = Expressions.namedLambda( iterExpr.getExpression(), n.getExpression().getText()); r.withFD(iterExpr); BaseNode rangeEndExpr = n.getRangeEndExpr(); if (rangeEndExpr != null) { DirectCompilerResult rangeEnd = rangeEndExpr.accept(this);
@Test public void testForExpression() { String inputExpression = "for item in order.items return item.price * item.quantity"; BaseNode forbase = parse( inputExpression ); assertThat( forbase, is( instanceOf( ForExpressionNode.class ) ) ); assertThat( forbase.getText(), is( inputExpression ) ); assertThat( forbase.getResultType(), is( BuiltInType.LIST ) ); ForExpressionNode forExpr = (ForExpressionNode) forbase; assertThat( forExpr.getIterationContexts().size(), is( 1 ) ); assertThat( forExpr.getExpression(), is( instanceOf( InfixOpNode.class ) ) ); assertThat( forExpr.getExpression().getText(), is( "item.price * item.quantity" ) ); IterationContextNode ic = forExpr.getIterationContexts().get( 0 ); assertThat( ic.getName().getText(), is("item") ); assertThat( ic.getExpression(), is( instanceOf( QualifiedNameNode.class ) ) ); assertThat( ic.getExpression().getText(), is("order.items") ); }
@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" ) ); }
@Override public DirectCompilerResult visit(ForExpressionNode 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.ffor(expressions, namedLambda.name()), expr.resultType, fds); }
@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" ) ); }
@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); }
public static IterationContextNode newIterationContextNode(ParserRuleContext ctx, NameDefNode name, BaseNode expr) { return new IterationContextNode( ctx, name, expr ); }