org.opengis.filter
Interface FilterFactory

Show UML class diagram

All Known Subinterfaces:

FilterFactory2

public interface FilterFactory

Interface whose methods allow the caller to create instances of the various Filter and Expression subclasses.

Since:

GeoAPI 2.0

Method Summary

Add	add(Expression expr1, Expression expr2) Computes the numeric addition of the first and second operand.
After	after(Expression expr1, Expression expr2) Check if first expression is after the second.
And	and(Filter f, Filter g) AND filter between two filters.
And	and(List<Filter> f) AND filter between a list of filters.
AnyInteracts	anyInteracts(Expression expr1, Expression expr2) Sortcut filter for NOT (Before OR Meets OR MetBy OR After).
ArithmeticOperators	arithmeticOperators(boolean simple, Functions functions) arithmetic operators
BBOX	bbox(String propertyName, double minx, double miny, double maxx, double maxy, String srs) Checks if the bounding box of the feature's geometry overlaps the indicated bounds.
Before	before(Expression expr1, Expression expr2) Check if first expression is before the second.
Begins	begins(Expression expr1, Expression expr2) Check if first expression begins at the second.
BegunBy	begunBy(Expression expr1, Expression expr2) Check if first expression begun by the second.
PropertyIsBetween	between(Expression expr, Expression lower, Expression upper) A compact way of encoding a range check.
Beyond	beyond(String propertyName, Geometry geometry, double distance, String units) Check if all of a feature's geometry is more distant than the given distance from this object's geometry.
FilterCapabilities	capabilities(String version, ScalarCapabilities scalar, SpatialCapabilities spatial, TemporalCapabilities temporal, IdCapabilities id) filter capabilities
ComparisonOperators	comparisonOperators(Operator[] comparisonOperators) comparison operators
Contains	contains(String propertyName, Geometry geometry) Checks if the the first geometric operand contains the second.
Crosses	crosses(String propertyName, Geometry geometry) Checks if the first geometric operand crosses the second.
Disjoint	disjoint(String propertyName, Geometry geometry) Checks if the first operand is disjoint from the second.
Divide	divide(Expression expr1, Expression expr2) Computes the numeric quotient resulting from dividing the first operand by the second.
During	during(Expression expr1, Expression expr2) Check if first expression is during the second.
DWithin	dwithin(String propertyName, Geometry geometry, double distance, String units) Checks if any part of the first geometry lies within the given distance of the second geometry.
EndedBy	endedBy(Expression expr1, Expression expr2) Check if first expression is ended by the second.
Ends	ends(Expression expr1, Expression expr2) Check if first expression ends by the second.
PropertyIsEqualTo	equal(Expression expr1, Expression expr2, boolean matchCase, MatchAction matchAction) Compares that two sub-expressions are equal to eacher other
PropertyIsEqualTo	equals(Expression expr1, Expression expr2) Compares that two sub-expressions are equal to each other.
Equals	equals(String propertyName, Geometry geometry) Checks if the geometry of the two operands are equal.
FeatureId	featureId(String id) Creates a new feautre id from a string
Function	function(String name, Expression... args) Call into some implementation-specific function.
FunctionName	functionName(String name, int nargs) function name
Functions	functions(FunctionName[] functionNames) functions
GmlObjectId	gmlObjectId(String id) Creates a new gml object id from a string
PropertyIsGreaterThan	greater(Expression expr1, Expression expr2) Checks that the first sub-expression is greater than the second subexpression.
PropertyIsGreaterThan	greater(Expression expr1, Expression expr2, boolean matchCase, MatchAction matchAction) Checks that the first sub-expression is greater than the second subexpression.
PropertyIsGreaterThanOrEqualTo	greaterOrEqual(Expression expr1, Expression expr2) Checks that the first sub-expression is greater or equal to the second subexpression.
PropertyIsGreaterThanOrEqualTo	greaterOrEqual(Expression expr1, Expression expr2, boolean matchCase, MatchAction matchAction) Checks that the first sub-expression is greater or equal to the second subexpression.
Id	id(Set<? extends Identifier> ids) Passes only for objects that have one of the IDs given to this object.
IdCapabilities	idCapabilities(boolean eid, boolean fid) id capabilities
Intersects	intersects(String propertyName, Geometry geometry) Checks if the two geometric operands intersect.
PropertyIsNil	isNil(Expression expr) Checks if an expression's value is nil.
PropertyIsNull	isNull(Expression expr) Checks if an expression's value is null.
PropertyIsLessThan	less(Expression expr1, Expression expr2) Checks that its first sub-expression is less than its second subexpression.
PropertyIsLessThan	less(Expression expr1, Expression expr2, boolean matchCase, MatchAction matchAction)
PropertyIsLessThanOrEqualTo	lessOrEqual(Expression expr1, Expression expr2) Checks that its first sub-expression is less than or equal to its second subexpression.
PropertyIsLessThanOrEqualTo	lessOrEqual(Expression expr1, Expression expr2, boolean matchCase, MatchAction matchAction)
PropertyIsLike	like(Expression expr, String pattern) Character string comparison operator with pattern matching and default wildcards.
PropertyIsLike	like(Expression expr, String pattern, String wildcard, String singleChar, String escape) Character string comparison operator with pattern matching and specified wildcards.
PropertyIsLike	like(Expression expr, String pattern, String wildcard, String singleChar, String escape, boolean matchCase) Character string comparison operator with pattern matching and specified wildcards.
Literal	literal(boolean b) A constant, literal Boolean value that can be used in expressions.
Literal	literal(byte b) A constant, literal Byte value that can be used in expressions.
Literal	literal(char c) A constant, literal Character value that can be used in expressions.
Literal	literal(double d) A constant, literal Double value that can be used in expressions.
Literal	literal(float f) A constant, literal Float value that can be used in expressions.
Literal	literal(int i) A constant, literal Integer value that can be used in expressions.
Literal	literal(long l) A constant, literal Long value that can be used in expressions.
Literal	literal(Object obj) A constant, literal value that can be used in expressions.
Literal	literal(short s) A constant, literal Short value that can be used in expressions.
Meets	meets(Expression expr1, Expression expr2) Check if first expression meets the second.
MetBy	metBy(Expression expr1, Expression expr2) Check if first expression is met by the second.
Multiply	multiply(Expression expr1, Expression expr2) Computes the numeric product of their first and second operand.
Not	not(Filter f) Reverses the logical value of a filter.
PropertyIsNotEqualTo	notEqual(Expression expr1, Expression expr2) Checks that the first sub-expression is not equal to the second subexpression.
PropertyIsNotEqualTo	notEqual(Expression expr1, Expression expr2, boolean matchCase, MatchAction matchAction) Checks that the first sub-expression is not equal to the second subexpression.
Operator	operator(String name) operators
Or	or(Filter f, Filter g) OR filter between two filters.
Or	or(List<Filter> f) OR filter between a list of filters.
OverlappedBy	overlappedBy(Expression expr1, Expression expr2) Check if first expression is overlapped by the second.
Overlaps	overlaps(String propertyName, Geometry geometry) Checks if the interior of the first geometry somewhere overlaps the interior of the second geometry.
PropertyName	property(String name) Retrieves the value of a feature's property.
ScalarCapabilities	scalarCapabilities(ComparisonOperators comparison, ArithmeticOperators arithmetic, boolean logical) scalar capabilities
SortBy	sort(String propertyName, SortOrder order) Indicates an property by which contents should be sorted, along with intended order.
SpatialCapabilities	spatialCapabilities(GeometryOperand[] geometryOperands, SpatialOperators spatial) spatial capabilities
SpatialOperator	spatialOperator(String name, GeometryOperand[] geometryOperands) spatial operator
SpatialOperators	spatialOperators(SpatialOperator[] spatialOperators) spatial operators
Subtract	subtract(Expression expr1, Expression expr2) Computes the numeric difference between the first and second operand.
TContains	tcontains(Expression expr1, Expression expr2) Check if first expression iscontained in the second.
TemporalCapabilities	temporalCapabilities(TemporalOperand[] temporalOperands, TemporalOperators temporal) temporal capabilities
TEquals	tequals(Expression expr1, Expression expr2) Check if first expression equal to the second.
Touches	touches(String propertyName, Geometry geometry) Checks if the feature's geometry touches, but does not overlap with the geometry held by this object.
TOverlaps	toverlaps(Expression expr1, Expression expr2) Check if first expression overlaps the second.
Within	within(String propertyName, Geometry geometry) Checks if the feature's geometry is completely contained by the specified constant geometry.

Method Detail

featureId

FeatureId featureId(String id)

Creates a new feautre id from a string

gmlObjectId

GmlObjectId gmlObjectId(String id)

Creates a new gml object id from a string

and

And and(Filter f,
        Filter g)

AND filter between two filters.

and

And and(List<Filter> f)

AND filter between a list of filters.

or

Or or(Filter f,
      Filter g)

OR filter between two filters.

or

Or or(List<Filter> f)

OR filter between a list of filters.

not

Not not(Filter f)

Reverses the logical value of a filter.

id

Id id(Set<? extends Identifier> ids)

Passes only for objects that have one of the IDs given to this object.

property

PropertyName property(String name)

Retrieves the value of a feature's property.

between

PropertyIsBetween between(Expression expr,
                          Expression lower,
                          Expression upper)

A compact way of encoding a range check.

equals

PropertyIsEqualTo equals(Expression expr1,
                         Expression expr2)

Compares that two sub-expressions are equal to each other.

TODO:

should be equal (so equals can refer to geometry)

equal

PropertyIsEqualTo equal(Expression expr1,
                        Expression expr2,
                        boolean matchCase,
                        MatchAction matchAction)

Compares that two sub-expressions are equal to eacher other

notEqual

PropertyIsNotEqualTo notEqual(Expression expr1,
                              Expression expr2)

Checks that the first sub-expression is not equal to the second subexpression.

notEqual

PropertyIsNotEqualTo notEqual(Expression expr1,
                              Expression expr2,
                              boolean matchCase,
                              MatchAction matchAction)

Checks that the first sub-expression is not equal to the second subexpression.

Parameters:

expr1 - first expression

expr2 - second expression

matchCase - true if the comparison should be case insensitive

Returns:

evaluates to true of expr1 not equal to expr2

greater

PropertyIsGreaterThan greater(Expression expr1,
                              Expression expr2)

Checks that the first sub-expression is greater than the second subexpression.

greater

PropertyIsGreaterThan greater(Expression expr1,
                              Expression expr2,
                              boolean matchCase,
                              MatchAction matchAction)

Checks that the first sub-expression is greater than the second subexpression.

Parameters:

expr1 - first expression

expr2 - second expression

matchCase - true if the comparison should be case insensitive

Returns:

evaluates to true of expr1 is greater than expr2

greaterOrEqual

PropertyIsGreaterThanOrEqualTo greaterOrEqual(Expression expr1,
                                              Expression expr2)

Checks that the first sub-expression is greater or equal to the second subexpression.

greaterOrEqual

PropertyIsGreaterThanOrEqualTo greaterOrEqual(Expression expr1,
                                              Expression expr2,
                                              boolean matchCase,
                                              MatchAction matchAction)

Checks that the first sub-expression is greater or equal to the second subexpression.

less

PropertyIsLessThan less(Expression expr1,
                        Expression expr2)

Checks that its first sub-expression is less than its second subexpression.

less

PropertyIsLessThan less(Expression expr1,
                        Expression expr2,
                        boolean matchCase,
                        MatchAction matchAction)

lessOrEqual

PropertyIsLessThanOrEqualTo lessOrEqual(Expression expr1,
                                        Expression expr2)

Checks that its first sub-expression is less than or equal to its second subexpression.

lessOrEqual

PropertyIsLessThanOrEqualTo lessOrEqual(Expression expr1,
                                        Expression expr2,
                                        boolean matchCase,
                                        MatchAction matchAction)

like

PropertyIsLike like(Expression expr,
                    String pattern)

Character string comparison operator with pattern matching and default wildcards.

like

PropertyIsLike like(Expression expr,
                    String pattern,
                    String wildcard,
                    String singleChar,
                    String escape)

Character string comparison operator with pattern matching and specified wildcards.

like

PropertyIsLike like(Expression expr,
                    String pattern,
                    String wildcard,
                    String singleChar,
                    String escape,
                    boolean matchCase)

Character string comparison operator with pattern matching and specified wildcards.

isNull

PropertyIsNull isNull(Expression expr)

Checks if an expression's value is null.

isNil

PropertyIsNil isNil(Expression expr)

Checks if an expression's value is nil.

bbox

BBOX bbox(String propertyName,
          double minx,
          double miny,
          double maxx,
          double maxy,
          String srs)

Checks if the bounding box of the feature's geometry overlaps the indicated bounds.

This method is defined in strict accordance with the Filter 1.0 specification, you may find the FilterFactory2.bbox(Expression, BoundingBox) to be easier to use.

Parameters:

propertyName - Name of geometry property (for a PropertyName to access a Feature's Geometry)

minx - Minimum "x" value (for a literal BoundingBox)

miny - Minimum "y" value (for a literal BoundingBox)

maxx - Maximum "x" value (for a literal BoundingBox)

maxy - Maximum "y" value (for a literal BoundingBox)

srs - Indicating the CoordianteReferenceSystem to use for a literal BoundingBox

beyond

Beyond beyond(String propertyName,
              Geometry geometry,
              double distance,
              String units)

Check if all of a feature's geometry is more distant than the given distance from this object's geometry.

contains

Contains contains(String propertyName,
                  Geometry geometry)

Checks if the the first geometric operand contains the second.

crosses

Crosses crosses(String propertyName,
                Geometry geometry)

Checks if the first geometric operand crosses the second.

disjoint

Disjoint disjoint(String propertyName,
                  Geometry geometry)

Checks if the first operand is disjoint from the second.

dwithin

DWithin dwithin(String propertyName,
                Geometry geometry,
                double distance,
                String units)

Checks if any part of the first geometry lies within the given distance of the second geometry.

equals

Equals equals(String propertyName,
              Geometry geometry)

Checks if the geometry of the two operands are equal.

intersects

Intersects intersects(String propertyName,
                      Geometry geometry)

Checks if the two geometric operands intersect.

overlaps

Overlaps overlaps(String propertyName,
                  Geometry geometry)

Checks if the interior of the first geometry somewhere overlaps the interior of the second geometry.

touches

Touches touches(String propertyName,
                Geometry geometry)

Checks if the feature's geometry touches, but does not overlap with the geometry held by this object.

within

Within within(String propertyName,
              Geometry geometry)

Checks if the feature's geometry is completely contained by the specified constant geometry.

after

After after(Expression expr1,
            Expression expr2)

Check if first expression is after the second.

anyInteracts

AnyInteracts anyInteracts(Expression expr1,
                          Expression expr2)

Sortcut filter for NOT (Before OR Meets OR MetBy OR After).

before

Before before(Expression expr1,
              Expression expr2)

Check if first expression is before the second.

begins

Begins begins(Expression expr1,
              Expression expr2)

Check if first expression begins at the second.

begunBy

BegunBy begunBy(Expression expr1,
                Expression expr2)

Check if first expression begun by the second.

during

During during(Expression expr1,
              Expression expr2)

Check if first expression is during the second.

ends

Ends ends(Expression expr1,
          Expression expr2)

Check if first expression ends by the second.

endedBy

EndedBy endedBy(Expression expr1,
                Expression expr2)

Check if first expression is ended by the second.

meets

Meets meets(Expression expr1,
            Expression expr2)

Check if first expression meets the second.

metBy

MetBy metBy(Expression expr1,
            Expression expr2)

Check if first expression is met by the second.

overlappedBy

OverlappedBy overlappedBy(Expression expr1,
                          Expression expr2)

Check if first expression is overlapped by the second.

tcontains

TContains tcontains(Expression expr1,
                    Expression expr2)

Check if first expression iscontained in the second.

tequals

TEquals tequals(Expression expr1,
                Expression expr2)

Check if first expression equal to the second.

toverlaps

TOverlaps toverlaps(Expression expr1,
                    Expression expr2)

Check if first expression overlaps the second.

add

Add add(Expression expr1,
        Expression expr2)

Computes the numeric addition of the first and second operand.

divide

Divide divide(Expression expr1,
              Expression expr2)

Computes the numeric quotient resulting from dividing the first operand by the second.

multiply

Multiply multiply(Expression expr1,
                  Expression expr2)

Computes the numeric product of their first and second operand.

subtract

Subtract subtract(Expression expr1,
                  Expression expr2)

Computes the numeric difference between the first and second operand.

function

Function function(String name,
                  Expression... args)

Call into some implementation-specific function.

literal

Literal literal(Object obj)

A constant, literal value that can be used in expressions.

literal

Literal literal(byte b)

A constant, literal Byte value that can be used in expressions.

literal

Literal literal(short s)

A constant, literal Short value that can be used in expressions.

literal

Literal literal(int i)

A constant, literal Integer value that can be used in expressions.

literal

Literal literal(long l)

A constant, literal Long value that can be used in expressions.

literal

Literal literal(float f)

A constant, literal Float value that can be used in expressions.

literal

Literal literal(double d)

A constant, literal Double value that can be used in expressions.

literal

Literal literal(char c)

A constant, literal Character value that can be used in expressions.

literal

Literal literal(boolean b)

A constant, literal Boolean value that can be used in expressions.

sort

SortBy sort(String propertyName,
            SortOrder order)

Indicates an property by which contents should be sorted, along with intended order.

operator

Operator operator(String name)

operators

spatialOperator

SpatialOperator spatialOperator(String name,
                                GeometryOperand[] geometryOperands)

spatial operator

functionName

FunctionName functionName(String name,
                          int nargs)

function name

functions

Functions functions(FunctionName[] functionNames)

functions

spatialOperators

SpatialOperators spatialOperators(SpatialOperator[] spatialOperators)

spatial operators

comparisonOperators

ComparisonOperators comparisonOperators(Operator[] comparisonOperators)

comparison operators

arithmeticOperators

ArithmeticOperators arithmeticOperators(boolean simple,
                                        Functions functions)

arithmetic operators

scalarCapabilities

ScalarCapabilities scalarCapabilities(ComparisonOperators comparison,
                                      ArithmeticOperators arithmetic,
                                      boolean logical)

scalar capabilities

spatialCapabilities

SpatialCapabilities spatialCapabilities(GeometryOperand[] geometryOperands,
                                        SpatialOperators spatial)

spatial capabilities

temporalCapabilities

TemporalCapabilities temporalCapabilities(TemporalOperand[] temporalOperands,
                                          TemporalOperators temporal)

temporal capabilities

idCapabilities

IdCapabilities idCapabilities(boolean eid,
                              boolean fid)

id capabilities

capabilities

FilterCapabilities capabilities(String version,
                                ScalarCapabilities scalar,
                                SpatialCapabilities spatial,
                                TemporalCapabilities temporal,
                                IdCapabilities id)

filter capabilities