/** * Handles the special CQL expressions embedded in the style markers since the time * * @param expression */ private void visitCqlExpression(String expression) { Expression parsed = ExpressionExtractor.extractCqlExpressions(expression); if (parsed != null) parsed.accept(this, null); }
/** * Builds a CQL expression equivalent to the specified string, see class javadocs for rules on * how to build the expression in string form * * @param expression * @return */ public static Expression extractCqlExpressions(String expression) { return catenateExpressions(splitCqlExpressions(expression)); } }
public void testOpenLingering() { try { ExpressionExtractor.splitCqlExpressions("I'm a plain string ${bla"); fail("Double cql exp open, should have failed"); } catch (IllegalArgumentException e) { // fine } }
public void testCatenateOne() { Expression l = ff.literal("http://test?param="); Expression cat = ExpressionExtractor.catenateExpressions(Arrays.asList(l)); assertEquals(l, cat); }
public void testDoubleClose() { try { ExpressionExtractor.splitCqlExpressions("I'm a plain string ${bla}}"); fail("Double cql exp open, should have failed"); } catch (IllegalArgumentException e) { // fine } }
public void testCatenateTwo() { Literal l = ff.literal("http://test?param="); PropertyName pn = ff.property("intAttribute"); Expression cat = ExpressionExtractor.catenateExpressions(Arrays.asList(l, pn)); assertTrue(cat instanceof Function); Function f = (Function) cat; assertEquals("Concatenate", f.getName()); assertEquals(l, f.getParameters().get(0)); assertEquals(pn, f.getParameters().get(1)); }
/** * Parses an expression from its string representation. * * <p>The <tt>safe</tt> parameter when set to true will cause null to be returned when the * string can not be parsed as a ECQL expression. When false it will result in an exception * thrown back. * * @return The parsed expression, or null if the string value was empty. */ public static Expression expression(String value, boolean safe, Factory factory) { if (value.isEmpty()) { return null; } Expression expr = ExpressionExtractor.extractCqlExpressions(value); expr = unwrapConcatenates(expr, factory); // Expression expr = ECQL.toExpression(value, factory.filter); /* * if (expr instanceof PropertyName && !ATTRIBUTE_PATTERN.matcher(value).matches()) { // treat as literal return * factory.filter.literal(((PropertyName) expr).getPropertyName()); } */ return expr; }
public void testDoubleOpen() { try { ExpressionExtractor.splitCqlExpressions("I'm a plain string ${bla ${bla}"); fail("Double cql exp open, should have failed"); } catch (IllegalArgumentException e) { // fine } }
/** * Builds a CQL expression equivalent to the specified string, see class javadocs for * rules on how to build the expression in string form * @param expression * @return */ public static Expression extractCqlExpressions(String expression) { return catenateExpressions(splitCqlExpressions(expression)); } }
public void testCatenateThree() { Literal l1 = ff.literal("http://test?param="); PropertyName pn = ff.property("intAttribute"); Literal l2 = ff.literal("¶m2=foo"); Expression cat = ExpressionExtractor.catenateExpressions(Arrays.asList(l1, pn, l2)); assertTrue(cat instanceof Function); Function f = (Function) cat; assertEquals("Concatenate", f.getName()); assertEquals(l1, f.getParameters().get(0)); assertEquals(pn, f.getParameters().get(1)); assertEquals(l2, f.getParameters().get(2)); } }
protected Expression copyCqlExpression(Expression expression) { if (expression == null) return null; Expression simplified = null; if (expression instanceof Literal) { String value = expression.evaluate(null, String.class); if (value != null && value.startsWith("${")) { expression = ExpressionExtractor.extractCqlExpressions(value); } } simplified = (Expression) expression.accept(simplifier, ff); return simplified; }
public void testLiteralEscapes() { final String exp = "I'm a plain string \\\\ \\${bla bla\\}"; List<Expression> result = ExpressionExtractor.splitCqlExpressions(exp); assertEquals(1, result.size()); assertEquals(ff.literal("I'm a plain string \\ ${bla bla}"), result.get(0)); }
/** * @param entry * @return * @throws NumberFormatException */ private static Color getColor(ColorMapEntry entry) throws NumberFormatException { ColorMapUtilities.ensureNonNull("ColorMapEntry", entry); Expression color = entry.getColor(); ColorMapUtilities.ensureNonNull("color", color); String colorString = (String) color.evaluate(null, String.class); if (colorString != null && colorString.startsWith("${")) { color = ExpressionExtractor.extractCqlExpressions(colorString); colorString = color.evaluate(null, String.class); } ColorMapUtilities.ensureNonNull("colorString", colorString); return Color.decode(colorString); }
public void testLiteral() { final String exp = "I'm a plain string"; List<Expression> result = ExpressionExtractor.splitCqlExpressions(exp); assertEquals(1, result.size()); assertEquals(ff.literal("I'm a plain string"), result.get(0)); }
if (opacityValue == null && opacity instanceof Literal) { String opacityExp = opacity.evaluate(null, String.class); opacity = ExpressionExtractor.extractCqlExpressions(opacityExp); opacityValue = opacity.evaluate(null, Double.class);
public void testEscapesInside() { final String exp = "${strLength('\\\\\\${\\}')}"; List<Expression> result = ExpressionExtractor.splitCqlExpressions(exp); assertEquals(1, result.size()); assertEquals(ff.function("strLength", ff.literal("\\${}")), result.get(0)); }
location = ExpressionExtractor.extractCqlExpressions(strLocation); } catch (IllegalArgumentException e) { if (eg.getFormat() != null) { Expression formatExpression = ExpressionExtractor.extractCqlExpressions(eg.getFormat()); format = formatExpression.evaluate(feature, String.class);
public void testTwoExpressions() { final String exp = "${name}${age}"; List<Expression> result = ExpressionExtractor.splitCqlExpressions(exp); assertEquals(2, result.size()); assertEquals(ff.property("name"), result.get(0)); assertEquals(ff.property("age"), result.get(1)); }
if (expression != null) name = ExpressionExtractor.extractCqlExpressions(expression);
public void testSimpleExpressions() { final String exp = "I'm a ${name} expression of type ${type}"; List<Expression> result = ExpressionExtractor.splitCqlExpressions(exp); assertEquals(4, result.size()); assertEquals(ff.literal("I'm a "), result.get(0)); assertEquals(ff.property("name"), result.get(1)); assertEquals(ff.literal(" expression of type "), result.get(2)); assertEquals(ff.property("type"), result.get(3)); }