 Type Parameters:
R
 the type of resources (e.g.Feature
) to use as inputs.G
 base class of geometry objects. The implementationneutral type is GeoAPIGeometry
.T
 base class of temporal objects.
 All Superinterfaces:
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 TypeMethodDescriptionadd
(Expression<R, ? extends Number> operand1, Expression<R, ? extends Number> operand2) Creates a function computing the numeric addition of the first and second operand.after
(Expression<R, ? extends T> time1, Expression<R, ? extends T> time2) Creates an operator that checks if first temporal operand is after the second.and
(Collection<? extends Filter<R>> operands) Creates aAND
filter between two or more filters.default LogicalOperator
<R> Creates aAND
filter between two filters.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).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.before
(Expression<R, ? extends T> time1, Expression<R, ? extends T> time2) Creates an operator that checks if first temporal operand is before the second.begins
(Expression<R, ? extends T> time1, Expression<R, ? extends T> time2) Creates an operator that checks if first temporal operand begins at the second.begunBy
(Expression<R, ? extends T> time1, Expression<R, ? extends T> time2) Creates an operator that checks if first temporal operand begun by the second.between
(Expression<R, ?> expression, Expression<R, ?> lowerBoundary, Expression<R, ?> upperBoundary) Filter operation for a range check.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.contains
(Expression<R, ? extends G> geometry1, Expression<R, ? extends G> geometry2) Creates an operator that checks if the first geometric operand contains the second.crosses
(Expression<R, ? extends G> geometry1, Expression<R, ? extends G> geometry2) Creates an operator that checks if the first geometric operand crosses the second.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.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.during
(Expression<R, ? extends T> time1, Expression<R, ? extends T> time2) Creates an operator that checks if first temporal operand is during the second.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.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 subexpressions are equal to each other.equal
(Expression<R, ?> expression1, Expression<R, ?> expression2, boolean isMatchingCase, MatchAction matchAction) Filter operator that compares that its two subexpressions are equal to each other.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 implementationspecific function with a single parameter.Expression
<R, ?> function
(String name, Expression<R, ?>[] parameters) Creates an implementationspecific function with an arbitrary number of parameters.default Expression
<R, ?> function
(String name, Expression<R, ?> param1, Expression<R, ?> param2) Creates an implementationspecific function with two parameters.Describes the abilities of this factory.default BinaryComparisonOperator
<R> greater
(Expression<R, ?> expression1, Expression<R, ?> expression2) Filter operator that checks that its first subexpression is greater than its second subexpression.greater
(Expression<R, ?> expression1, Expression<R, ?> expression2, boolean isMatchingCase, MatchAction matchAction) Filter operator that checks that its first subexpression is greater than its second subexpression.default BinaryComparisonOperator
<R> greaterOrEqual
(Expression<R, ?> expression1, Expression<R, ?> expression2) Filter operator that checks that its first subexpression is greater than its second subexpression.greaterOrEqual
(Expression<R, ?> expression1, Expression<R, ?> expression2, boolean isMatchingCase, MatchAction matchAction) Filter operator that checks that its first subexpression is greater than its second subexpression.intersects
(Expression<R, ? extends G> geometry1, Expression<R, ? extends G> geometry2) Creates an operator that checks if the two geometric operands intersect.isNil
(Expression<R, ?> expression, String nilReason) An operator that tests if an expression's value is nil.isNull
(Expression<R, ?> expression) An operator that tests if an expression's value isnull
.default BinaryComparisonOperator
<R> less
(Expression<R, ?> expression1, Expression<R, ?> expression2) Filter operator that checks that its first subexpression is less than its second subexpression.less
(Expression<R, ?> expression1, Expression<R, ?> expression2, boolean isMatchingCase, MatchAction matchAction) Filter operator that checks that its first subexpression is less than its second subexpression.default BinaryComparisonOperator
<R> lessOrEqual
(Expression<R, ?> expression1, Expression<R, ?> expression2) Filter operator that checks that its first subexpression is less than or equal to its second subexpression.lessOrEqual
(Expression<R, ?> expression1, Expression<R, ?> expression2, boolean isMatchingCase, MatchAction matchAction) Filter operator that checks that its first subexpression is less than or equal to its second subexpression.default LikeOperator
<R> like
(Expression<R, ?> expression, String pattern) Character string comparison operator with pattern matching and default wildcards.like
(Expression<R, ?> expression, String pattern, char wildcard, char singleChar, char escape, boolean isMatchingCase) Character string comparison operator with pattern matching and specified wildcards.literal
(V value) Creates a constant, literal value that can be used in expressions.meets
(Expression<R, ? extends T> time1, Expression<R, ? extends T> time2) Creates an operator that checks if first temporal operand meets the second.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.multiply
(Expression<R, ? extends Number> operand1, Expression<R, ? extends Number> operand2) Creates a function computing the numeric product of their first and second operand.Creates aNOT
filter for the given filter.default BinaryComparisonOperator
<R> notEqual
(Expression<R, ?> expression1, Expression<R, ?> expression2) Filter operator that compares that its two subexpressions are not equal to each other.notEqual
(Expression<R, ?> expression1, Expression<R, ?> expression2, boolean isMatchingCase, MatchAction matchAction) Filter operator that compares that its two subexpressions are not equal to each other.or
(Collection<? extends Filter<R>> operands) Creates aOR
filter between two or more filters.default LogicalOperator
<R> Creates aOR
filter between two filters.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.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, ?> Creates an expression whose value is computed by retrieving the value indicated by a path in a resource.<V> ValueReference
<R, V> 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
(String rid, Version version, Instant startTime, Instant endTime) Creates a predicate to identify an identifiable resource within a filter expression.sort
(ValueReference<R, ?> property, SortOrder order) Indicates a property by which contents should be sorted, along with intended order.subtract
(Expression<R, ? extends Number> operand1, Expression<R, ? extends Number> operand2) Creates a function computing the numeric difference between the first and second operand.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.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.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.toverlaps
(Expression<R, ? extends T> time1, Expression<R, ? extends T> time2) Creates an operator that checks if first temporal operand overlaps the second.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.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.

Method Details

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
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
Creates a predicate to identify an identifiable resource within a filter expression. IfstartTime
andendTime
are nonnull, 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, ornull
for any version.startTime
 start time of the resource to select, ornull
if none.endTime
 end time of the resource to select, ornull
if none. Returns:
 the predicate.

property
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 theapply(R)
method. Returns:
 an expression evaluating the referenced property value.

property
Creates an expression retrieving the value as an instance of the specified class. Thexpath
argument follows the rule described inproperty(String)
.The desired type of property values can be specified. For example if the property values should be numbers, then
type
can beNumber.class
. If property values can be of any type with no conversion desired, thentype
should beObject.class
. Type Parameters:
V
 the type of the values to be fetched (compiletime value oftype
). Parameters:
xpath
 the path to the property whose value will be returned by theapply(R)
method.type
 the type of the values to be fetched (runtime value of<V>
). Returns:
 an expression evaluating the referenced property value.

literal
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 aGeometry
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 benull
. Returns:
 a literal for the given value.

equal
Filter operator that compares that its two subexpressions are equal to each other. The comparison is casesensitive and evaluates totrue
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:

equal
BinaryComparisonOperator<R> equal(Expression<R, ?> expression1, Expression<R, ?> expression2, boolean isMatchingCase, MatchAction matchAction) Filter operator that compares that its two subexpressions 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:

notEqual
default BinaryComparisonOperator<R> notEqual(Expression<R, ?> expression1, Expression<R, ?> expression2) Filter operator that compares that its two subexpressions are not equal to each other. The comparison is casesensitive and evaluates totrue
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:

notEqual
BinaryComparisonOperator<R> notEqual(Expression<R, ?> expression1, Expression<R, ?> expression2, boolean isMatchingCase, MatchAction matchAction) Filter operator that compares that its two subexpressions 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:

less
Filter operator that checks that its first subexpression is less than its second subexpression. The comparison is casesensitive and evaluates totrue
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:
 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 subexpression is less than its second subexpression. 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:
 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 subexpression is greater than its second subexpression. The comparison is casesensitive and evaluates totrue
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:
 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 subexpression is greater than its second subexpression. 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:
 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 subexpression is less than or equal to its second subexpression. The comparison is casesensitive and evaluates totrue
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:
 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 subexpression is less than or equal to its second subexpression. 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:
 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 subexpression is greater than its second subexpression. The comparison is casesensitive and evaluates totrue
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:
 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 subexpression is greater than its second subexpression. 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:
 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
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 casesensitive. 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
An operator that tests if an expression's value isnull
. This corresponds to checking whether the property exists in the realworld. Parameters:
expression
 source of values to compare againstnull
. Returns:
 a filter that checks if an expression's value is
null
.

isNil
An operator that tests if an expression's value is nil. The difference withNullOperator
is that a value should exist but cannot be provided for the reason given bynilReason
. 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, ornull
for accepting any reason. Returns:
 a filter that checks if an expression's value is nil for the specified reason.

and

and
Creates aAND
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:

or

or
Creates aOR
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:

not
Creates aNOT
filter for the given filter. Parameters:
operand
 the operand of the NOT operation. Returns:
 a filter evaluating
NOT operand
.  See Also:

bbox
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:

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:
 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:

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:

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:

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:

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:

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:

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:

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 astrue
. 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:

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 astrue
. 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:

after
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:

before
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:

begins
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:

begunBy
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:

tcontains
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:

during
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:

tequals
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:

toverlaps
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:

meets
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:

ends
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:

overlappedBy
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:

metBy
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:

endedBy
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:

anyInteracts
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:

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
Creates an implementationspecific function with a single parameter. The names of available functions is given bygetCapabilities()
. 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:

function
Creates an implementationspecific function with two parameters. The names of available functions is given bygetCapabilities()
. 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:

function
Creates an implementationspecific function with an arbitrary number of parameters. The names of available functions is given bygetCapabilities()
. 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:

sort
Indicates a property by which contents should be sorted, along with intended order. Implementation may require that the given expression evaluates toComparable
objects. Parameters:
property
 the property to sort by.order
 the sorting order, ascending or descending. Returns:
 definition of sort order of a property.
