public static FunctionCallNode equals(FormulaNode x, FormulaNode y) { return new FunctionCallNode(EqualFunction.INSTANCE, x, y); }
private static FormulaNode stringContains(FormulaNode field, FilterConfig filter) { ConstantNode substring = new ConstantNode(Strings.nullToEmpty(filter.getValue())); FormulaNode string = field; return new FunctionCallNode(IsNumberFunction.INSTANCE, new FunctionCallNode(SearchFunction.INSTANCE, substring, string)); }
private static FormulaNode binaryTree(FormulaFunction function, Iterable<FormulaNode> nodes) { Iterator<FormulaNode> it = nodes.iterator(); FormulaNode expr = it.next(); while(it.hasNext()) { expr = new FunctionCallNode(function, expr, it.next()); } return expr; }
@Override public FormulaNode transform(Function<FormulaNode, FormulaNode> function) { List<FormulaNode> transformedArgs = new ArrayList<>(); for (FormulaNode argument : arguments) { transformedArgs.add(argument.transform(function)); } return function.apply(new FunctionCallNode(this.function, transformedArgs)); }
private static FormulaNode toDateFormula(FormulaNode field, FilterConfig filter) { return new FunctionCallNode(comparisonFilter(filter), field, dateValue(filter)); }
private FunctionCallNode binaryInfixCall(FormulaFunction op, FormulaNode left, FormulaNode right) { SourceRange source = new SourceRange(left.getSourceRange(), right.getSourceRange()); return new FunctionCallNode(op, Arrays.asList(left, right), source); }
@Test public void group() { expect("(false||true)&&true", new FunctionCallNode(AND, new GroupNode(new FunctionCallNode(OR, FALSE, TRUE)), TRUE) ); }
private static FormulaNode dateValue(FilterConfig filter) { // GXT serializes the date value as unix time value in milliseconds long time = Long.parseLong(filter.getValue()); Date date = new Date(time); LocalDate localDate = new LocalDate(date); return new FunctionCallNode(DateFunction.INSTANCE, new ConstantNode(localDate.getYear()), new ConstantNode(localDate.getMonthOfYear()), new ConstantNode(localDate.getDayOfMonth())); }
@Test public void parseCalc() { expect("{Exp}*{Alloc}*{InCostUnsp}/10000", new FunctionCallNode(FormulaFunctions.get("/"), new FunctionCallNode(FormulaFunctions.get("*"), new FunctionCallNode(FormulaFunctions.get("*"), new SymbolNode("Exp"), new SymbolNode("Alloc")), new SymbolNode("InCostUnsp")), new ConstantNode(10000))); }
@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 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))); }
@Test public void equalsComparison() { assertThat( new FunctionCallNode(IfFunction.INSTANCE, new FunctionCallNode(EqualFunction.INSTANCE, new ConstantNode(true), new ConstantNode(false)), new ConstantNode(true), new ConstantNode(false)).asExpression(), equalTo("if(true == false, true, false)")); }
@Test public void binaryInfix() { assertThat( new FunctionCallNode(PlusFunction.INSTANCE, new SymbolNode("X"), new SymbolNode("Y")).asExpression(), equalTo("X + Y")); }
@Test public void normalCall() { assertThat( new FunctionCallNode(MaxFunction.INSTANCE, new SymbolNode("X"), new SymbolNode("Y")).asExpression(), equalTo("max(X, Y)")); }
@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"))); }
@Test public void parseEqualsSign() { expect("true==false", new FunctionCallNode( EqualFunction.INSTANCE, new ConstantNode(true), new ConstantNode(false))); }
@Test public void parseComparisons() { expect("A==B", new FunctionCallNode(EqualFunction.INSTANCE, new SymbolNode("A"), new SymbolNode("B"))); }
@Test public void ifCall() { assertThat( new FunctionCallNode(IfFunction.INSTANCE, new ConstantNode(true), new ConstantNode(1), new ConstantNode(0)).asExpression(), equalTo("if(true, 1, 0)") ); }
@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 parseCompoundOp() { expect("a.b==c", new FunctionCallNode( EqualFunction.INSTANCE, new CompoundExpr( new SymbolNode("a"), new SymbolNode("b")), new SymbolNode("c"))); }