public SymbolNode(Token token) { assert token.getType() == TokenType.SYMBOL; this.name = token.getString(); this.sourceRange = new SourceRange(token); }
private Token finishToken(TokenType type, String text) { int length = currentCharIndex - currentTokenStart; Token token = new Token(type, currentTokenStartPos, length, text); currentTokenStart = currentCharIndex; currentTokenStartPos = new SourcePos(currentLineIndex, currentColumnIndex); return token; }
@Override public FieldValue evaluate(EvalContext context) { FieldValue baseValue = value.evaluate(context); if(baseValue instanceof EnumValue) { EnumValue enumValue = (EnumValue) baseValue; return evaluateEnumValue(enumValue); } return BooleanFieldValue.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(); } }
@Test public void parseCompoundOp() { expect("a.b==c", new FunctionCallNode( EqualFunction.INSTANCE, new CompoundExpr( new SymbolNode("a"), new SymbolNode("b")), new SymbolNode("c"))); }
@Test public void parseMax() { expect("max(A)", new FunctionCallNode(MaxFunction.INSTANCE, new SymbolNode("A"))); expect("max(A, B)", new FunctionCallNode(MaxFunction.INSTANCE, new SymbolNode("A"), new SymbolNode("B"))); expect("min(A, B, C)", new FunctionCallNode(MinFunction.INSTANCE, new SymbolNode("A"), new SymbolNode("B"), new SymbolNode("C"))); }
private FormulaNode compound(SymbolNode symbol) { FormulaNode result = symbol; while(lexer.hasNext() && lexer.peek().isDot()) { lexer.next(); SymbolNode field = symbol(); result = new CompoundExpr(result, field, new SourceRange(result.getSourceRange(), field.getSourceRange())); } return result; }
@Test public void parseNested() { expect("(1+2)/3", new FunctionCallNode(ArithmeticFunctions.DIVIDE, new GroupNode( new FunctionCallNode(ArithmeticFunctions.BINARY_PLUS, new ConstantNode(1), new ConstantNode(2))), new ConstantNode(3))); }
private List<FormulaNode> parsePermission(String filter) { FormulaNode formulaNode = FormulaParser.parse(filter); return Formulas.findBinaryTree(formulaNode, AndFunction.INSTANCE); }
private FormulaNode stringLiteral() { Token token = lexer.next(); assert token.getType() == TokenType.STRING_LITERAL; return new ConstantNode(token.getString(), new SourceRange(token)); }
private SymbolNode symbol(Token token) { assert token.getType() == TokenType.SYMBOL; return new SymbolNode(token); }
private FormulaNode enumLiteral() { Token token = lexer.next(); assert token.getType() == TokenType.SYMBOL; return new ConstantNode(token, new SourceRange(token)); }
@Test public void parseStringLiteral() { expect("A=='Foo'", call(EQ, symbol("A"), new ConstantNode("Foo"))); }
@Override public String asExpression() { return value.asExpression() + "." + field.asExpression(); }
@Test public void group() { expect("(false||true)&&true", new FunctionCallNode(AND, new GroupNode(new FunctionCallNode(OR, FALSE, TRUE)), TRUE) ); }
@Test public void parseFunctions() { expect("containsAll({f1},{v1})", new FunctionCallNode(ContainsAllFunction.INSTANCE, new SymbolNode("f1"), new SymbolNode("v1")) ); expect("!containsAll({f1},{v1})", new FunctionCallNode(NotFunction.INSTANCE, new FunctionCallNode(ContainsAllFunction.INSTANCE, new SymbolNode("f1"), new SymbolNode("v1")) )); }
@Test public void parseSimple() { expect("1", new ConstantNode(1)); expect("(1)", new GroupNode(new ConstantNode(1))); expect("1+2", new FunctionCallNode(PLUS, new ConstantNode(1), new ConstantNode(2))); }
@Test public void parseComparisons() { expect("A==B", new FunctionCallNode(EqualFunction.INSTANCE, new SymbolNode("A"), new SymbolNode("B"))); }