public static FilterExpressionNode newFilterExpressionNode(ParserRuleContext ctx, BaseNode expr, BaseNode filter) { return new FilterExpressionNode( ctx, expr, filter ); }
private List evaluateExpressionsInContext(EvaluationContext ctx, List expressions) { List results = new ArrayList(); expressions.forEach(expression -> evaluateExpressionInContext( ctx, results, expression)); return results; }
@Override public DirectCompilerResult visit(FilterExpressionNode n) { DirectCompilerResult expr = n.getExpression().accept(this); DirectCompilerResult filter = n.getFilter().accept(this); Expressions.NamedLambda lambda = Expressions.namedLambda(filter.getExpression(), n.getFilter().getText()); DirectCompilerResult r = DirectCompilerResult.of( Expressions.filter(expr.getExpression(), lambda.name()), // here we could still try to infer the result type, but presently use ANY BuiltInType.UNKNOWN).withFD(expr).withFD(filter); r.addFieldDesclaration(lambda.field()); return r; }
return list.get( list.size() + i ); } else { ctx.notifyEvt( astEvent( Severity.ERROR, Msg.createMessage( Msg.INDEX_OUT_OF_BOUND ) ) ); return null; return evaluateExpressionsInContext(ctx, list); return evaluateExpressionsInContext(ctx, list); ctx.notifyEvt( astEvent(Severity.ERROR, Msg.createMessage(Msg.ERROR_EXECUTING_LIST_FILTER, getText()), e) );
@Test public void testFilterExpression() { String inputExpression = "[ {x:1, y:2}, {x:2, y:3} ][ x=1 ]"; BaseNode filterBase = parse( inputExpression ); assertThat( filterBase, is( instanceOf( FilterExpressionNode.class ) ) ); assertThat( filterBase.getText(), is( inputExpression ) ); FilterExpressionNode filter = (FilterExpressionNode) filterBase; assertThat( filter.getExpression(), is( instanceOf( ListNode.class ) ) ); assertThat( filter.getExpression().getText(), is( "{x:1, y:2}, {x:2, y:3}" ) ); assertThat( filter.getFilter(), is( instanceOf( InfixOpNode.class ) ) ); assertThat( filter.getFilter().getText(), is( "x=1" ) ); }