/** * Used by methods that visited a filter that produced one or more filters over the surrogate * feature type to combine them in an Or filter if necessary. * * @param combinedFilters * @return */ private Filter combineOred(List combinedFilters) { switch (combinedFilters.size()) { case 0: throw new IllegalArgumentException("No filters to combine"); case 1: return (Filter) combinedFilters.get(0); default: return ff.or(combinedFilters); } }
public Object visit(Or filter, Object arg1) { List list = visitBinaryLogicOp(filter); Filter unrolled = ff.or(list); return unrolled; }
private BinaryLogicOperator createLogicOperator( BinaryLogicOperator originalOperator, List<Filter> filters) { if (originalOperator instanceof Or) { return ff.or(filters); } else { return ff.and(filters); } }
public Object visit(Or filter, Object extraData) { List<Filter> newChildren = children(filter, targetFilter, extraData); if (newChildren.isEmpty()) { // every time you remove a filter from an Or // expression you get less stuff, so removing the last is ... return Filter.EXCLUDE; } else if (newChildren.size() == 1) { return newChildren.get(0); } else { return getFactory(extraData).or(newChildren); } }
public Object visit(Or filter, Object extraData) { List<Filter> children = filter.getChildren(); List<Filter> newChildren = new ArrayList<Filter>(); for (Iterator<Filter> iter = children.iterator(); iter.hasNext(); ) { Filter child = iter.next(); if (child != null) { Filter newChild = (Filter) child.accept(this, extraData); newChildren.add(newChild); } } return getFactory(extraData).or(newChildren); }
@Override public Object visit(Or filter, Object extraData) { // scan, clone and simplify the children List<Filter> filters = collect(filter, Or.class, extraData, new ArrayList<Filter>()); filters = basicOrSimplification(filters); filters = extraOrSimplification(extraData, filters); // we might end up with an empty list if (filters.size() == 0) { return Filter.EXCLUDE; } // remove the logic we have only one filter if (filters.size() == 1) { return filters.get(0); } // else return the cloned and simplified up list return getFactory(extraData).or(filters); }
public static Or or() { return f.or(propertyIsEqualTo(), propertyIsNotEqualTo()); }
static Or or() { return f.or(propertyIsEqualTo(), propertyIsNotEqualTo()); }
@Test public void testOr() { Filter result = filters.or(ff, a, b); assertEquals(ff.or(a, b), result); }
public void testLogicFilter() throws IllegalFilterException { testExp1 = new LiteralExpressionImpl(Integer.valueOf(45)); testExp2 = new LiteralExpressionImpl(Integer.valueOf(45)); testExp3 = new AttributeExpressionImpl(testSchema, "testInteger"); testExp4 = new AttributeExpressionImpl(testSchema, "testInteger"); PropertyIsEqualTo cFilter1 = ff.equals(testExp1, testExp2); PropertyIsEqualTo cFilter2 = ff.equals(testExp2, testExp4); org.opengis.filter.Filter logFilter1 = ff.and(cFilter1, cFilter2); org.opengis.filter.Filter logFilter2 = ff.and(cFilter1, cFilter2); assertTrue(logFilter1.equals(logFilter2)); logFilter1 = ff.not(cFilter2); assertTrue(!logFilter1.equals(logFilter2)); cFilter1 = ff.equals(testExp1, testExp3); logFilter2 = ff.not(cFilter1); assertTrue(logFilter1.equals(logFilter2)); assertTrue(!logFilter1.equals(ff.between(testExp1, testExp2, testExp3))); Or logFilter3 = ff.or(logFilter1, logFilter2); Or logFilter4 = ff.or(logFilter1, logFilter2); assertTrue(logFilter3.equals(logFilter4)); // Questionable behavior. Is this what we want? Or logFilter5 = ff.or(cFilter1, logFilter3); // does not change structure of logFilter3 Or logFilter6 = ff.or(logFilter4, cFilter1); // different structure, but same result assertTrue(logFilter5.equals(logFilter6)); // do we want these equal? assertTrue(logFilter4.equals(logFilter3)); // shouldn't they be equal? }
/** Should returns 1, 2, 10, 12(11 on index) */ private Filter totalIndexedFilterCase() { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(); List<Filter> filters = Arrays.asList( ff.or( ff.equals(ff.property(this.attName), ff.literal("station11")), ff.equals(ff.property(this.attId), ff.literal("st.1"))), ff.or( ff.equals(ff.property(this.attName), ff.literal("station10")), ff.equals(ff.property(this.attId), ff.literal("st.2")))); Filter filter = ff.or(filters); return filter; }
/** Should returns 1, 2, 5, 6, 10, 12(11 on index) */ @Override protected Filter partialIndexedFilter_2idxfilterResults() { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(); List<Filter> filters = Arrays.asList( ff.or( ff.equals(ff.property(this.attName), ff.literal("station11")), ff.equals(ff.property(this.attId), ff.literal("st.1"))), ff.like(ff.property(attLocationName), "*America*"), ff.or( ff.equals(ff.property(this.attName), ff.literal("station10")), ff.equals(ff.property(this.attId), ff.literal("st.2")))); Filter filter = ff.or(filters); return filter; } }
/** * Test the logic operators. * * @throws IllegalFilterException If the constructed filter is not valid. */ public void testLogic() throws IllegalFilterException { PropertyName testAttribute = fac.property("testString"); // Set up true sub filter PropertyIsEqualTo filterTrue = fac.equals(testAttribute, fac.literal("test string data")); // Set up false sub filter PropertyIsEqualTo filterFalse = fac.equals(testAttribute, fac.literal("incorrect test string data")); // Test OR for false negatives Or filter = fac.or( Arrays.asList( (org.opengis.filter.Filter) filterFalse, (org.opengis.filter.Filter) filterTrue)); assertAttributeName(filter, "testString"); }
private Filter totallyIndexedFilter() { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(); Filter filter = ff.or( ff.equals(ff.property("st:Station"), ff.literal("st.1")), ff.like(ff.property("st:Station/st:name"), "*fer*")); return filter; }
protected Filter totallyIndexedFilter() { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(); Filter filter = ff.or( ff.equals(ff.property(attId), ff.literal("st.1")), ff.like(ff.property(attName), "*fer*")); return filter; }
protected Filter totallyIndexedFilter2() { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(); Filter filter = ff.or( ff.equals(ff.property(attName), ff.literal("fer")), ff.like(ff.property(attName), "*mariela*")); return filter; }
private Filter totallyIndexedFilter2() { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(); Filter filter = ff.or( ff.equals(ff.property("st:Station/st:name"), ff.literal("fer")), ff.like(ff.property("st:Station/st:name"), "*mariela*")); return filter; }
@Test public void testOr() { Filter f = ff.or( ff.bbox("geom", -10, -10, 10, 10, null), ff.equals(ff.property("att"), ff.literal("10"))); Envelope env = (Envelope) f.accept(visitor, null); assertEquals(infinity, env); }
@Test public void testRemoveFilterCompound() { Or childOr = ff.or(Arrays.asList(new Filter[] {b, c, d})); And base = ff.and(a, childOr); Filter results = Filters.removeFilter(base, d, false); assertEquals("Filter should not be removed because it should not recurse", base, results); results = Filters.removeFilter(base, d); assertFalse("Results should be a new object with different children", base.equals(results)); childOr = ff.or(b, c); And expected = ff.and(a, childOr); assertEquals(expected, results); // again results = Filters.removeFilter(results, c); expected = ff.and(a, b); assertEquals(expected, results); // again results = Filters.removeFilter(results, a); assertEquals(b, results); // again results = Filters.removeFilter(results, b); assertEquals(Filter.INCLUDE, results); }
public void testFullySupports() { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(); try { logFilter = ff.and(gFilter, compFilter); assertTrue(capabilities.fullySupports(compFilter)); assertTrue(!(capabilities.fullySupports(gFilter))); assertTrue(!(capabilities.fullySupports(logFilter))); logFilter = ff.and( compFilter, ff.between(ff.property("sample"), ff.literal(1), ff.literal(2))); assertTrue(capabilities.fullySupports(logFilter)); logFilter = ff.or( logFilter, ff.between(ff.property("sample"), ff.literal(1), ff.literal(2))); assertTrue(capabilities.fullySupports(logFilter)); logFilter = ff.and(logFilter, gFilter); assertTrue(!(capabilities.fullySupports(logFilter))); } catch (IllegalFilterException e) { LOGGER.fine("Bad filter " + e); } } }