# Class DefaultFilterFactory<R,G,T>

Object
AbstractFactory
DefaultFilterFactory<R,G,T>

Type Parameters:
  `R` - the type of resources (e.g. `AbstractFeature`) 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:
  `DefaultFilterFactory​.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 `AbstractFeature`.
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`
  `DefaultFilterFactory​.Features<G,T>`
  A filter factory operating on `AbstractFeature` instances.

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `DefaultFilterFactory(Class<G> spatial, Class<T> temporal, WraparoundMethod 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>`
  `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).
  `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>`
  `begunBy(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,?> lowerBoundary, Expression<R,?> upperBoundary)`
  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>`
  `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.
  `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 DefaultFilterFactory<AbstractFeature, Object, Object>`
  `forFeatures()`
  Returns a factory operating on `AbstractFeature` instances.
  `static <R> Optional<DefaultFilterFactory<R,Object,Object>>`
  `forResources(Class<R> type)`
  Returns a factory operating on resource instances of the given class.
  `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>`
  `greaterOrEqual(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>`
  `isNil(Expression<R,?> expression, String nilReason)`
  An operator that tests if an expression's value is nil.
  `Filter<R>`
  `isNull(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>`
  `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.
  `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 singleChar, char escape, boolean isMatchingCase)`
  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>`
  `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.
  `Filter<R>`
  `not(Filter<R> operand)`
  Creates a `NOT` filter for the given filter.
  `Filter<R>`
  `notEqual(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>`
  `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.
  `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>`
  `resourceId(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

  `getVendor, toString`

  ### Methods inherited from class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, 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`

    The `temporal` argument should be one of the `Temporal` implementation classes. The `Temporal​.class` or `Object​.class` arguments are also accepted if the temporal class is not known at compile-time, in which case it will be determined on a case-by-case basis at runtime. Note the latter is lightly more expensive that specifying an implementation class in advance.
    Parameters:
      `spatial` - type of spatial objects, or `Object​.class` for default.
      `temporal` - type of temporal objects, or `Object​.class` for any supported type.
      `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 `AbstractFeature` instances. The geometry library will be the system default. The temporal objects can be `Date` or implementations of `Temporal`.
    Returns:
      factory operating on `AbstractFeature` instances.

  - ### forResources

    public static <R> Optional<DefaultFilterFactory<R,Object,Object>> forResources(Class<R> type)
    Returns a factory operating on resource instances of the given class. The current implementation recognizes the following classes:
    - invalid reference

          Feature

      : delegate to `forFeatures()`.
    More classes may be added in future versions.
    Type Parameters:
      `R` - compile-time value of the `type` argument.
    Parameters:
      `type` - type of resources that the factory shall accept.
    Returns:
      factory operating on resource instances of the given class.
    Since:
      1.5

  - ### 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.
      `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

    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.
      `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

    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 `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.
    See Also:
      - `NilObject`
      - `NilReason`

  - ### 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:
      `IllegalArgumentException` - 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:
      `IllegalArgumentException` - 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:
      `IllegalArgumentException` - 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:
      `IllegalArgumentException` - 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:
      `IllegalArgumentException` - if the given name is not recognized, or if the arguments are illegal for the specified function.