Module org.apache.sis.feature

Package org.apache.sis.filter

Class DefaultFilterFactory<R,G,T>

Object

AbstractFactory

DefaultFilterFactory<R,G,T>

Type Parameters:

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

G - base class of geometry objects. The implementation-neutral type is GeoAPI Geometry, but this factory allows the use of other implementations such as JTS Geometry or ESRI Geometry.

T - base class of temporal objects.

All Implemented Interfaces:

Factory

Direct Known Subclasses:

Default­Filter­Factory.Features

public abstract class DefaultFilterFactory<R,G,T>
extends AbstractFactory

A factory of default Filter and Expression implementations. This base class operates on resources of arbitrary type <R>. Concrete subclass operates on resources of specific type such as Abstract­Feature.

Upcoming API change
In a future version, all Filter and Expression parameters may be replaced by parameters of the same names but from the org.opengis.filter package instead of org.apache.sis.filter. This change is pending next GeoAPI release. In addition, return types may become more specialized types.

Since:

1.1

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	Default­Filter­Factory.Features<G,T>	A filter factory operating on Abstract­Feature instances.

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Default­Filter­Factory(Class<G> spatial, Class<T> temporal, Wraparound­Method wraparound)	Creates a new factory for geometries and temporal objects of the given 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.
Filter<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.
Filter<R>	and(Collection<? extends Filter<R>> operands)	Creates a AND filter between two or more filters.
Filter<R>	and(Filter<R> operand1, Filter<R> operand2)	Creates a AND filter between two filters.
Filter<R>	any­Interacts(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).
Filter<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.
Filter<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.
Filter<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.
Filter<R>	begun­By(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand begun by the second.
Filter<R>	between(Expression<R,?> expression, Expression<R,?> lower­Boundary, Expression<R,?> upper­Boundary)	Filter operation for a range check.
Filter<R>	beyond(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2, 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.
Filter<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.
Filter<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.
Filter<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.
Filter<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.
Filter<R>	ended­By(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is ended by the second.
Filter<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.
Filter<R>	equal(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that compares that two sub-expressions are equal to each other.
Filter<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.
static Default­Filter­Factory<Abstract­Feature,Object,Object>	for­Features()	Returns a factory operating on Abstract­Feature instances.
Expression<R,?>	function(String name, Expression<? super R,?> parameter)	Creates an implementation-specific function with a single parameter.
Expression<R,?>	function(String name, Expression<? super R,?> param1, Expression<? super R,?> param2)	Creates an implementation-specific function with two parameters.
Expression<R,?>	function(String name, Expression<R,?>[] parameters)	Creates an implementation-specific function.
Filter<R>	greater(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that checks that its first sub-expression is greater than its second sub-expression.
Filter<R>	greater­Or­Equal(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that checks that its first sub-expression is greater than its second sub-expression.
Filter<R>	intersects(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2)	Creates an operator that checks if the two geometric operands intersect.
Filter<R>	is­Nil(Expression<R,?> expression, String nil­Reason)	An operator that tests if an expression's value is nil.
Filter<R>	is­Null(Expression<R,?> expression)	An operator that tests if an expression's value is null.
Filter<R>	less(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that checks that its first sub-expression is less than its second sub-expression.
Filter<R>	less­Or­Equal(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.
Filter<R>	like(Expression<R,?> expression, String pattern)	Character string comparison operator with pattern matching and default wildcards.
Filter<R>	like(Expression<R,?> expression, String pattern, char wildcard, char single­Char, char escape, boolean is­Matching­Case)	Character string comparison operator with pattern matching and specified wildcards.
<V> Expression<R,V>	literal(V value)	Creates a constant, literal value that can be used in expressions.
Filter<R>	meets(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand meets the second.
Filter<R>	met­By(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.
Filter<R>	not(Filter<R> operand)	Creates a NOT filter for the given filter.
Filter<R>	not­Equal(Expression<R,?> expression1, Expression<R,?> expression2)	Filter operator that compares that its two sub-expressions are not equal to each other.
Filter<R>	or(Collection<? extends Filter<R>> operands)	Creates a OR filter between two or more filters.
Filter<R>	or(Filter<R> operand1, Filter<R> operand2)	Creates a OR filter between two filters.
Filter<R>	overlapped­By(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand is overlapped by the second.
Filter<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.
Expression<R,?>	property(String xpath)	Creates an expression whose value is computed by retrieving the value indicated by a path in a resource.
abstract <V> Expression<R,V>	property(String xpath, Class<V> type)	Creates an expression retrieving the value as an instance of the specified class.
abstract Filter<R>	resource­Id(String rid)	Creates a predicate to identify an identifiable resource within a filter expression.
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.
Filter<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.
Filter<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.
Filter<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.
Filter<R>	toverlaps(Expression<R,? extends T> time1, Expression<R,? extends T> time2)	Creates an operator that checks if first temporal operand overlaps the second.
Filter<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.
Filter<R>	within(Expression<R,? extends G> geometry1, Expression<R,? extends G> geometry2, 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 class AbstractFactory

get­Vendor

Methods inherited from class Object

clone, equals, finalize, get­Class, hash­Code, notify, notify­All, to­String, wait, wait, wait

Constructor Details

DefaultFilterFactory

protected DefaultFilterFactory(Class<G> spatial,
 Class<T> temporal,
 WraparoundMethod wraparound)

Creates a new factory for geometries and temporal objects of the given types. The spatial argument can be one of the following classes:

Authorized spatial class argument values

Library	Spatial class
ESRI	com.esri.core.geometry.Geometry
JTS	org.locationtech.jts.geom.Geometry
Java2D	java.awt.Shape
Default	java.lang.Object

Authorized temporal class argument values

Library	Temporal class
Default	java.lang.Object

Parameters:

spatial - type of spatial objects, or Object.class for default.

temporal - type of temporal objects, or Object.class for default.

wraparound - the strategy to use for representing a region crossing the anti-meridian.

Method Details

forFeatures

public static DefaultFilterFactory<AbstractFeature,Object,Object> forFeatures()

Returns a factory operating on Abstract­Feature instances. The geometry library will be the system default.

Returns:

factory operating on Abstract­Feature instances.

"TODO:"

The type of temporal objects is not yet determined.

resourceId

public abstract Filter<R> resourceId(String rid)

Creates a predicate to identify an identifiable resource within a filter expression.

Parameters:

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

Returns:

the predicate.

property

public Expression<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

public abstract <V> Expression<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

public <V> Expression<R,V> literal(V value)

Creates a constant, literal value that can be used in expressions. The given value should be data objects such as strings, numbers, dates or geometries.

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

public Filter<R> equal(Expression<R,?> expression1,
 Expression<R,?> expression2)

Filter operator that compares that 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.

Returns:

a filter evaluating expression1 = expression2.

notEqual

public Filter<R> notEqual(Expression<R,?> expression1,
 Expression<R,?> expression2)

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.

Returns:

a filter evaluating expression1 ≠ expression2.

less

public Filter<R> less(Expression<R,?> expression1,
 Expression<R,?> expression2)

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.

Returns:

a filter evaluating expression1 < expression2.

greater

public Filter<R> greater(Expression<R,?> expression1,
 Expression<R,?> expression2)

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.

Returns:

a filter evaluating expression1 > expression2.

lessOrEqual

public Filter<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.

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.

greaterOrEqual

public Filter<R> greaterOrEqual(Expression<R,?> expression1,
 Expression<R,?> expression2)

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.

Returns:

a filter evaluating expression1 ≥ expression2.

between

public Filter<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.

lower­Boundary - the lower bound (inclusive) as an expression.

upper­Boundary - the upper bound (inclusive) as an expression.

Returns:

a filter evaluating (expression ≥ lower­Boundary) & (expression ≤ upper­Boundary).

like

public Filter<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

public Filter<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.

single­Char - pattern character for matching exactly one character.

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

is­Matching­Case - specifies how a filter expression processor should perform string comparisons.

Returns:

a character string comparison operator with pattern matching.

isNull

public Filter<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

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

An operator that tests if an expression's value is nil. The difference with Null­Operator is that a value should exist but cannot be provided for the reason given by nil­Reason. 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.

nil­Reason - 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.

See Also:

• Nil­Object
• Nil­Reason

and

public Filter<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.

and

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

Illegal­Argument­Exception - if the given collection contains less than 2 elements.

or

public Filter<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.

or

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

Illegal­Argument­Exception - if the given collection contains less than 2 elements.

not

public Filter<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.

bbox

public Filter<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.

equals

public Filter<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" operation between the two geometries.

disjoint

public Filter<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" operation between the two geometries.

intersects

public Filter<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" operation between the two geometries.

touches

public Filter<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" operation between the two geometries.

crosses

public Filter<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" operation between the two geometries.

within

public Filter<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" operation between the two geometries.

contains

public Filter<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" operation between the two geometries.

overlaps

public Filter<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" operation between the two geometries.

beyond

public Filter<R> beyond(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2,
 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.

within

public Filter<R> within(Expression<R,? extends G> geometry1,
 Expression<R,? extends G> geometry2,
 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.

after

public Filter<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.

before

public Filter<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.

begins

public Filter<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.

begunBy

public Filter<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.

tcontains

public Filter<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.

during

public Filter<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.

tequals

public Filter<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.

toverlaps

public Filter<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.

meets

public Filter<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.

ends

public Filter<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.

overlappedBy

public Filter<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.

metBy

public Filter<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.

endedBy

public Filter<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.

anyInteracts

public Filter<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.

add

public 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

public 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

public 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

public 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

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

Creates an implementation-specific function with a single parameter.

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:

Illegal­Argument­Exception - if the given name is not recognized, or if the argument is illegal for the specified function.

function

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

Creates an implementation-specific function with two parameters.

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:

Illegal­Argument­Exception - if the given name is not recognized, or if the arguments are illegal for the specified function.

function

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

Creates an implementation-specific function.

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:

Illegal­Argument­Exception - if the given name is not recognized, or if the arguments are illegal for the specified function.