private boolean isValid(String updatedFormula) { try { FormulaParser.parse(updatedFormula); return true; } catch (Exception e) { return false; } } }
public static FormulaNode parse(String expression) { if(Strings.isNullOrEmpty(expression)) { return new ConstantNode((String)null); } FormulaLexer lexer = new FormulaLexer(expression); FormulaParser parser = new FormulaParser(lexer); return parser.parse(); } }
private FormulaNode equality() { FormulaNode left = relational(); while(lexer.hasNext() && lexer.peek().isEqualityOperator()) { FormulaFunction op = function(); FormulaNode right = relational(); left = binaryInfixCall(op, left, right); } return left; }
private FormulaNode term() { // <term> ::= <factor> | <term> + <factor> | <term> - <factor> FormulaNode left = factor(); while (lexer.hasNext() && lexer.peek().isAdditiveOperator()) { FormulaFunction op = function(); FormulaNode right = factor(); left = binaryInfixCall(op, left, right); } return left; }
private FormulaNode relational() { FormulaNode left = term(); while(lexer.hasNext() && lexer.peek().isRelationalOperator()) { FormulaFunction op = function(); FormulaNode right = term(); left = binaryInfixCall(op, left, right); } return left; }
private FormulaNode primary() { switch (lexer.peek().getType()) { case SYMBOL: if(lexer.peek().getString().matches("t\\d{10}")) { return enumLiteral(); } else { return symbolOrCall(); } case NUMBER: return number(); case BOOLEAN_LITERAL: return booleanLiteral(); case STRING_LITERAL: return stringLiteral(); case PAREN_START: Token openToken = lexer.next(); FormulaNode e = expression(); Token closeToken = expect(TokenType.PAREN_END); return new GroupNode(e, new SourceRange(openToken, closeToken)); default: throw new FormulaSyntaxException(new SourceRange(lexer.peek()), "Expected a symbol, a number, a string, or '('"); } }
private FormulaNode disjunction() { FormulaNode left = conjunction(); while(lexer.hasNext() && lexer.peek().isOrOperator()) { FormulaFunction op = function(); FormulaNode right = conjunction(); left = binaryInfixCall(op, left, right); } return left; }
public FormulaNode factor() { // <factor> ::= <unary> | <factor> * <unary> | <factor> / <unary> FormulaNode left = unary(); while(lexer.hasNext() && lexer.peek().isMultiplicativeOperator()) { FormulaFunction function = function(); FormulaNode right = unary(); left = binaryInfixCall(function, left, right); } return left; }
private FormulaNode conjunction() { FormulaNode left = equality(); while(lexer.hasNext() && lexer.peek().isAndOperator()) { FormulaFunction op = function(); FormulaNode right = equality(); left = binaryInfixCall(op, left, right); } return left; }
public Multimap<Integer, FilterConfig> parseFilter(Optional<String> filterString) { if(filterString.isPresent()) { return parseFilter(FormulaParser.parse(filterString.get())); } else { return EMPTY; } }
private FormulaNode parse(String string) { System.out.println("Parsing [" + string + "]"); FormulaLexer lexer = new FormulaLexer(string); FormulaParser parser = new FormulaParser(lexer); return parser.parse(); }
@JsonSetter public void setFilter(String filterExpression) { if(filterExpression == null) { this.filter = null; } else { this.filter = FormulaParser.parse(filterExpression); } }
private String validateExpression(String value) { try { FormulaLexer lexer = new FormulaLexer(value); FormulaParser parser = new FormulaParser(lexer); FormulaNode expr = parser.parse(); // expr node is created, expression is parsable // try to check variable names List<SymbolNode> placeholderExprList = Lists.newArrayList(); gatherPlaceholderExprs(expr, placeholderExprList); List<String> existingIndicatorCodes = existingIndicatorCodes(); for (SymbolNode placeholderExpr : placeholderExprList) { if (!existingIndicatorCodes.contains(placeholderExpr.getName())) { return I18N.MESSAGES.doesNotExist(placeholderExpr.getName()); } } return null; } catch (FormulaSyntaxException e) { return e.getMessage(); } catch (Exception ignored) { return constants.calculationExpressionIsInvalid(); } }
private List<FormulaNode> parsePermission(String filter) { FormulaNode formulaNode = FormulaParser.parse(filter); return Formulas.findBinaryTree(formulaNode, AndFunction.INSTANCE); }
private void evaluate(String exprString, boolean expectedValue) { FormulaLexer lexer = new FormulaLexer(exprString); FormulaParser parser = new FormulaParser(lexer); FormulaNode expr = parser.parse(); FieldValue result = expr.evaluate(EmptyEvalContext.INSTANCE); assertThat(exprString, Casting.toBoolean(result), equalTo(expectedValue)); }
private Slot<ColumnView> evaluateExpression(String expression) { FormulaNode parsed = FormulaParser.parse(expression); return parsed.accept(columnVisitor); }
private void validateExpression() { String expression = expressionTextBox.getValue(); if(Strings.isNullOrEmpty(expression)) { expressionGroup.setShowValidationMessage(false); expressionGroup.validationStateType(ValidationStateType.NONE); return; } try { FormulaLexer lexer = new FormulaLexer(expression); FormulaParser parser = new FormulaParser(lexer); FormulaNode expr = parser.parse(); } catch (Exception e) { expressionGroup.setShowValidationMessage(true); expressionGroup.setValidationMessage(I18N.CONSTANTS.calculationExpressionIsInvalid()); expressionGroup.validationStateType(ValidationStateType.ERROR); return; } // Ok expressionGroup.setShowValidationMessage(false); expressionGroup.validationStateType(ValidationStateType.SUCCESS); } }
private static Optional<String> and(Optional<String> filter1, Optional<String> filter2) { if (!filter1.isPresent() && !filter2.isPresent()) { return Optional.empty(); } else if (!filter1.isPresent()) { return filter2; } else if (!filter2.isPresent()) { return filter1; } FormulaNode filterFormula1 = FormulaParser.parse(filter1.get()); FormulaNode filterFormula2 = FormulaParser.parse(filter2.get()); if (filterFormula1.equals(filterFormula2)) { return filter1; } FormulaNode and = Formulas.allTrue(Lists.newArrayList(filterFormula1, filterFormula2)); return Optional.of(and.asExpression()); }
private void eval(String relevanceExpression, boolean expectedValue, TypedFormRecord instance) { FormulaLexer lexer = new FormulaLexer(relevanceExpression); FormulaParser parser = new FormulaParser(lexer); FormulaNode expr = parser.parse(); Assert.assertEquals(relevanceExpression, expectedValue, Casting.toBoolean(expr.evaluate(new FormEvalContext(formClass, instance)))); }
private static FormulaNode parseFilter(String filter) { if(Strings.isNullOrEmpty(filter)) { return new ConstantNode(true); } try { return FormulaParser.parse(filter); } catch (FormulaException e) { // Failed to parse filter, falling back to denied access return new ConstantNode(false); } }