/** * A convenience method to make an expression from a string. Evaluates the * expression with respect to the current query. * * @param expression The expression to parse. * @return the Expr object. * @throws QueryParseException on error. */ public Expr makeExpr(String expression) throws QueryParseException { return ExprUtils.parse(query, expression, true); }
/** * A convenience method to make an expression from a string. Evaluates the * expression with respect to the current query. * * @param expression The expression to parse. * @return the Expr object. * @throws QueryParseException on error. */ public Expr makeExpr(String expression) throws QueryParseException { return ExprUtils.parse(query, expression, true); }
public void put(Var var, String v) { super.put(var, ExprUtils.parse(v)) ; }
public static Expr parse(String s) { return parse(s, ARQConstants.getGlobalPrefixMap()) ; }
private static void testSyntax(String exprString) { ExprUtils.parse(query, exprString, false) ; }
public static void expr(String exprStr, Binding binding) { try { Expr expr = ExprUtils.parse(exprStr, ARQConstants.getGlobalPrefixMap()) ; evalPrint(expr, binding) ; } catch (QueryParseException ex) { System.err.println("Parse error: "+ex.getMessage()) ; return ; } }
/** * Add an expression string as a filter. * * @param expression * The expression string to add. * @throws ParseException * If the expression can not be parsed. */ public void addFilter(String expression) throws ParseException { getClause().addElement(new ElementFilter(ExprUtils.parse(query, expression, true))); }
private Expr parseExpr(String expression) { Query query = new Query(); query.setPrefixMapping(prefixHandler.getPrefixes()); return ExprUtils.parse(query, expression, true); }
private Expr parseExpr(String expression) { Query query = new Query(); query.setPrefixMapping(prefixHandler.getPrefixes()); return ExprUtils.parse(query, expression, true); }
/** * Add an expression string as a filter. * * @param expression * The expression string to add. * @throws ParseException * If the expression can not be parsed. */ public void addFilter(String expression) throws ParseException { getClause().addElement(new ElementFilter(ExprUtils.parse(query, expression, true))); }
private static void testSafeEquality(String string, boolean b) { Expr expr = ExprUtils.parse(string) ; Assert.assertEquals(string, b, ExprLib.isAssignmentSafeEquality(expr)) ; }
private void testEqual(String exprStr, String exprStrExpected) { Expr expr = ExprUtils.parse(exprStrExpected) ; NodeValue rExpected = expr.eval(null, LibTestExpr.createTest()) ; test(exprStr, rExpected) ; }
/*package*/ static void eval(String string, boolean result) { Expr expr = ExprUtils.parse(string) ; NodeValue nv = expr.eval(null, LibTestExpr.createTest()) ; boolean b = XSDFuncOp.booleanEffectiveValue(nv) ; assertEquals(string, result, b) ; } }
static void test(String exprString, Node result) { Expr expr = ExprUtils.parse(exprString, pmap); NodeValue actual = expr.eval(null, new FunctionEnvBase()); NodeValue expected = NodeValue.makeNode(result); assertTrue("Expected = " + expected + " : Actual = " + actual, NodeValue.sameAs(expected, actual)) ; }
private static void eval(String string, String bindingStr, boolean expected) { Binding binding = binding(bindingStr) ; Expr expr = ExprUtils.parse(string) ; NodeValue nv = expr.eval(binding, LibTestExpr.createTest()) ; boolean b = XSDFuncOp.booleanEffectiveValue(nv) ; assertEquals(string, expected, b) ; }
private NodeValue cast(String input$) { Expr input = ExprUtils.parse(input$) ; ARQ.getContext().set(ARQConstants.sysCurrentTime, NodeFactoryExtra.nowAsDateTime()) ; FunctionEnv env = new ExecutionContext(ARQ.getContext(), null, null, null) ; return input.eval(null, env) ; } }
static void testDouble(String exprString, Node result, double delta) { Expr expr = ExprUtils.parse(exprString, pmap); NodeValue actual = expr.eval(null, new FunctionEnvBase()); NodeValue expected = NodeValue.makeNode(result); // Note that we don't test lexical form because we can get mismatches // between how things like doubles are expressed if (NodeValue.sameAs(expected, actual)) return; testDouble(exprString, expected.getDouble(), delta); ; }
private static void testNumberFormat(String expression, String expected) { Expr expr = ExprUtils.parse(expression) ; NodeValue r = expr.eval(null, LibTestExpr.createTest()) ; Assert.assertTrue(r.isString()); Assert.assertEquals(expected, r.getString()) ; }
private static void test(String string, String result) { Expr expr = ExprUtils.parse(string, pmap) ; NodeValue nv = expr.eval(null, new FunctionEnvBase()) ; Node r = NodeFactoryExtra.parseNode(result) ; NodeValue nvr = NodeValue.makeNode(r) ; assertTrue("Not same value: Expected: "+nvr+" : Actual = "+nv, NodeValue.sameAs(nvr, nv)) ; // test result must be lexical form exact. assertEquals(r, nv.asNode()) ; }
static void test(String string, String result) { Expr expr = ExprUtils.parse(string, pmap) ; NodeValue nv = expr.eval(null, new FunctionEnvBase()) ; Node r = NodeFactoryExtra.parseNode(result) ; NodeValue nvr = NodeValue.makeNode(r) ; assertTrue("Not same value: Expected: " + nvr + " : Actual = " + nv, NodeValue.sameAs(nvr, nv)) ; // test result must be lexical form exact. assertEquals(r, nv.asNode()) ; } }