public Object visit(PropertyIsLessThanOrEqualTo filter, Object arg1) { Expression[][] expressions = visitBinaryComparisonOperator(filter); List combinedFilters = new ArrayList(expressions.length); for (int i = 0; i < expressions.length; i++) { Expression left = expressions[i][0]; Expression right = expressions[i][1]; Filter unrolled = ff.lessOrEqual(left, right, filter.isMatchingCase(), filter.getMatchAction()); combinedFilters.add(unrolled); } Filter unrolled = combineOred(combinedFilters); return unrolled; }
/** Delegates to FilterFactory2 */ public static boolean lessEqualThan(Object o1, Object o2) { return getFilterFactory2().lessOrEqual(ff.literal(o1), ff.literal(o2)).evaluate(null); }
static PropertyIsLessThanOrEqualTo propertyIsLessThanOrEqualTo() { return f.lessOrEqual(propertyName(), literal()); }
public static PropertyIsLessThanOrEqualTo propertyIsLessThanOrEqualTo() { return f.lessOrEqual(propertyName(), literal()); }
return FILTER_FACT.lessOrEqual(left, right);
public Object visit(PropertyIsLessThanOrEqualTo filter, Object extraData) { Expression expr1 = visit(filter.getExpression1(), extraData); Expression expr2 = visit(filter.getExpression2(), extraData); return getFactory(extraData) .lessOrEqual(expr1, expr2, filter.isMatchingCase(), filter.getMatchAction()); }
return factory.lessOrEqual(expr1, expr2);
return factory.lessOrEqual(expr1, expr2);
filters.add( ff.and( ff.lessOrEqual( ff.property(propertyName), ff.literal(range.getMaxValue())), ff.literal(maxValue), ff.property(propertyName)); Filter minCondition = ff.lessOrEqual( ff.literal(minValue), ff.property(additionalPropertyName)); ff.lessOrEqual(ff.property(propertyName), ff.literal(value)), ff.greaterOrEqual( ff.property(additionalPropertyName),
FeatureUtilities.DEFAULT_FILTER_FACTORY.lessOrEqual( FeatureUtilities.DEFAULT_FILTER_FACTORY.property( timeFilterAttribute), FeatureUtilities.DEFAULT_FILTER_FACTORY.lessOrEqual( FeatureUtilities.DEFAULT_FILTER_FACTORY.property( elevationFilterAttribute),
@Override public Object visit(PropertyIsLessThanOrEqualTo 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).lessOrEqual(expr1, expr2, matchCase, filter.getMatchAction()); }
/** * Builds a filter that compares a and b: <code>a compare b</code> * * @param filterType * @param a * @param b * @return */ org.opengis.filter.Filter compare( Class filterType, org.opengis.filter.expression.Expression a, org.opengis.filter.expression.Expression b) { if (filterType == PropertyIsLessThan.class) { return fac.less(a, b); } else if (filterType == PropertyIsLessThanOrEqualTo.class) { return fac.lessOrEqual(a, b); } if (filterType == PropertyIsEqualTo.class) { return fac.equals(a, b); } else if (filterType == PropertyIsGreaterThanOrEqualTo.class) { return fac.greaterOrEqual(a, b); } else if (filterType == PropertyIsGreaterThan.class) { return fac.greater(a, b); } else { throw new IllegalArgumentException("Uknown compare filter type " + filterType); } }
public void testCapablities_PropertyIsLessThanOrEqualTo() { Capabilities capabilities = new Capabilities(); capabilities.addAll(Capabilities.SIMPLE_COMPARISONS); FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(null); Filter filter = ff.lessOrEqual(ff.property("x"), ff.literal(2)); assertTrue("supports", capabilities.supports(filter)); }
less = FF.less(PERSONS, FF.literal(rangedClassifier.getMax(i))); } else { less = FF.lessOrEqual(PERSONS, FF.literal(rangedClassifier.getMax(i)));
} else if (simplified instanceof PropertyIsGreaterThan) { PropertyIsGreaterThan pg = (PropertyIsGreaterThan) simplified; return ff.lessOrEqual( pg.getExpression1(), pg.getExpression2(), pg.isMatchingCase()); } else if (simplified instanceof PropertyIsGreaterThanOrEqualTo) {
assertFalse(filter.evaluate(null)); filter = fac.lessOrEqual(e1, new LiteralExpressionImpl(10000.5), false, MatchAction.ALL); assertTrue(filter.evaluate(null)); filter = fac.lessOrEqual(e1, new LiteralExpressionImpl(201.7), false, MatchAction.ALL); assertFalse(filter.evaluate(null)); filter = fac.lessOrEqual(new LiteralExpressionImpl(35.2), e1, false, MatchAction.ALL); assertTrue(filter.evaluate(null)); filter = fac.lessOrEqual(new LiteralExpressionImpl(201.7), e1, false, MatchAction.ALL); assertFalse(filter.evaluate(null));
assertFalse(filter.evaluate(null)); filter = fac.lessOrEqual(e1, new LiteralExpressionImpl(35.2), false, MatchAction.ONE); assertTrue(filter.evaluate(null)); filter = fac.lessOrEqual(e1, new LiteralExpressionImpl(10001), false, MatchAction.ONE); assertFalse(filter.evaluate(null)); filter = fac.lessOrEqual(new LiteralExpressionImpl(10000.5), e1, false, MatchAction.ONE); assertTrue(filter.evaluate(null)); filter = fac.lessOrEqual(new LiteralExpressionImpl(201.7), e1, false, MatchAction.ONE); assertFalse(filter.evaluate(null));
assertFalse(filter.evaluate(null)); filter = fac.lessOrEqual(e, new LiteralExpressionImpl(35.2)); assertTrue(filter.evaluate(null)); filter = fac.lessOrEqual(e, new LiteralExpressionImpl(35)); assertFalse(filter.evaluate(null)); filter = fac.lessOrEqual(new LiteralExpressionImpl(10000.5), e); assertTrue(filter.evaluate(null)); filter = fac.lessOrEqual(new LiteralExpressionImpl(10001), e); assertFalse(filter.evaluate(null));
public Object visit(PropertyIsLessThanOrEqualTo filter, Object extraData) { Expression expr1 = visitBinaryChild(filter.getExpression1(), extraData, 0); Expression expr2 = visitBinaryChild(filter.getExpression2(), extraData, 1); return getFactory(extraData) .lessOrEqual(expr1, expr2, filter.isMatchingCase(), filter.getMatchAction()); } }
filter = fac.greater(expr1, expr2, false); assertEquals(filter.getMatchAction(), MatchAction.ANY); filter = fac.lessOrEqual(expr1, expr2, false); assertEquals(filter.getMatchAction(), MatchAction.ANY); filter = fac.greaterOrEqual(expr1, expr2, false); filter = fac.greater(expr1, expr2, false, MatchAction.ALL); assertEquals(filter.getMatchAction(), MatchAction.ALL); filter = fac.lessOrEqual(expr1, expr2, false, MatchAction.ONE); assertEquals(filter.getMatchAction(), MatchAction.ONE); filter = fac.greaterOrEqual(expr1, expr2, false, MatchAction.ALL);