public void testIncludeAndExclude() { Filter result = (Filter) ff.and(Filter.INCLUDE, Filter.EXCLUDE).accept(simpleVisitor, null); assertEquals(Filter.EXCLUDE, result); }
public void testIncludeAndInclude() { Filter result = (Filter) ff.and(Filter.INCLUDE, Filter.INCLUDE).accept(simpleVisitor, null); assertEquals(Filter.INCLUDE, result); }
public void testExcludeAndExclude() { Filter result = (Filter) ff.and(Filter.EXCLUDE, Filter.EXCLUDE).accept(simpleVisitor, null); assertEquals(Filter.EXCLUDE, result); }
public void testIncludeAndProperty() { Filter result = (Filter) ff.and(Filter.INCLUDE, property).accept(simpleVisitor, null); assertEquals(property, result); }
public void testLogicFilterDuplication() throws IllegalFilterException { List filters = new ArrayList(); // create a filter Filter filter1 = fac.greater(fac.literal(2), fac.literal(1)); filters.add(filter1); Filter filter2 = fac.greater(fac.literal(4), fac.literal(3)); filters.add(filter2); And oldFilter = fac.and(filters); // duplicate it DuplicatingFilterVisitor visitor = new DuplicatingFilterVisitor((FilterFactory2) fac); Filter newFilter = (Filter) oldFilter.accept(visitor, null); // compare it assertNotNull(newFilter); // TODO: a decent comparison }
public void testCoalesheNestedAnd() { Filter eq = ff.equal(ff.property("A"), ff.literal("3"), true); Filter gt = ff.greater(ff.property("b"), ff.literal("3")); Filter lt = ff.less(ff.property("c"), ff.literal("5")); And nested = ff.and(Arrays.asList(ff.and(Arrays.asList(eq, gt)), lt)); And simplified = (And) nested.accept(simpleVisitor, null); assertEquals(3, simplified.getChildren().size()); assertEquals(ff.and(Arrays.asList(eq, gt, lt)), simplified); }
public void testRepeatedFilter() { Filter f1 = ff.equal(ff.property("a"), ff.literal(3), false); Filter f2 = ff.equal(ff.property("a"), ff.literal(3), false); Filter s1 = (Filter) ff.and(f1, f2).accept(simpleVisitor, null); assertEquals(f1, s1); Filter s2 = (Filter) ff.or(f1, f2).accept(simpleVisitor, null); assertEquals(f1, s2); Filter f3 = ff.greater(ff.property("a"), ff.property("b")); Filter s3 = (Filter) ff.and(Arrays.asList(f1, f2, f3)).accept(simpleVisitor, null); assertEquals(ff.and(Arrays.asList(f1, f3)), s3); Filter s4 = (Filter) ff.and(Arrays.asList(f3, f1, f2)).accept(simpleVisitor, null); assertEquals(ff.and(Arrays.asList(f3, f1)), s4); Filter s5 = (Filter) ff.and(Arrays.asList(f1, f3, f2)).accept(simpleVisitor, null); assertEquals(ff.and(Arrays.asList(f1, f3)), s5); Filter s6 = (Filter) ff.or(Arrays.asList(f1, f2, f3)).accept(simpleVisitor, null); assertEquals(ff.or(Arrays.asList(f1, f3)), s6); Filter s7 = (Filter) ff.or(Arrays.asList(f3, f1, f2)).accept(simpleVisitor, null); assertEquals(ff.or(Arrays.asList(f3, f1)), s7); Filter s8 = (Filter) ff.or(Arrays.asList(f1, f3, f2)).accept(simpleVisitor, null); assertEquals(ff.or(Arrays.asList(f1, f3)), s8); }
public void testLogicFilterDuplication() throws IllegalFilterException { // create a filter PropertyIsGreaterThan greater = fac.greater(fac.literal(2), fac.literal(1)); PropertyIsLessThan less = fac.less(fac.literal(3), fac.literal(4)); And and = fac.and(greater, less); // duplicate it DuplicatingFilterVisitor visitor = new DuplicatingFilterVisitor(); Filter newFilter = (Filter) and.accept(visitor, fac); // compare it assertNotNull(newFilter); assertEquals(and, newFilter); }
@Test public void testLogicFilterAnd() throws Exception { PropertyIsEqualTo equals = ff.equals(ff.property("measurement/result"), ff.literal(1.1)); PropertyIsGreaterThan greater = ff.greater(ff.property("measurement/determinand_description"), ff.literal("desc1")); And logicFilter = ff.and(equals, greater); Filter unrolled = (Filter) logicFilter.accept(visitor, null); assertNotNull(unrolled); assertTrue(unrolled instanceof And); assertNotSame(equals, unrolled); And sourceAnd = (And) unrolled; assertEquals(2, sourceAnd.getChildren().size()); Filter sourceEquals = (Filter) sourceAnd.getChildren().get(0); assertTrue(sourceEquals instanceof PropertyIsEqualTo); Expression left = ((PropertyIsEqualTo) sourceEquals).getExpression1(); Expression right = ((PropertyIsEqualTo) sourceEquals).getExpression2(); assertTrue(left instanceof PropertyName); assertTrue(right instanceof Literal); assertEquals("results_value", ((PropertyName) left).getPropertyName()); assertEquals(new Double(1.1), ((Literal) right).getValue()); Filter sourceGreater = (Filter) sourceAnd.getChildren().get(1); assertTrue(sourceGreater instanceof PropertyIsGreaterThan); left = ((PropertyIsGreaterThan) sourceGreater).getExpression1(); right = ((PropertyIsGreaterThan) sourceGreater).getExpression2(); assertTrue(left instanceof PropertyName); assertTrue(right instanceof Literal); assertEquals("determinand_description", ((PropertyName) left).getPropertyName()); assertEquals("desc1", ((Literal) right).getValue()); }
@Test public void testSimplifyRedundant() { PropertyIsBetween between = ff.between(ff.property("a"), ff.property("b"), ff.property("c")); PropertyIsEqualTo equal = ff.equal(ff.property("a"), ff.property("b"), false); And and = ff.and(between, equal); NullHandlingVisitor nh = new NullHandlingVisitor(); Filter nhResult = (Filter) and.accept(nh, null); SimplifyingFilterVisitor simplifier = new SimplifyingFilterVisitor(); Filter simplified = (Filter) nhResult.accept(simplifier, null); assertTrue(simplified instanceof And); Filter expected = ff.and( Arrays.asList( between, equal, propertyNotNull("a"), propertyNotNull("b"), propertyNotNull("c"))); assertEquals(expected, simplified); }
public static Selector combineAnd(List<Data> selectors, Object ctx) { if (selectors.size() == 1) { return selectors.get(0); } List<Filter> filters = new ArrayList<>(); FeatureType featureType = null; for (Data selector : selectors) { filters.add(selector.filter); featureType = selector.featureType; } org.opengis.filter.And and = FF.and(filters); SimplifyingFilterVisitor visitor; if (ctx instanceof SimplifyingFilterVisitor) { visitor = (SimplifyingFilterVisitor) ctx; } else { visitor = new UnboundSimplifyingFilterVisitor(); visitor.setFeatureType(featureType); } Filter simplified = (Filter) and.accept(visitor, null); if (Filter.INCLUDE.equals(simplified)) { return ACCEPT; } else if (Filter.EXCLUDE.equals(simplified)) { return REJECT; } else { return new Data(simplified); } }
newList.add(child); And and = getFactory(extraData).and(newList); Filter simplified = (Filter) and.accept(this, extraData); if (simplified == Filter.EXCLUDE) { continue;
public Query invertQuery( @DescribeParameter(name = "outputBBOX", description = "Georeferenced bounding box of the output") ReferencedEnvelope envelope, Query targetQuery, GridGeometry targetGridGeometry ) throws ProcessException { final BBOXRemovingFilterVisitor visitor = new BBOXRemovingFilterVisitor(); Filter filter = (Filter) targetQuery.getFilter().accept(visitor, null); final String geometryName = visitor.getGeometryPropertyName(); if (geometryName != null) { final BBOX bbox; try { if (envelope.getCoordinateReferenceSystem() != null) { envelope = envelope.transform(DefaultGeographicCRS.WGS84,false); } bbox = FILTER_FACTORY.bbox(geometryName, envelope.getMinX(), envelope.getMinY(), envelope.getMaxX(), envelope.getMaxY(), "EPSG:4326"); } catch (Exception e) { throw new ProcessException("Unable to create bbox filter for feature source", e); } filter = (Filter) FILTER_FACTORY.and(filter, bbox).accept(new SimplifyingFilterVisitor(), null); targetQuery.setFilter(filter); } final List<PropertyName> properties = new ArrayList<>(); properties.add(FILTER_FACTORY.property("_aggregation")); targetQuery.setProperties(properties); return targetQuery; }
@Test public void testLogicFilterAnd() throws Exception { PropertyIsEqualTo equals = ff.equals(ff.property("measurement/result"), ff.literal(1.1)); PropertyIsGreaterThan greater = ff.greater(ff .property("measurement/determinand_description"), ff.literal("desc1")); And logicFilter = ff.and(equals, greater); Filter unrolled = (Filter) logicFilter.accept(visitor, null); assertNotNull(unrolled); assertTrue(unrolled instanceof And); assertNotSame(equals, unrolled); And sourceAnd = (And) unrolled; assertEquals(2, sourceAnd.getChildren().size()); Filter sourceEquals = (Filter) sourceAnd.getChildren().get(0); assertTrue(sourceEquals instanceof PropertyIsEqualTo); Expression left = ((PropertyIsEqualTo) sourceEquals).getExpression1(); Expression right = ((PropertyIsEqualTo) sourceEquals).getExpression2(); assertTrue(left instanceof PropertyName); assertTrue(right instanceof Literal); assertEquals("results_value", ((PropertyName) left).getPropertyName()); assertEquals(new Double(1.1), ((Literal) right).getValue()); Filter sourceGreater = (Filter) sourceAnd.getChildren().get(1); assertTrue(sourceGreater instanceof PropertyIsGreaterThan); left = ((PropertyIsGreaterThan) sourceGreater).getExpression1(); right = ((PropertyIsGreaterThan) sourceGreater).getExpression2(); assertTrue(left instanceof PropertyName); assertTrue(right instanceof Literal); assertEquals("determinand_description", ((PropertyName) left).getPropertyName()); assertEquals("desc1", ((Literal) right).getValue()); }