public Object visit(PropertyIsGreaterThanOrEqualTo 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.greaterOrEqual( left, right, filter.isMatchingCase(), filter.getMatchAction()); combinedFilters.add(unrolled); } Filter unrolled = combineOred(combinedFilters); return unrolled; }
/** Delegates to FilterFactory2 */ public static boolean greaterEqualThan(Object o1, Object o2) { return getFilterFactory2().greaterOrEqual(ff.literal(o1), ff.literal(o2)).evaluate(null); }
isIncludedInThreshold = ff.greater(lookupExp, threshholdExp); } else { isIncludedInThreshold = ff.greaterOrEqual(lookupExp, threshholdExp);
public static PropertyIsGreaterThanOrEqualTo propertyIsGreaterThanOrEqualTo() { return f.greaterOrEqual(propertyName(), literal()); }
static PropertyIsGreaterThanOrEqualTo propertyIsGreaterThanOrEqualTo() { return f.greaterOrEqual(propertyName(), literal()); }
return FILTER_FACT.greaterOrEqual(left, right);
public Object visit(PropertyIsGreaterThanOrEqualTo filter, Object extraData) { Expression expr1 = visit(filter.getExpression1(), extraData); Expression expr2 = visit(filter.getExpression2(), extraData); return getFactory(extraData) .greaterOrEqual(expr1, expr2, filter.isMatchingCase(), filter.getMatchAction()); }
return factory.greaterOrEqual(expr1, expr2);
return factory.greaterOrEqual(expr1, expr2);
ff.property(propertyName), ff.literal(range.getMaxValue())), ff.greaterOrEqual( ff.property(propertyName), ff.literal(range.getMinValue())))); ff.greaterOrEqual( ff.literal(maxValue), ff.property(propertyName)); Filter minCondition = ff.and( ff.lessOrEqual(ff.property(propertyName), ff.literal(value)), ff.greaterOrEqual( ff.property(additionalPropertyName), ff.literal(value))));
FeatureUtilities.DEFAULT_FILTER_FACTORY.literal( range.getMaxValue())), FeatureUtilities.DEFAULT_FILTER_FACTORY.greaterOrEqual( FeatureUtilities.DEFAULT_FILTER_FACTORY.property( timeFilterAttribute), FeatureUtilities.DEFAULT_FILTER_FACTORY.literal( range.getMaxValue())), FeatureUtilities.DEFAULT_FILTER_FACTORY.greaterOrEqual( FeatureUtilities.DEFAULT_FILTER_FACTORY.property( elevationFilterAttribute),
@Override public Object visit(PropertyIsGreaterThanOrEqualTo 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) .greaterOrEqual(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); } }
FF.greaterOrEqual(PERSONS, FF.literal(rangedClassifier.getMin(i))); Filter less; if (i < rangedClassifier.getSize() - 1) {
} else if (simplified instanceof PropertyIsLessThan) { PropertyIsLessThan pl = (PropertyIsLessThan) simplified; return ff.greaterOrEqual( pl.getExpression1(), pl.getExpression2(), pl.isMatchingCase()); } else if (simplified instanceof PropertyIsLessThanOrEqualTo) {
assertFalse(filter.evaluate(null)); filter = fac.greaterOrEqual(e1, new LiteralExpressionImpl(35.2), false, MatchAction.ALL); assertTrue(filter.evaluate(null)); filter = fac.greaterOrEqual(e1, new LiteralExpressionImpl(201.7), false, MatchAction.ALL); assertFalse(filter.evaluate(null)); filter = fac.greaterOrEqual(new LiteralExpressionImpl(10000.5), e1, false, MatchAction.ALL); assertTrue(filter.evaluate(null)); filter = fac.greaterOrEqual(new LiteralExpressionImpl(201.7), e1, false, MatchAction.ALL); assertFalse(filter.evaluate(null));
assertFalse(filter.evaluate(null)); filter = fac.greaterOrEqual(e1, new LiteralExpressionImpl(10000.5), false, MatchAction.ONE); assertTrue(filter.evaluate(null)); filter = fac.greaterOrEqual(e1, new LiteralExpressionImpl(201.7), false, MatchAction.ONE); assertFalse(filter.evaluate(null)); filter = fac.greaterOrEqual(new LiteralExpressionImpl(35.2), e1, false, MatchAction.ONE); assertTrue(filter.evaluate(null)); filter = fac.greaterOrEqual(new LiteralExpressionImpl(10001), e1, false, MatchAction.ONE); assertFalse(filter.evaluate(null));
public Object visit(PropertyIsGreaterThanOrEqualTo filter, Object extraData) { Expression expr1= visit(filter.getExpression1(), extraData); Expression expr2= visit(filter.getExpression2(), extraData); return getFactory(extraData).greaterOrEqual(expr1, expr2); }
assertFalse(filter.evaluate(null)); filter = fac.greaterOrEqual(e, new LiteralExpressionImpl(10000.5)); assertTrue(filter.evaluate(null)); filter = fac.greaterOrEqual(e, new LiteralExpressionImpl(10001)); assertFalse(filter.evaluate(null)); filter = fac.greaterOrEqual(new LiteralExpressionImpl(35.2), e); assertTrue(filter.evaluate(null)); filter = fac.greaterOrEqual(new LiteralExpressionImpl(35), e); assertFalse(filter.evaluate(null));
filter = fac.lessOrEqual(expr1, expr2, false); assertEquals(filter.getMatchAction(), MatchAction.ANY); filter = fac.greaterOrEqual(expr1, expr2, false); assertEquals(filter.getMatchAction(), MatchAction.ANY); filter = fac.notEqual(expr1, expr2, false); filter = fac.lessOrEqual(expr1, expr2, false, MatchAction.ONE); assertEquals(filter.getMatchAction(), MatchAction.ONE); filter = fac.greaterOrEqual(expr1, expr2, false, MatchAction.ALL); assertEquals(filter.getMatchAction(), MatchAction.ALL); filter = fac.notEqual(expr1, expr2, false, MatchAction.ONE);