public static Filter or(Filter... operands) { List<Filter> ored = Lists.newArrayList(operands); return factory.or(ored); }
public static Filter or(List<Filter> operands) { if (operands.size() == 0) { return Filter.EXCLUDE; } else if (operands.size() == 1) { return operands.get(0); } else { return factory.or(operands); } }
/** * Returns a predicate that evaluates to {@code true} if either of its components evaluates to * {@code true}. * * <p>The components are evaluated in order, and evaluation will be "short-circuited" as soon as * a true predicate is found. */ public static Filter or(Filter op1, Filter op2) { List<Filter> children = new ArrayList<Filter>(); if (op1 instanceof Or) { children.addAll(((Or) op1).getChildren()); } else { children.add(op1); } if (op2 instanceof Or) { children.addAll(((Or) op2).getChildren()); } else { children.add(op2); } return factory.or(children); }
@SuppressWarnings("unchecked") private <T extends BinaryLogicOperator> T createOperator(T oldParent, List<Filter> children) { T result = null; if (oldParent instanceof And) { result = (T) ff.and(children); } else if (oldParent instanceof Or) { result = (T) ff.or(children); } return result; }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated modifiable */ public Object parse(ElementInstance instance, Node node, Object value) throws Exception { List<Filter> operands = FilterParsingUtils.BinaryLogicOperator_getChildFilters(node, filterfactory); return filterfactory.or(operands); } }
public void testExcludeAndProperty() { Filter result = (Filter) ff.or(Filter.EXCLUDE, property).accept(simpleVisitor, null); assertEquals(property, result); }
public void testExcludeOrProperty() { Filter result = (Filter) ff.or(Filter.EXCLUDE, property).accept(simpleVisitor, null); assertEquals(property, result); }
public void testExcludeOrExclude() { Filter result = (Filter) ff.or(Filter.EXCLUDE, Filter.EXCLUDE).accept(simpleVisitor, null); assertEquals(Filter.EXCLUDE, result); }
public void testIncludeOrProperty() { Filter result = (Filter) ff.or(Filter.INCLUDE, property).accept(simpleVisitor, null); assertEquals(Filter.INCLUDE, result); }
public void testRecurseAnd() { Filter test = ff.and(Filter.INCLUDE, ff.or(property, Filter.EXCLUDE)); assertEquals(property, test.accept(simpleVisitor, null)); }
public void testCoalesheNestedOr() { 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")); Or nested = ff.or(Arrays.asList(ff.or(Arrays.asList(eq, gt)), lt)); Or simplified = (Or) nested.accept(simpleVisitor, null); assertEquals(3, simplified.getChildren().size()); assertEquals(ff.or(Arrays.asList(eq, gt, lt)), simplified); }
private FeatureCollection<? extends FeatureType, ? extends Feature> indexFeatureCollection() throws IOException, URISyntaxException { Map<String, Serializable> params = new HashMap<>(); File dir = new File(getClass().getResource("/test-data/index/").toURI()); PropertyDataStore datastore = new PropertyDataStore(dir); FilterFactory ff1 = datastore.getFilterFactory(); Query query = new Query( "stationsIndex", ff1.or( ff1.equals(ff1.property("NAME"), ff1.literal("station2")), ff1.equals(ff1.property("NAME"), ff1.literal("station3")))); return datastore.getFeatureSource("stationsIndex").getFeatures(query); } }
public void testMassOrFilter() throws Exception { List filters = new ArrayList(); for (int i = 0; i < 10000; i++) { filters.add(ff.equals(ff.property(nameAtt), ff.literal("" + i))); } Or orFilter = ff.or(filters); visitor = newVisitor(simpleLogicalCaps); // this would have throw the thing into a stack overflow error orFilter.accept(visitor, null); assertEquals(orFilter, visitor.getFilterPre()); assertEquals(Filter.INCLUDE, visitor.getFilterPost()); }
public void testDualFilterNullOr() { Filter original = ff.or( Arrays.asList( ff.not(ff.isNull(ff.property("a"))), ff.isNull(ff.property("a")))); assertEquals(Filter.INCLUDE, original.accept(simpleVisitor, null)); }
@Test public void testMassOrFilter() throws Exception { List filters = new ArrayList(); for (int i = 0; i < 10000; i++) { filters.add(ff.equals(ff.property(nameAtt), ff.literal("" + i))); } Or orFilter = ff.or(filters); visitor = newVisitor(simpleLogicalCaps); // this would have throw the thing into a stack overflow error orFilter.accept(visitor, null); assertEquals(orFilter, visitor.getFilterPre()); assertEquals(Filter.INCLUDE, visitor.getFilterPost()); }
public void testDualFilterOr() { Or or = ff.or( Arrays.asList( ff.not(ff.equal(ff.property("a"), ff.literal(3), true)), ff.equal(ff.property("a"), ff.literal(3), true))); assertEquals(Filter.INCLUDE, or.accept(simpleVisitor, null)); }
public void testNegateBetween() { PropertyName prop = ff.property("prop"); Literal l10 = ff.literal(10); Literal l20 = ff.literal(20); Filter f = ff.not(ff.between(prop, l10, l20)); Filter result = (Filter) f.accept(simpleVisitor, null); assertEquals( ff.or(Arrays.asList((Filter) ff.less(prop, l10), ff.greater(prop, l20))), result); }
private <T> void testOrDisjointRanges(Class<T> type, T max, T min) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setFeatureType(schema); Filter original = ff.or( ff.greater(ff.property("a"), ff.literal(max)), ff.less(ff.property("a"), ff.literal(min))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(original, simplified); }
private <T> void testOrTouchingRanges(Class<T> type, T value) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); Filter original = ff.or( ff.greaterOrEqual(ff.property("a"), ff.literal(value)), ff.lessOrEqual(ff.property("a"), ff.literal(value))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(Filter.INCLUDE, simplified); }
public void testRangeExpression() throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "pop:String"); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); Function func = ff.function("parseLong", ff.property("pop")); Filter f1 = ff.less(func, ff.literal(20000)); Filter f2 = ff.between(func, ff.literal(20000), ff.literal(50000)); Filter or = ff.or(f1, f2); Filter simplified = (Filter) or.accept(visitor, null); assertEquals(ff.lessOrEqual(func, ff.literal(50000)), simplified); }