How to use

FormulaParser

in

org.activityinfo.model.formula

  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);
  }
}