private FilterFunction_sdonn getSDO_NN_Query(PropertyIsEqualTo filter) { Expression expr1 = filter.getExpression1(); Expression expr2 = filter.getExpression2(); if (expr2 instanceof FilterFunction_sdonn) { // switch position Expression tmp = expr1; expr1 = expr2; expr2 = tmp; } if (expr1 instanceof FilterFunction_sdonn) { if (!(expr2 instanceof Literal)) { throw new UnsupportedOperationException( "Unsupported usage of SDO_NN Oracle function: it can be compared only to a Boolean \"true\" value"); } Boolean nearest = (Boolean) evaluateLiteral((Literal) expr2, Boolean.class); if (nearest == null || !nearest.booleanValue()) { throw new UnsupportedOperationException( "Unsupported usage of SDO_NN Oracle function: it can be compared only to a Boolean \"true\" value"); } return (FilterFunction_sdonn) expr1; } else { return null; } }
private Object buildIN(Or filter, Object extraData) { StringBuilder output = FilterToTextUtil.asStringBuilder(extraData); List<Filter> children = filter.getChildren(); PropertyIsEqualTo first = (PropertyIsEqualTo) filter.getChildren().get(0); Expression left = first.getExpression1(); left.accept(expressionVisitor, output); output.append(" IN ("); for (Iterator<Filter> i = children.iterator(); i.hasNext(); ) { PropertyIsEqualTo child = (PropertyIsEqualTo) i.next(); Expression right = child.getExpression2(); right.accept(expressionVisitor, output); if (i.hasNext()) { output.append(","); } } output.append(")"); return output; }
public Object visit(PropertyIsEqualTo filter, Object data) { filter.getExpression1().accept(this, data); if (found) return found; filter.getExpression2().accept(this, data); return found; }
public Object visit(PropertyIsEqualTo filter, Object data) { data = filter.getExpression1().accept(this, data); data = filter.getExpression2().accept(this, data); return data; }
public Object visit(PropertyIsEqualTo filter, Object data) { data = filter.getExpression1().accept(this, data); if (found(data)) return data; data = filter.getExpression2().accept(this, data); return data; }
public Object visit(PropertyIsEqualTo filter, Object extraData) { Class targetType = getTargetType(filter.getExpression1(), filter.getExpression2()); Expression expr1 = optimize(filter.getExpression1(), extraData, targetType); Expression expr2 = optimize(filter.getExpression2(), extraData, targetType); boolean matchCase = filter.isMatchingCase(); return getFactory(extraData).equal(expr1, expr2, matchCase, filter.getMatchAction()); }
public Object visit(PropertyIsEqualTo filter, Object extraData) { Expression left = filter.getExpression1(); Expression right = filter.getExpression2(); final String type = "PropertyIsEqualTo"; start(type); left.accept(this, extraData); right.accept(this, extraData); end(type); return extraData; }
public Object visit(PropertyIsEqualTo filter, Object extraData) { ScalarCapabilities scalar = capabilities.getScalarCapabilities(); if (scalar == null) return false; ComparisonOperators operators = scalar.getComparisonOperators(); if (operators == null) return false; if (operators.getOperator(PropertyIsEqualTo.NAME) == null) return false; return (Boolean) filter.getExpression1().accept(this, null) && (Boolean) filter.getExpression2().accept(this, null); }
public Object visit(PropertyIsEqualTo filter, Object extraData) { Expression expr1 = visit(filter.getExpression1(), extraData); Expression expr2 = visit(filter.getExpression2(), extraData); boolean matchCase = filter.isMatchingCase(); return getFactory(extraData).equal(expr1, expr2, matchCase, filter.getMatchAction()); }
public void testRun() throws Exception { Object thing = parser.parse(getClass().getResourceAsStream("test1.xml")); assertNotNull(thing); assertTrue(thing instanceof PropertyIsEqualTo); PropertyIsEqualTo equal = (PropertyIsEqualTo) thing; assertTrue(equal.getExpression1() instanceof PropertyName); assertTrue(equal.getExpression2() instanceof Literal); PropertyName name = (PropertyName) equal.getExpression1(); assertEquals("testString", name.getPropertyName()); Literal literal = (Literal) equal.getExpression2(); assertEquals("2", literal.toString()); }
public void testParse() throws Exception { Parser parser = new Parser(new OGCConfiguration()); InputStream in = getClass().getResourceAsStream("test1.xml"); if (in == null) { throw new FileNotFoundException(getClass().getResource("test1.xml").toExternalForm()); } Object thing = parser.parse(in); assertEquals(0, parser.getValidationErrors().size()); assertNotNull(thing); assertTrue(thing instanceof PropertyIsEqualTo); PropertyIsEqualTo equal = (PropertyIsEqualTo) thing; assertTrue(equal.getExpression1() instanceof PropertyName); assertTrue(equal.getExpression2() instanceof Literal); PropertyName name = (PropertyName) equal.getExpression1(); assertEquals("testString", name.getPropertyName()); Literal literal = (Literal) equal.getExpression2(); assertEquals("2", literal.toString()); }
@Test public void testFilterFunctionNoMarker() throws Exception { String yaml = "rules: \n" + "- filter: strEndsWith(foo,'bar') = true\n"; StyledLayerDescriptor sld = Ysld.parse(yaml); Rule r = SLD.defaultStyle(sld).featureTypeStyles().get(0).rules().get(0); PropertyIsEqualTo f = (PropertyIsEqualTo) r.getFilter(); Function func = (Function) f.getExpression1(); assertEquals("strEndsWith", func.getName()); assertTrue(func.getParameters().get(0) instanceof PropertyName); assertTrue(func.getParameters().get(1) instanceof Literal); Literal lit = (Literal) f.getExpression2(); }
@Test public void testFilterFunctionWithMarker() throws Exception { String yaml = "rules: \n" + "- filter: ${strEndsWith(foo,'bar') = true}\n"; StyledLayerDescriptor sld = Ysld.parse(yaml); Rule r = SLD.defaultStyle(sld).featureTypeStyles().get(0).rules().get(0); PropertyIsEqualTo f = (PropertyIsEqualTo) r.getFilter(); Function func = (Function) f.getExpression1(); assertEquals("strEndsWith", func.getName()); assertTrue(func.getParameters().get(0) instanceof PropertyName); assertTrue(func.getParameters().get(1) instanceof Literal); Literal lit = (Literal) f.getExpression2(); }
@Test public void testFilterWithEscape() throws Exception { String yaml = "rules: \n" + "- filter: ${foo = '\\$\\}'}\n"; StyledLayerDescriptor sld = Ysld.parse(yaml); Rule r = SLD.defaultStyle(sld).featureTypeStyles().get(0).rules().get(0); Filter f = r.getFilter(); assertThat(f, Matchers.instanceOf(PropertyIsEqualTo.class)); assertThat(((PropertyIsEqualTo) f).getExpression1(), attribute("foo")); assertThat(((PropertyIsEqualTo) f).getExpression2(), literal("$}")); }
public void testPropertyIsEqualToParse() throws Exception { FilterMockData.propertyIsEqualTo(document, document); PropertyIsEqualTo equalTo = (PropertyIsEqualTo) parse(); assertNotNull(equalTo); assertNotNull(equalTo.getExpression1()); assertNotNull(equalTo.getExpression2()); }
public void testPropertyIsEqualToParse() throws Exception { FilterMockData.propertyIsEqualTo(document, document); PropertyIsEqualTo equalTo = (PropertyIsEqualTo) parse(); assertNotNull(equalTo); assertNotNull(equalTo.getExpression1()); assertNotNull(equalTo.getExpression2()); }
@Test public void equalsTest() { // forward PropertyIsEqualTo source = ff.equal(ff.property("i"), ff.literal("10"), true); PropertyIsEqualTo bound = (PropertyIsEqualTo) source.accept(visitor, null); assertEquals(Integer.valueOf(10), ((Literal) bound.getExpression2()).getValue()); // flip it source = ff.equal(ff.literal("10"), ff.property("i"), true); bound = (PropertyIsEqualTo) source.accept(visitor, null); assertEquals(Integer.valueOf(10), ((Literal) bound.getExpression1()).getValue()); }
public void testLiteralWithEntity() throws Exception { String xml = "<Filter>" + " <PropertyIsEqualTo>" + " <PropertyName>foo</PropertyName>" + " <Literal>bar > 10 and < 20</Literal>" + " </PropertyIsEqualTo>" + "</Filter>"; Parser parser = new Parser(new OGCConfiguration()); parser.setStrict(false); Filter filter = (Filter) parser.parse(new ByteArrayInputStream(xml.getBytes())); assertNotNull(filter); PropertyIsEqualTo equal = (PropertyIsEqualTo) filter; PropertyName pn = (PropertyName) equal.getExpression1(); assertEquals("foo", pn.getPropertyName()); Literal literal = (Literal) equal.getExpression2(); assertEquals("bar > 10 and < 20", literal.getValue()); }
public void testPropertyEqualWithFunction() throws Exception { Function function = new GeometryFunction(); // see if coordinates gets flipped, urn forces lat/lon interpretation PropertyIsEqualTo original = ff.equals(ff.property("geom"), function); PropertyIsEqualTo clone = (PropertyIsEqualTo) original.accept(reprojector, null); assertNotSame(original, clone); assertEquals(clone.getExpression1(), original.getExpression1()); LineString clonedLs = (LineString) clone.getExpression2().evaluate(null); assertTrue(15 == clonedLs.getCoordinateN(0).x); assertTrue(10 == clonedLs.getCoordinateN(0).y); assertTrue(25 == clonedLs.getCoordinateN(1).x); assertTrue(20 == clonedLs.getCoordinateN(1).y); assertEquals(CRS.decode("EPSG:4326"), clonedLs.getUserData()); }
@Test public void testCompareFilter() throws Exception { PropertyIsEqualTo complexFilter = ff.equal(ff.property("measurement/result"), ff.literal(1.1), true, MatchAction.ALL); Filter unrolled = (Filter) complexFilter.accept(visitor, null); assertNotNull(unrolled); assertTrue(unrolled instanceof PropertyIsEqualTo); assertNotSame(complexFilter, unrolled); assertTrue(((PropertyIsEqualTo) unrolled).isMatchingCase()); assertEquals(MatchAction.ALL, ((PropertyIsEqualTo) unrolled).getMatchAction()); Expression left = ((PropertyIsEqualTo) unrolled).getExpression1(); Expression right = ((PropertyIsEqualTo) unrolled).getExpression2(); assertTrue(left instanceof PropertyName); assertTrue(right instanceof Literal); PropertyName attExp = (PropertyName) left; String expectedAtt = "results_value"; assertEquals(expectedAtt, attExp.getPropertyName()); assertEquals(new Double(1.1), ((Literal) right).getValue()); }