Module org.opengis.geoapi

Package org.opengis.filter

Interface FilterFactory<R,G,T>

Type Parameters:

R - the type of resources (e.g. Feature) to use as inputs.

G - base class of geometry objects. The implementation-neutral type is GeoAPI Geometry.

T - base class of temporal objects.

All Superinterfaces:

Factory

public interface FilterFactory<R,G,T>
extends Factory

Factory of instances of the various Filter and Expression subclasses.

Since:

3.1

TODO:

This interface is a first draft. Its API may change at any time. In particular different strategies may be tried regarding the parameterized types.

Method Summary

Modifier and Type	Method	Description
Expression<R,Number>	add(Expression<R,? extends Number> operand1, Expression<R,? extends Number> operand2)	Creates a function computing the numeric addition of the first and second operand.
TemporalOperator<R>	after(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is after the second.
LogicalOperator<R>	and(Collection<? extends Filter<R>> operands)	Creates a AND filter between two or more filters.
default LogicalOperator<R>	and(Filter<R> operand1, Filter<R> operand2)	Creates a AND filter between two filters.
TemporalOperator<R>	anyInteracts(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates a shortcut operator semantically equivalent to NOT (Before OR Meets OR MetBy OR After).
BinarySpatialOperator<R>	bbox(Expression<R,? extends G> geometry, Envelope bounds)	Creates an operator that checks if the bounding box of the feature's geometry interacts with the bounding box provided in the filter properties.
TemporalOperator<R>	before(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is before the second.
TemporalOperator<R>	begins(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand begins at the second.
TemporalOperator<R>	begunBy(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand begun by the second.
BetweenComparisonOperator<R>	between(Expression<R,?> expression, Expression<R,?> lowerBoundary, Expression<R,?> upperBoundary)	Filter operation for a range check.
DistanceOperator<R>	beyond(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2, javax.measure.Quantity<javax.measure.quantity.Length> distance)	Creates an operator that checks if all of a feature's geometry is more distant than the given distance from the given geometry.
BinarySpatialOperator<R>	contains(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the first geometric operand contains the second.
BinarySpatialOperator<R>	crosses(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the first geometric operand crosses the second.
BinarySpatialOperator<R>	disjoint(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the first operand is disjoint from the second.
Expression<R,Number>	divide(Expression<R,? extends Number> operand1, Expression<R,? extends Number> operand2)	Creates a function computing the numeric quotient resulting from dividing the first operand by the second.
TemporalOperator<R>	during(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is during the second.
TemporalOperator<R>	endedBy(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is ended by the second.
TemporalOperator<R>	ends(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand ends at the second.
default BinaryComparisonOperator<R>	equal(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that compares that its two sub-expressions are equal to each other.
BinaryComparisonOperator<R>	equal(Expression<R,?> expression1, Expression<R,?> expression2, boolean isMatchingCase, MatchAction matchAction)	Filter operator that compares that its two sub-expressions are equal to each other.
BinarySpatialOperator<R>	equals(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the geometry of the two operands are equal.
default Expression<R,?>	function(String name, Expression<R,?> parameter)	Creates an implementation-specific function with a single parameter.
Expression<R,?>	function(String name, Expression<R,?>[] parameters)	Creates an implementation-specific function with an arbitrary number of parameters.
default Expression<R,?>	function(String name, Expression<R,?> param1, Expression<R,?> param2)	Creates an implementation-specific function with two parameters.
FilterCapabilities	getCapabilities()	Describes the abilities of this factory.
default BinaryComparisonOperator<R>	greater(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that checks that its first sub-expression is greater than its second sub-expression.
BinaryComparisonOperator<R>	greater(Expression<R,?> expression1, Expression<R,?> expression2, boolean isMatchingCase, MatchAction matchAction)	Filter operator that checks that its first sub-expression is greater than its second sub-expression.
default BinaryComparisonOperator<R>	greaterOrEqual(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that checks that its first sub-expression is greater than its second sub-expression.
BinaryComparisonOperator<R>	greaterOrEqual(Expression<R,?> expression1, Expression<R,?> expression2, boolean isMatchingCase, MatchAction matchAction)	Filter operator that checks that its first sub-expression is greater than its second sub-expression.
BinarySpatialOperator<R>	intersects(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the two geometric operands intersect.
NilOperator<R>	isNil(Expression<R,?> expression, String nilReason)	An operator that tests if an expression's value is nil.
NullOperator<R>	isNull(Expression<R,?> expression)	An operator that tests if an expression's value is null.
default BinaryComparisonOperator<R>	less(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that checks that its first sub-expression is less than its second sub-expression.
BinaryComparisonOperator<R>	less(Expression<R,?> expression1, Expression<R,?> expression2, boolean isMatchingCase, MatchAction matchAction)	Filter operator that checks that its first sub-expression is less than its second sub-expression.
default BinaryComparisonOperator<R>	lessOrEqual(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that checks that its first sub-expression is less than or equal to its second sub-expression.
BinaryComparisonOperator<R>	lessOrEqual(Expression<R,?> expression1, Expression<R,?> expression2, boolean isMatchingCase, MatchAction matchAction)	Filter operator that checks that its first sub-expression is less than or equal to its second sub-expression.
default LikeOperator<R>	like(Expression<R,?> expression, String pattern)	Character string comparison operator with pattern matching and default wildcards.
LikeOperator<R>	like(Expression<R,?> expression, String pattern, char wildcard, char singleChar, char escape, boolean isMatchingCase)	Character string comparison operator with pattern matching and specified wildcards.
<V> Literal<R,V>	literal(V value)	Creates a constant, literal value that can be used in expressions.
TemporalOperator<R>	meets(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand meets the second.
TemporalOperator<R>	metBy(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is met by the second.
Expression<R,Number>	multiply(Expression<R,? extends Number> operand1, Expression<R,? extends Number> operand2)	Creates a function computing the numeric product of their first and second operand.
LogicalOperator<R>	not(Filter<R> operand)	Creates a NOT filter for the given filter.
default BinaryComparisonOperator<R>	notEqual(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that compares that its two sub-expressions are not equal to each other.
BinaryComparisonOperator<R>	notEqual(Expression<R,?> expression1, Expression<R,?> expression2, boolean isMatchingCase, MatchAction matchAction)	Filter operator that compares that its two sub-expressions are not equal to each other.
LogicalOperator<R>	or(Collection<? extends Filter<R>> operands)	Creates a OR filter between two or more filters.
default LogicalOperator<R>	or(Filter<R> operand1, Filter<R> operand2)	Creates a OR filter between two filters.
TemporalOperator<R>	overlappedBy(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is overlapped by the second.
BinarySpatialOperator<R>	overlaps(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the interior of the first geometric operand somewhere overlaps the interior of the second geometric operand.
default ValueReference<R,?>	property(String xpath)	Creates an expression whose value is computed by retrieving the value indicated by a path in a resource.
<V> ValueReference<R,V>	property(String xpath, Class<V> type)	Creates an expression retrieving the value as an instance of the specified class.
default ResourceId<R>	resourceId(String rid)	Creates a predicate to identify an identifiable resource within a filter expression.
ResourceId<R>	resourceId(String rid, Version version, Instant startTime, Instant endTime)	Creates a predicate to identify an identifiable resource within a filter expression.
SortProperty<R>	sort(ValueReference<R,?> property, SortOrder order)	Indicates a property by which contents should be sorted, along with intended order.
Expression<R,Number>	subtract(Expression<R,? extends Number> operand1, Expression<R,? extends Number> operand2)	Creates a function computing the numeric difference between the first and second operand.
TemporalOperator<R>	tcontains(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is contained by the second.
TemporalOperator<R>	tequals(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is equal to the second.
BinarySpatialOperator<R>	touches(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the two geometric operands touch each other, but do not overlap.
TemporalOperator<R>	toverlaps(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand overlaps the second.
BinarySpatialOperator<R>	within(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the first geometric operand is completely contained by the constant geometric operand.
DistanceOperator<R>	within(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2, javax.measure.Quantity<javax.measure.quantity.Length> distance)	Creates an operator that checks if any part of the first geometry lies within the given distance of the second geometry.

Methods inherited from interface org.opengis.util.Factory

getVendor

Method Details

getCapabilities

FilterCapabilities getCapabilities()

Describes the abilities of this factory. The description includes restrictions on the available spatial operations, scalar operations, lists of supported functions, and description of which geometry literals are understood.

Returns:

description of the abilities of this factory.

resourceId

default ResourceId<R> resourceId(String rid)

Creates a predicate to identify an identifiable resource within a filter expression. The predicate uses no versioning and no time range.

Parameters:

rid - identifier of the resource that shall be selected by the predicate.

Returns:

the predicate.

resourceId

ResourceId<R> resourceId(String rid,
 Version version,
 Instant startTime,
 Instant endTime)

Creates a predicate to identify an identifiable resource within a filter expression. If startTime and endTime are non-null, the filter will select all versions of a resource between the specified dates.

Parameters:

rid - identifier of the resource that shall be selected by the predicate.

version - version of the resource to select, or null for any version.

startTime - start time of the resource to select, or null if none.

endTime - end time of the resource to select, or null if none.

Returns:

the predicate.

property

default ValueReference<R,?> property(String xpath)

Creates an expression whose value is computed by retrieving the value indicated by a path in a resource. If all characters in the path are Unicode identifier parts, then the XPath expression is simply a property name.

Parameters:

xpath - the path to the property whose value will be returned by the apply(R) method.

Returns:

an expression evaluating the referenced property value.

property

<V> ValueReference<R,V> property(String xpath,
 Class<V> type)

Creates an expression retrieving the value as an instance of the specified class. The xpath argument follows the rule described in property(String).

The desired type of property values can be specified. For example if the property values should be numbers, then type can be Number.class. If property values can be of any type with no conversion desired, then type should be Object.class.

Type Parameters:

V - the type of the values to be fetched (compile-time value of type).

Parameters:

xpath - the path to the property whose value will be returned by the apply(R) method.

type - the type of the values to be fetched (run-time value of <V>).

Returns:

an expression evaluating the referenced property value.

literal

<V> Literal<R,V> literal(V value)

Creates a constant, literal value that can be used in expressions.

Recommended restriction

The given value may be persisted with XML based technologies. As an example a Geometry may be written out using GML. Consequently, the value should be data objects such as strings, numbers, dates, or geometries. It should not be state of operations.

Type Parameters:

V - the type of the value of the literal.

Parameters:

value - the literal value. May be null.

Returns:

a literal for the given value.

equal

default BinaryComparisonOperator<R> equal(Expression<R,?> expression1,
 Expression<R,?> expression2)

Filter operator that compares that its two sub-expressions are equal to each other. The comparison is case-sensitive and evaluates to true if Any of the value in the collection can satisfy the predicate.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

Returns:

a filter evaluating expression1 = expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_EQUAL_TO

equal

BinaryComparisonOperator<R> equal(Expression<R,?> expression1,
 Expression<R,?> expression2,
 boolean isMatchingCase,
 MatchAction matchAction)

Filter operator that compares that its two sub-expressions are equal to each other.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

isMatchingCase - specifies whether comparisons are case sensitive.

matchAction - specifies how the comparisons shall be evaluated for a collection of values.

Returns:

a filter evaluating expression1 = expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_EQUAL_TO

notEqual

default BinaryComparisonOperator<R> notEqual(Expression<R,?> expression1,
 Expression<R,?> expression2)

Filter operator that compares that its two sub-expressions are not equal to each other. The comparison is case-sensitive and evaluates to true if Any of the value in the collection can satisfy the predicate.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

Returns:

a filter evaluating expression1 ≠ expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_NOT_EQUAL_TO

notEqual

BinaryComparisonOperator<R> notEqual(Expression<R,?> expression1,
 Expression<R,?> expression2,
 boolean isMatchingCase,
 MatchAction matchAction)

Filter operator that compares that its two sub-expressions are not equal to each other.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

isMatchingCase - specifies whether comparisons are case sensitive.

matchAction - specifies how the comparisons shall be evaluated for a collection of values.

Returns:

a filter evaluating expression1 ≠ expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_NOT_EQUAL_TO

less

default BinaryComparisonOperator<R> less(Expression<R,?> expression1,
 Expression<R,?> expression2)

Filter operator that checks that its first sub-expression is less than its second sub-expression. The comparison is case-sensitive and evaluates to true if Any of the value in the collection can satisfy the predicate.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

Returns:

a filter evaluating expression1 < expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_LESS_THAN

TODO:

Revisit if we can be more specific on the second parameterized type in expressions.

less

BinaryComparisonOperator<R> less(Expression<R,?> expression1,
 Expression<R,?> expression2,
 boolean isMatchingCase,
 MatchAction matchAction)

Filter operator that checks that its first sub-expression is less than its second sub-expression.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

isMatchingCase - specifies whether comparisons are case sensitive.

matchAction - specifies how the comparisons shall be evaluated for a collection of values.

Returns:

a filter evaluating expression1 < expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_LESS_THAN

TODO:

Revisit if we can be more specific on the second parameterized type in expressions.

greater

default BinaryComparisonOperator<R> greater(Expression<R,?> expression1,
 Expression<R,?> expression2)

Filter operator that checks that its first sub-expression is greater than its second sub-expression. The comparison is case-sensitive and evaluates to true if Any of the value in the collection can satisfy the predicate.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

Returns:

a filter evaluating expression1 > expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_GREATER_THAN

TODO:

Revisit if we can be more specific on the second parameterized type in expressions.

greater

BinaryComparisonOperator<R> greater(Expression<R,?> expression1,
 Expression<R,?> expression2,
 boolean isMatchingCase,
 MatchAction matchAction)

Filter operator that checks that its first sub-expression is greater than its second sub-expression.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

isMatchingCase - specifies whether comparisons are case sensitive.

matchAction - specifies how the comparisons shall be evaluated for a collection of values.

Returns:

a filter evaluating expression1 > expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_GREATER_THAN

TODO:

Revisit if we can be more specific on the second parameterized type in expressions.

lessOrEqual

default BinaryComparisonOperator<R> lessOrEqual(Expression<R,?> expression1,
 Expression<R,?> expression2)

Filter operator that checks that its first sub-expression is less than or equal to its second sub-expression. The comparison is case-sensitive and evaluates to true if Any of the value in the collection can satisfy the predicate.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

Returns:

a filter evaluating expression1 ≤ expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_LESS_THAN_OR_EQUAL_TO

TODO:

Revisit if we can be more specific on the second parameterized type in expressions.

lessOrEqual

BinaryComparisonOperator<R> lessOrEqual(Expression<R,?> expression1,
 Expression<R,?> expression2,
 boolean isMatchingCase,
 MatchAction matchAction)

Filter operator that checks that its first sub-expression is less than or equal to its second sub-expression.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

isMatchingCase - specifies whether comparisons are case sensitive.

matchAction - specifies how the comparisons shall be evaluated for a collection of values.

Returns:

a filter evaluating expression1 ≤ expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_LESS_THAN_OR_EQUAL_TO

TODO:

Revisit if we can be more specific on the second parameterized type in expressions.

greaterOrEqual

default BinaryComparisonOperator<R> greaterOrEqual(Expression<R,?> expression1,
 Expression<R,?> expression2)

Filter operator that checks that its first sub-expression is greater than its second sub-expression. The comparison is case-sensitive and evaluates to true if Any of the value in the collection can satisfy the predicate.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

Returns:

a filter evaluating expression1 ≥ expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_GREATER_THAN_OR_EQUAL_TO

TODO:

Revisit if we can be more specific on the second parameterized type in expressions.

greaterOrEqual

BinaryComparisonOperator<R> greaterOrEqual(Expression<R,?> expression1,
 Expression<R,?> expression2,
 boolean isMatchingCase,
 MatchAction matchAction)

Filter operator that checks that its first sub-expression is greater than its second sub-expression.

Parameters:

expression1 - the first of the two expressions to be used by this comparator.

expression2 - the second of the two expressions to be used by this comparator.

isMatchingCase - specifies whether comparisons are case sensitive.

matchAction - specifies how the comparisons shall be evaluated for a collection of values.

Returns:

a filter evaluating expression1 ≥ expression2.

See Also:

• ComparisonOperatorName.PROPERTY_IS_GREATER_THAN_OR_EQUAL_TO

TODO:

Revisit if we can be more specific on the second parameterized type in expressions.

between

BetweenComparisonOperator<R> between(Expression<R,?> expression,
 Expression<R,?> lowerBoundary,
 Expression<R,?> upperBoundary)

Filter operation for a range check. The lower and upper boundary values are inclusive.

Parameters:

expression - the expression to be compared by this comparator.

lowerBoundary - the lower bound (inclusive) as an expression.

upperBoundary - the upper bound (inclusive) as an expression.

Returns:

a filter evaluating (expression ≥ lowerBoundary) & (expression ≤ upperBoundary).

like

default LikeOperator<R> like(Expression<R,?> expression,
 String pattern)

Character string comparison operator with pattern matching and default wildcards. The wildcard character is '%', the single character is '_' and the escape character is '\\'. The comparison is case-sensitive.

Parameters:

expression - source of values to compare against the pattern.

pattern - pattern to match against expression values.

Returns:

a character string comparison operator with pattern matching.

like

LikeOperator<R> like(Expression<R,?> expression,
 String pattern,
 char wildcard,
 char singleChar,
 char escape,
 boolean isMatchingCase)

Character string comparison operator with pattern matching and specified wildcards.

Parameters:

expression - source of values to compare against the pattern.

pattern - pattern to match against expression values.

wildcard - pattern character for matching any sequence of characters.

singleChar - pattern character for matching exactly one character.

escape - pattern character for indicating that the next character should be matched literally.

isMatchingCase - specifies how a filter expression processor should perform string comparisons.

Returns:

a character string comparison operator with pattern matching.

isNull

NullOperator<R> isNull(Expression<R,?> expression)

An operator that tests if an expression's value is null. This corresponds to checking whether the property exists in the real-world.

Parameters:

expression - source of values to compare against null.

Returns:

a filter that checks if an expression's value is null.

isNil

NilOperator<R> isNil(Expression<R,?> expression,
 String nilReason)

An operator that tests if an expression's value is nil. The difference with NullOperator is that a value should exist but cannot be provided for the reason given by nilReason. Possible reasons are:

• inapplicable — there is no value.
• template — the value will be available later.
• missing — the correct value is not readily available to the sender of this data. Furthermore, a correct value may not exist.
• unknown — the correct value is not known to, and not computable by, the sender of this data. However, a correct value probably exists..
• withheld — the value is not divulged.
• Other strings at implementation choice.

Parameters:

expression - source of values to compare against nil values.

nilReason - the reason why the value is nil, or null for accepting any reason.

Returns:

a filter that checks if an expression's value is nil for the specified reason.

and

default LogicalOperator<R> and(Filter<R> operand1,
 Filter<R> operand2)

Creates a AND filter between two filters.

Parameters:

operand1 - the first operand of the AND operation.

operand2 - the second operand of the AND operation.

Returns:

a filter evaluating operand1 AND operand2.

See Also:

• LogicalOperatorName.AND

and

LogicalOperator<R> and(Collection<? extends Filter<R>> operands)

Creates a AND filter between two or more filters.

Parameters:

operands - a collection of at least 2 operands.

Returns:

a filter evaluating operand1 AND operand2 AND operand3…

Throws:

IllegalArgumentException - if the given collection contains less than 2 elements.

See Also:

• LogicalOperatorName.AND

or

default LogicalOperator<R> or(Filter<R> operand1,
 Filter<R> operand2)

Creates a OR filter between two filters.

Parameters:

operand1 - the first operand of the OR operation.

operand2 - the second operand of the OR operation.

Returns:

a filter evaluating operand1 OR operand2.

See Also:

• LogicalOperatorName.OR

or

LogicalOperator<R> or(Collection<? extends Filter<R>> operands)

Creates a OR filter between two or more filters.

Parameters:

operands - a collection of at least 2 operands.

Returns:

a filter evaluating operand1 OR operand2 OR operand3…

Throws:

IllegalArgumentException - if the given collection contains less than 2 elements.

See Also:

• LogicalOperatorName.OR

not

LogicalOperator<R> not(Filter<R> operand)

Creates a NOT filter for the given filter.

Parameters:

operand - the operand of the NOT operation.

Returns:

a filter evaluating NOT operand.

See Also:

• LogicalOperatorName.NOT

bbox

BinarySpatialOperator<R> bbox(Expression<R,? extends G> geometry,
 Envelope bounds)

Creates an operator that checks if the bounding box of the feature's geometry interacts with the bounding box provided in the filter properties.

Parameters:

geometry - expression fetching the geometry to check for interaction with bounds.

bounds - the bounds to check geometry against.

Returns:

a filter checking for any interactions between the bounding boxes.

See Also:

• SpatialOperatorName.BBOX

equals

BinarySpatialOperator<R> equals(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2)

Creates an operator that checks if the geometry of the two operands are equal.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

Returns:

a filter for the "Equals" operator between the two geometries.

See Also:

• SpatialOperatorName.EQUALS

TODO:

Rename equal.

disjoint

BinarySpatialOperator<R> disjoint(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2)

Creates an operator that checks if the first operand is disjoint from the second.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

Returns:

a filter for the "Disjoint" operator between the two geometries.

See Also:

• SpatialOperatorName.DISJOINT

intersects

BinarySpatialOperator<R> intersects(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2)

Creates an operator that checks if the two geometric operands intersect.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

Returns:

a filter for the "Intersects" operator between the two geometries.

See Also:

• SpatialOperatorName.INTERSECTS

touches

BinarySpatialOperator<R> touches(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2)

Creates an operator that checks if the two geometric operands touch each other, but do not overlap.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

Returns:

a filter for the "Touches" operator between the two geometries.

See Also:

• SpatialOperatorName.TOUCHES

crosses

BinarySpatialOperator<R> crosses(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2)

Creates an operator that checks if the first geometric operand crosses the second.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

Returns:

a filter for the "Crosses" operator between the two geometries.

See Also:

• SpatialOperatorName.CROSSES

within

BinarySpatialOperator<R> within(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2)

Creates an operator that checks if the first geometric operand is completely contained by the constant geometric operand.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

Returns:

a filter for the "Within" operator between the two geometries.

See Also:

• SpatialOperatorName.WITHIN

contains

BinarySpatialOperator<R> contains(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2)

Creates an operator that checks if the first geometric operand contains the second.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

Returns:

a filter for the "Contains" operator between the two geometries.

See Also:

• SpatialOperatorName.CONTAINS

overlaps

BinarySpatialOperator<R> overlaps(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2)

Creates an operator that checks if the interior of the first geometric operand somewhere overlaps the interior of the second geometric operand.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

Returns:

a filter for the "Overlaps" operator between the two geometries.

See Also:

• SpatialOperatorName.OVERLAPS

beyond

DistanceOperator<R> beyond(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2,
 javax.measure.Quantity<javax.measure.quantity.Length> distance)

Creates an operator that checks if all of a feature's geometry is more distant than the given distance from the given geometry.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

distance - minimal distance for evaluating the expression as true.

Returns:

operator that evaluates to true when all of a feature's geometry is more distant than the given distance from the second geometry.

See Also:

• DistanceOperatorName.BEYOND

within

DistanceOperator<R> within(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2,
 javax.measure.Quantity<javax.measure.quantity.Length> distance)

Creates an operator that checks if any part of the first geometry lies within the given distance of the second geometry.

Parameters:

geometry1 - expression fetching the first geometry of the binary operator.

geometry2 - expression fetching the second geometry of the binary operator.

distance - maximal distance for evaluating the expression as true.

Returns:

operator that evaluates to true when any part of the feature's geometry lies within the given distance of the second geometry.

See Also:

• DistanceOperatorName.WITHIN

after

TemporalOperator<R> after(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand is after the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "After" operator between the two temporal values.

See Also:

• TemporalOperatorName.AFTER

before

TemporalOperator<R> before(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand is before the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "Before" operator between the two temporal values.

See Also:

• TemporalOperatorName.BEFORE

begins

TemporalOperator<R> begins(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand begins at the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "Begins" operator between the two temporal values.

See Also:

• TemporalOperatorName.BEGINS

begunBy

TemporalOperator<R> begunBy(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand begun by the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "BegunBy" operator between the two temporal values.

See Also:

• TemporalOperatorName.BEGUN_BY

tcontains

TemporalOperator<R> tcontains(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand is contained by the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "TContains" operator between the two temporal values.

See Also:

• TemporalOperatorName.CONTAINS

during

TemporalOperator<R> during(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand is during the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "During" operator between the two temporal values.

See Also:

• TemporalOperatorName.DURING

tequals

TemporalOperator<R> tequals(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand is equal to the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "TEquals" operator between the two temporal values.

See Also:

• TemporalOperatorName.EQUALS

toverlaps

TemporalOperator<R> toverlaps(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand overlaps the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "TOverlaps" operator between the two temporal values.

See Also:

• TemporalOperatorName.OVERLAPS

meets

TemporalOperator<R> meets(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand meets the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "Meets" operator between the two temporal values.

See Also:

• TemporalOperatorName.MEETS

ends

TemporalOperator<R> ends(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand ends at the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "Ends" operator between the two temporal values.

See Also:

• TemporalOperatorName.ENDS

overlappedBy

TemporalOperator<R> overlappedBy(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand is overlapped by the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "OverlappedBy" operator between the two temporal values.

See Also:

• TemporalOperatorName.OVERLAPPED_BY

metBy

TemporalOperator<R> metBy(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand is met by the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "MetBy" operator between the two temporal values.

See Also:

• TemporalOperatorName.MET_BY

endedBy

TemporalOperator<R> endedBy(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates an operator that checks if first temporal operand is ended by the second.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "EndedBy" operator between the two temporal values.

See Also:

• TemporalOperatorName.ENDED_BY

anyInteracts

TemporalOperator<R> anyInteracts(Expression<R,? extends T> time1,
 Expression<R,? extends T> time2)

Creates a shortcut operator semantically equivalent to NOT (Before OR Meets OR MetBy OR After). This is applicable to periods only.

Parameters:

time1 - expression fetching the first temporal value.

time2 - expression fetching the second temporal value.

Returns:

a filter for the "AnyInteracts" operator between the two temporal values.

See Also:

• TemporalOperatorName.ANY_INTERACTS

add

Expression<R,Number> add(Expression<R,? extends Number> operand1,
 Expression<R,? extends Number> operand2)

Creates a function computing the numeric addition of the first and second operand.

Parameters:

operand1 - expression fetching the first number.

operand2 - expression fetching the second number.

Returns:

an expression for the "Add" function between the two numerical values.

subtract

Expression<R,Number> subtract(Expression<R,? extends Number> operand1,
 Expression<R,? extends Number> operand2)

Creates a function computing the numeric difference between the first and second operand.

Parameters:

operand1 - expression fetching the first number.

operand2 - expression fetching the second number.

Returns:

an expression for the "Subtract" function between the two numerical values.

multiply

Expression<R,Number> multiply(Expression<R,? extends Number> operand1,
 Expression<R,? extends Number> operand2)

Creates a function computing the numeric product of their first and second operand.

Parameters:

operand1 - expression fetching the first number.

operand2 - expression fetching the second number.

Returns:

an expression for the "Multiply" function between the two numerical values.

divide

Expression<R,Number> divide(Expression<R,? extends Number> operand1,
 Expression<R,? extends Number> operand2)

Creates a function computing the numeric quotient resulting from dividing the first operand by the second.

Parameters:

operand1 - expression fetching the first number.

operand2 - expression fetching the second number.

Returns:

an expression for the "Divide" function between the two numerical values.

function

default Expression<R,?> function(String name,
 Expression<R,?> parameter)

Creates an implementation-specific function with a single parameter. The names of available functions is given by getCapabilities().

Parameters:

name - name of the function to call.

parameter - expression providing values for the function argument.

Returns:

an expression which will call the specified function.

Throws:

IllegalArgumentException - if the given name is not recognized, or if the argument is illegal for the specified function.

See Also:

• FilterCapabilities.getFunctions()

function

default Expression<R,?> function(String name,
 Expression<R,?> param1,
 Expression<R,?> param2)

Creates an implementation-specific function with two parameters. The names of available functions is given by getCapabilities().

Parameters:

name - name of the function to call.

param1 - expression providing values for the first function argument.

param2 - expression providing values for the second function argument.

Returns:

an expression which will call the specified function.

Throws:

IllegalArgumentException - if the given name is not recognized, or if the arguments are illegal for the specified function.

See Also:

• FilterCapabilities.getFunctions()

function

Expression<R,?> function(String name,
 Expression<R,?>[] parameters)

Creates an implementation-specific function with an arbitrary number of parameters. The names of available functions is given by getCapabilities().

Parameters:

name - name of the function to call.

parameters - expressions providing values for the function arguments.

Returns:

an expression which will call the specified function.

Throws:

IllegalArgumentException - if the given name is not recognized, or if the arguments are illegal for the specified function.

See Also:

• FilterCapabilities.getFunctions()

sort

SortProperty<R> sort(ValueReference<R,?> property,
 SortOrder order)

Indicates a property by which contents should be sorted, along with intended order. Implementation may require that the given expression evaluates to Comparable objects.

Parameters:

property - the property to sort by.

order - the sorting order, ascending or descending.

Returns:

definition of sort order of a property.