public static Filter equal( final String property, final Object expected, final MatchAction matchAction) { final boolean matchCase = true; return factory.equal( factory.property(property), factory.literal(expected), matchCase, matchAction); }
private CatalogInfo replaceCatalogInfo(CatalogInfo ci) { String id = ci.getId(); Catalog catalog = (Catalog) GeoServerExtensions.bean("catalog"); FilterFactory ff = CommonFactoryFinder.getFilterFactory(); Class iface = getCatalogInfoInterface(ci.getClass()); CatalogInfo replacement = catalog.get(iface, ff.equal(ff.property("id"), ff.literal(id), true)); return replacement; }
filter = factory.equal(factory.literal(ft1.getId()), factory.property("id"), true); expected = Sets.newHashSet(ft1); actual = Sets.newHashSet(catalog.list(ResourceInfo.class, filter)); filter = factory.equal(factory.literal("FT1"), factory.property("name"), false); expected = Sets.newHashSet(ft1); actual = Sets.newHashSet(catalog.list(ResourceInfo.class, filter)); filter = factory.equal(factory.property("name"), factory.property("description"), true); expected = Sets.newHashSet(ft2); actual = Sets.newHashSet(catalog.list(ResourceInfo.class, filter)); filter = factory.equal(factory.property("name"), factory.property("description"), false); expected = Sets.newHashSet(ft2, ft3); actual = Sets.newHashSet(catalog.list(ResourceInfo.class, filter)); factory.equal( factory.literal(new Keyword("keyword1")), factory.property("keywords"), factory.equal( factory.literal(new Keyword("keyword1")), factory.property("keywords"), factory.equal( factory.literal(new Keyword("keyword1")), factory.property("keywords"), values.add("ft2");
public WrappedCoverageSlicesCatalog( DataStoreConfiguration config, File file, Repository repository) throws IOException { super(config, repository); queryFilter = FF.equal( FF.property(CoverageSlice.Attributes.LOCATION), FF.literal(file.getCanonicalPath()), true); }
static Filter lookupExtendedOperator( Name opName, List<Expression> expressions, org.opengis.filter.FilterFactory factory) { FunctionFinder finder = new FunctionFinder(null); Function f = finder.findFunction(opName.getLocalPart(), expressions); return factory.equal(f, factory.literal(true), true); } }
public void testCaseSensitivity() { Expression e1 = filterFactory.literal("foo"); Expression e2 = filterFactory.literal("FoO"); PropertyIsEqualTo caseSensitive = filterFactory.equal(e1, e2, true); assertFalse(caseSensitive.evaluate(null)); PropertyIsEqualTo caseInsensitive = filterFactory.equal(e1, e2, false); assertTrue(caseInsensitive.evaluate(null)); } }
public void testVisitor() throws IOException { Filter filter = ff.equal(ff.property("someAtt"), ff.literal("1"), false); SimpleFeatureCollection collection = new FilteringSimpleFeatureCollection(delegate, filter); collection.accepts( new FeatureVisitor() { public void visit(Feature feature) { assertEquals(1, feature.getProperty("someAtt").getValue()); } }, null); }
public void testResolvePropertyName() { PropertyIsEqualTo f = factory.equal(factory.property("gml:name"), factory.literal("foo"), true); assertEquals("gml:name", f.getExpression1().toString()); f = (PropertyIsEqualTo) f.accept(new PropertyNameResolvingVisitor(featureType), null); assertEquals("name", f.getExpression1().toString()); }
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 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); }
public void testCompareConstantFunction() { EnvFunction.setLocalValue("var", "test"); Function f = ff.function("env", ff.literal("var")); PropertyIsEqualTo filter = ff.equal(f, ff.literal("test"), false); Filter simplified = (Filter) filter.accept(simpleVisitor, null); assertEquals(Filter.INCLUDE, simplified); }
public void testNext() { Filter filter = ff.equal(ff.property("someAtt"), ff.literal("1"), false); SimpleFeatureCollection collection = new FilteringSimpleFeatureCollection(delegate, filter); assertNotNull(collection.features().next()); }
public void testCaseInsensitiveFilter() throws Exception { FilterFactory ff = dataStore.getFilterFactory(); PropertyIsEqualTo sensitive = ff.equal(ff.property(aname("stringProperty")), ff.literal("OnE"), true); PropertyIsEqualTo insensitive = ff.equal(ff.property(aname("stringProperty")), ff.literal("OnE"), false); assertEquals(0, featureSource.getCount(new Query(null, sensitive))); assertEquals(1, featureSource.getCount(new Query(null, insensitive))); }
public void testSimplifyNegateImpossible() throws Exception { PropertyIsEqualTo propertyIsEqualTo = ff.equal(ff.literal("a"), ff.literal("b"), true); Not negated = ff.not(propertyIsEqualTo); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); SimpleFeatureType schema = DataUtilities.createType("test", "pop:String"); visitor.setFeatureType(schema); Filter simplified = (Filter) negated.accept(visitor, null); assertEquals(Filter.INCLUDE, simplified); } }
public void testSimpleNegation() throws Exception { Not filter = ff.not(ff.equal(ff.property(aname(A)), ff.literal(10), false)); ContentFeatureSource fs = dataStore.getFeatureSource(tname(ABC)); int count = fs.getCount(new Query(tname(ABC), filter)); assertEquals(2, count); }
public void testSimpleIn() throws IOException { FilterFactory ff = dataStore.getFilterFactory(); Function function = ff.function( "in", ff.property(aname("intProperty")), ff.literal("1"), ff.literal("2")); Filter filter = ff.equal(function, ff.literal("true"), false); SimpleFeatureSource fs = dataStore.getFeatureSource(tname("ft1")); SimpleFeatureCollection fc = fs.getFeatures(filter); assertEquals(getCaseInsensitiveSet("ft1.1", "ft1.2"), collectFeatureIds(fc)); }
public void testNegated() throws IOException { FilterFactory ff = dataStore.getFilterFactory(); Function function = ff.function( "in", ff.property(aname("intProperty")), ff.literal("1"), ff.literal("2")); Filter filter = ff.not(ff.equal(function, ff.literal("true"), false)); SimpleFeatureSource fs = dataStore.getFeatureSource(tname("ft1")); SimpleFeatureCollection fc = fs.getFeatures(filter); assertEquals(getCaseInsensitiveSet("ft1.0"), collectFeatureIds(fc)); }
public void testSimplifyStaticExclude() { assertEquals(Filter.EXCLUDE, simplify(ff.greater(ff.literal(3), ff.literal(5)))); assertEquals(Filter.EXCLUDE, simplify(ff.greaterOrEqual(ff.literal(3), ff.literal(5)))); assertEquals(Filter.EXCLUDE, simplify(ff.less(ff.literal(5), ff.literal(3)))); assertEquals(Filter.EXCLUDE, simplify(ff.lessOrEqual(ff.literal(5), ff.literal(3)))); assertEquals(Filter.EXCLUDE, simplify(ff.equal(ff.literal(5), ff.literal(3), true))); assertEquals( Filter.EXCLUDE, simplify(ff.between(ff.literal(3), ff.literal(1), ff.literal(2)))); }
public void testSimplifyStaticInclude() { assertEquals(Filter.INCLUDE, simplify(ff.less(ff.literal(3), ff.literal(5)))); assertEquals(Filter.INCLUDE, simplify(ff.lessOrEqual(ff.literal(3), ff.literal(5)))); assertEquals(Filter.INCLUDE, simplify(ff.greater(ff.literal(5), ff.literal(3)))); assertEquals(Filter.INCLUDE, simplify(ff.greaterOrEqual(ff.literal(5), ff.literal(3)))); assertEquals(Filter.INCLUDE, simplify(ff.equal(ff.literal(5), ff.literal(5), true))); assertEquals( Filter.INCLUDE, simplify(ff.between(ff.literal(3), ff.literal(1), ff.literal(4)))); }