Package org.optaplanner.core.api.score.stream

## Class Joiners

- java.lang.Object
- - org.optaplanner.core.api.score.stream.Joiners

-     public final class Joiners
      extends Object

  Creates an `BiJoiner`, `TriJoiner`, ... instance for use in `UniConstraintStream.join(Class, BiJoiner)`, ...

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <A> BiJoiner<A,​A>` | `equal()` | Joins every A and B that are equal.
    `static <A,​B,​C,​Property_> TriJoiner<A,​B,​C>` | `equal​(BiFunction<A,​B,​Property_> leftMapping, Function<C,​Property_> rightMapping)` | Joins every (A,B) and C that share a property.
    `static <A,​Property_> BiJoiner<A,​A>` | `equal​(Function<A,​Property_> mapping)` | Joins every A and B that share a property.
    `static <A,​B,​Property_> BiJoiner<A,​B>` | `equal​(Function<A,​Property_> leftMapping, Function<B,​Property_> rightMapping)` | Joins every A and B that share a property.
    `static <A,​B,​C,​D,​E,​Property_> PentaJoiner<A,​B,​C,​D,​E>` | `equal​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping, Function<E,​Property_> rightMapping)` | Joins every (A,B,C,D) and E that share a property.
    `static <A,​B,​C,​D,​Property_> QuadJoiner<A,​B,​C,​D>` | `equal​(TriFunction<A,​B,​C,​Property_> leftMapping, Function<D,​Property_> rightMapping)` | Joins every (A,B,C) and D that share a property.
    `static <A,​B> BiJoiner<A,​B>` | `filtering​(BiPredicate<A,​B> filter)` | Applies a filter to the joined tuple, with the semantics of `BiConstraintStream.filter(BiPredicate)`.
    `static <A,​B,​C,​D,​E> PentaJoiner<A,​B,​C,​D,​E>` | `filtering​(PentaPredicate<A,​B,​C,​D,​E> filter)` |
    `static <A,​B,​C,​D> QuadJoiner<A,​B,​C,​D>` | `filtering​(QuadPredicate<A,​B,​C,​D> filter)` | Applies a filter to the joined tuple (A,B,C,D), with the semantics of `QuadConstraintStream.filter(QuadPredicate)`.
    `static <A,​B,​C> TriJoiner<A,​B,​C>` | `filtering​(TriPredicate<A,​B,​C> filter)` | Applies a filter to the joined tuple (A,B,C), with the semantics of `TriConstraintStream.filter(TriPredicate)`.
    `static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C>` | `greaterThan​(BiFunction<A,​B,​Property_> leftMapping, Function<C,​Property_> rightMapping)` | Joins every (A,B) and C where a value of property of (A,B) is greater than the value of a property of C.
    `static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A>` | `greaterThan​(Function<A,​Property_> mapping)` | Joins every A and B where a value of property on A is greater than the value of the same property on B.
    `static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B>` | `greaterThan​(Function<A,​Property_> leftMapping, Function<B,​Property_> rightMapping)` | Joins every A and B where a value of property on A is greater than the value of a property on B.
    `static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E>` | `greaterThan​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping, Function<E,​Property_> rightMapping)` | Joins every (A,B,C,D) and E where a value of property of (A,B,C,D) is greater than the value of a property of E.
    `static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D>` | `greaterThan​(TriFunction<A,​B,​C,​Property_> leftMapping, Function<D,​Property_> rightMapping)` | Joins every (A,B,C) and D where a value of property of (A,B,C) is greater than the value of a property of D.
    `static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C>` | `greaterThanOrEqual​(BiFunction<A,​B,​Property_> leftMapping, Function<C,​Property_> rightMapping)` | Joins every (A,B) and C where a value of property of (A,B) is greater than or equal to the value of a property of C.
    `static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A>` | `greaterThanOrEqual​(Function<A,​Property_> mapping)` | Joins every A and B where a value of property on A is greater than or equal to the value of the same property on B.
    `static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B>` | `greaterThanOrEqual​(Function<A,​Property_> leftMapping, Function<B,​Property_> rightMapping)` | Joins every A and B where a value of property on A is greater than or equal to the value of a property on B.
    `static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E>` | `greaterThanOrEqual​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping, Function<E,​Property_> rightMapping)` | Joins every (A,B,C,D) and E where a value of property of (A,B,C,D) is greater than or equal to the value of a property of E.
    `static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D>` | `greaterThanOrEqual​(TriFunction<A,​B,​C,​Property_> leftMapping, Function<D,​Property_> rightMapping)` | Joins every (A,B,C) and D where a value of property of (A,B,C) is greater than or equal to the value of a property of D.
    `static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C>` | `lessThan​(BiFunction<A,​B,​Property_> leftMapping, Function<C,​Property_> rightMapping)` | Joins every (A,B) and C where a value of property of (A,B) is less than the value of a property of C.
    `static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A>` | `lessThan​(Function<A,​Property_> mapping)` | Joins every A and B where a value of property on A is less than the value of the same property on B.
    `static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B>` | `lessThan​(Function<A,​Property_> leftMapping, Function<B,​Property_> rightMapping)` | Joins every A and B where a value of property on A is less than the value of a property on B.
    `static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E>` | `lessThan​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping, Function<E,​Property_> rightMapping)` | Joins every (A,B,C,D) and E where a value of property of (A,B,C,D) is less than the value of a property of E.
    `static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D>` | `lessThan​(TriFunction<A,​B,​C,​Property_> leftMapping, Function<D,​Property_> rightMapping)` | Joins every (A,B,C) and D where a value of property of (A,B,C) is less than the value of a property of D.
    `static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C>` | `lessThanOrEqual​(BiFunction<A,​B,​Property_> leftMapping, Function<C,​Property_> rightMapping)` | Joins every (A,B) and C where a value of property of (A,B) is less than or equal to the value of a property of C.
    `static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A>` | `lessThanOrEqual​(Function<A,​Property_> mapping)` | Joins every A and B where a value of property on A is less than or equal to the value of the same property on B.
    `static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B>` | `lessThanOrEqual​(Function<A,​Property_> leftMapping, Function<B,​Property_> rightMapping)` | Joins every A and B where a value of property on A is less than or equal to the value of a property on B.
    `static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E>` | `lessThanOrEqual​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping, Function<E,​Property_> rightMapping)` | Joins every (A,B,C,D) and E where a value of property of (A,B,C,D) is less than or equal to the value of a property of E.
    `static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D>` | `lessThanOrEqual​(TriFunction<A,​B,​C,​Property_> leftMapping, Function<D,​Property_> rightMapping)` | Joins every (A,B,C) and D where a value of property of (A,B,C) is less than or equal to the value of a property of D.
    `static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C>` | `overlapping​(BiFunction<A,​B,​Property_> leftStartMapping, BiFunction<A,​B,​Property_> leftEndMapping, Function<C,​Property_> rightStartMapping, Function<C,​Property_> rightEndMapping)` | As defined by `overlapping(Function, Function)`.
    `static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A>` | `overlapping​(Function<A,​Property_> startMapping, Function<A,​Property_> endMapping)` | Joins every A and B that overlap for an interval which is specified by a start and end property on both A and B.
    `static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B>` | `overlapping​(Function<A,​Property_> leftStartMapping, Function<A,​Property_> leftEndMapping, Function<B,​Property_> rightStartMapping, Function<B,​Property_> rightEndMapping)` | As defined by `overlapping(Function, Function)`.
    `static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E>` | `overlapping​(QuadFunction<A,​B,​C,​D,​Property_> leftStartMapping, QuadFunction<A,​B,​C,​D,​Property_> leftEndMapping, Function<E,​Property_> rightStartMapping, Function<E,​Property_> rightEndMapping)` | As defined by `overlapping(Function, Function)`.
    `static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D>` | `overlapping​(TriFunction<A,​B,​C,​Property_> leftStartMapping, TriFunction<A,​B,​C,​Property_> leftEndMapping, Function<D,​Property_> rightStartMapping, Function<D,​Property_> rightEndMapping)` | As defined by `overlapping(Function, Function)`.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### equal

          public static <A> BiJoiner<A,​A> equal()

      Joins every A and B that are equal. Delegates to `equal(Function)` with `Function.identity()` as the argument.
      Type Parameters:
        `A` - the type of both objects
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where A and B are equal

    - #### equal

          public static <A,​Property_> BiJoiner<A,​A> equal​(Function<A,​Property_> mapping)

      Joins every A and B that share a property. These are exactly the pairs where `mapping.apply(A).equals(mapping.apply(B))`. Delegates to `equal(Function, Function)` with both arguments using the same mapping.
      Type Parameters:
        `A` - the type of both objects
        `Property_` - the type of the property to compare
      Parameters:
        `mapping` - mapping function to apply to both A and B
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where the same property of A and B is equal

    - #### equal

          public static <A,​B,​Property_> BiJoiner<A,​B> equal​(Function<A,​Property_> leftMapping,
                                                                              Function<B,​Property_> rightMapping)

      Joins every A and B that share a property. These are exactly the pairs where `leftMapping.apply(A).equals(rightMapping.apply(B))`.
      Type Parameters:
        `A` - the type of object on the left
        `B` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to A
        `rightMapping` - mapping function to apply to B
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A equals that of B

    - #### lessThan

          public static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A> lessThan​(Function<A,​Property_> mapping)

      Joins every A and B where a value of property on A is less than the value of the same property on B. These are exactly the pairs where `mapping.apply(A).compareTo(mapping.apply(B)) < 0`. Delegates to `lessThan(Function, Function)` with both arguments using the same mapping.
      Type Parameters:
        `A` - the type of both objects
        `Property_` - the type of the property to compare
      Parameters:
        `mapping` - mapping function to apply
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A is less than that of B

    - #### lessThan

          public static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B> lessThan​(Function<A,​Property_> leftMapping,
                                                                                                               Function<B,​Property_> rightMapping)

      Joins every A and B where a value of property on A is less than the value of a property on B. These are exactly the pairs where `leftMapping.apply(A).compareTo(rightMapping.apply(B)) < 0`.
      Type Parameters:
        `A` - the type of object on the left
        `B` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to A
        `rightMapping` - mapping function to apply to B
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A is less than a property of B

    - #### lessThanOrEqual

          public static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A> lessThanOrEqual​(Function<A,​Property_> mapping)

      Joins every A and B where a value of property on A is less than or equal to the value of the same property on B. These are exactly the pairs where `mapping.apply(A).compareTo(mapping.apply(B)) <= 0`. Delegates to `lessThanOrEqual(Function, Function)` with both arguments using the same mapping.
      Type Parameters:
        `A` - the type of both objects
        `Property_` - the type of the property to compare
      Parameters:
        `mapping` - mapping function to apply
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A is less than or equal to that of B

    - #### lessThanOrEqual

          public static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B> lessThanOrEqual​(Function<A,​Property_> leftMapping,
                                                                                                                      Function<B,​Property_> rightMapping)

      Joins every A and B where a value of property on A is less than or equal to the value of a property on B. These are exactly the pairs where `leftMapping.apply(A).compareTo(rightMapping.apply(B)) <= 0`.
      Type Parameters:
        `A` - the type of object on the left
        `B` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to A
        `rightMapping` - mapping function to apply to B
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A is less than or equal to a property of B

    - #### greaterThan

          public static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A> greaterThan​(Function<A,​Property_> mapping)

      Joins every A and B where a value of property on A is greater than the value of the same property on B. These are exactly the pairs where `mapping.apply(A).compareTo(mapping.apply(B)) > 0`. Delegates to `greaterThan(Function, Function)` with both arguments using the same mapping.
      Type Parameters:
        `A` - the type of both objects
        `Property_` - the type of the property to compare
      Parameters:
        `mapping` - mapping function to apply
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A is greater than that of B

    - #### greaterThan

          public static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B> greaterThan​(Function<A,​Property_> leftMapping,
                                                                                                                  Function<B,​Property_> rightMapping)

      Joins every A and B where a value of property on A is greater than the value of a property on B. These are exactly the pairs where `leftMapping.apply(A).compareTo(rightMapping.apply(B)) > 0`.
      Type Parameters:
        `A` - the type of object on the left
        `B` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to A
        `rightMapping` - mapping function to apply to B
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A is greater than a property of B

    - #### greaterThanOrEqual

          public static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A> greaterThanOrEqual​(Function<A,​Property_> mapping)

      Joins every A and B where a value of property on A is greater than or equal to the value of the same property on B. These are exactly the pairs where `mapping.apply(A).compareTo(mapping.apply(B)) >= 0`. Delegates to `greaterThanOrEqual(Function, Function)` with both arguments using the same mapping.
      Type Parameters:
        `A` - the type of both objects
        `Property_` - the type of the property to compare
      Parameters:
        `mapping` - mapping function to apply
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A is greater than or equal to that of B

    - #### greaterThanOrEqual

          public static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B> greaterThanOrEqual​(Function<A,​Property_> leftMapping,
                                                                                                                         Function<B,​Property_> rightMapping)

      Joins every A and B where a value of property on A is greater than or equal to the value of a property on B. These are exactly the pairs where `leftMapping.apply(A).compareTo(rightMapping.apply(B)) >= 0`.
      Type Parameters:
        `A` - the type of object on the left
        `B` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to A
        `rightMapping` - mapping function to apply to B
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where a property of A is greater than or equal to a property of B

    - #### filtering

          public static <A,​B> BiJoiner<A,​B> filtering​(BiPredicate<A,​B> filter)

      Applies a filter to the joined tuple, with the semantics of `BiConstraintStream.filter(BiPredicate)`.
      Type Parameters:
        `A` - type of the first fact in the tuple
        `B` - type of the second fact in the tuple
      Parameters:
        `filter` - never null, filter to apply
      Returns:
        never null

    - #### overlapping

          public static <A,​Property_ extends Comparable<Property_>> BiJoiner<A,​A> overlapping​(Function<A,​Property_> startMapping,
                                                                                                          Function<A,​Property_> endMapping)

      Joins every A and B that overlap for an interval which is specified by a start and end property on both A and B. These are exactly the pairs where `A.start < B.end` and `A.end > B.start`.
      Type Parameters:
        `A` - the type of both the first and second argument
        `Property_` - the type used to define the interval, comparable
      Parameters:
        `startMapping` - maps the argument to the start point of its interval (inclusive)
        `endMapping` - maps the argument to the end point of its interval (exclusive)
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where A's and B's intervals (as defined by the function mapping) overlap

    - #### overlapping

          public static <A,​B,​Property_ extends Comparable<Property_>> BiJoiner<A,​B> overlapping​(Function<A,​Property_> leftStartMapping,
                                                                                                                  Function<A,​Property_> leftEndMapping,
                                                                                                                  Function<B,​Property_> rightStartMapping,
                                                                                                                  Function<B,​Property_> rightEndMapping)

      As defined by `overlapping(Function, Function)`.
      Type Parameters:
        `A` - the type of the first argument
        `B` - the type of the second argument
        `Property_` - the type used to define the interval, comparable
      Parameters:
        `leftStartMapping` - maps the first argument to its interval start point (inclusive)
        `leftEndMapping` - maps the first argument to its interval end point (exclusive)
        `rightStartMapping` - maps the second argument to its interval start point (inclusive)
        `rightEndMapping` - maps the second argument to its interval end point (exclusive)
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B) where A's and B's intervals (as defined by the function mapping) overlap

    - #### equal

          public static <A,​B,​C,​Property_> TriJoiner<A,​B,​C> equal​(BiFunction<A,​B,​Property_> leftMapping,
                                                                                               Function<C,​Property_> rightMapping)

      Joins every (A,B) and C that share a property. These are exactly the pairs where `leftMapping.apply(A, B).equals(rightMapping.apply(C))`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B)
        `rightMapping` - mapping function to apply to C
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C) where a property of (A,B) equals that of C

    - #### lessThan

          public static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C> lessThan​(BiFunction<A,​B,​Property_> leftMapping,
                                                                                                                                Function<C,​Property_> rightMapping)

      Joins every (A,B) and C where a value of property of (A,B) is less than the value of a property of C. These are exactly the pairs where `leftMapping.apply(A, B).compareTo(rightMapping.apply(C)) < 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B)
        `rightMapping` - mapping function to apply to C
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C) where a property of (A,B) is less than a property of C

    - #### lessThanOrEqual

          public static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C> lessThanOrEqual​(BiFunction<A,​B,​Property_> leftMapping,
                                                                                                                                       Function<C,​Property_> rightMapping)

      Joins every (A,B) and C where a value of property of (A,B) is less than or equal to the value of a property of C. These are exactly the pairs where `leftMapping.apply(A, B).compareTo(rightMapping.apply(C)) <= 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B)
        `rightMapping` - mapping function to apply to C
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C) where a property of (A,B) is less than or equal to a property of C

    - #### greaterThan

          public static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C> greaterThan​(BiFunction<A,​B,​Property_> leftMapping,
                                                                                                                                   Function<C,​Property_> rightMapping)

      Joins every (A,B) and C where a value of property of (A,B) is greater than the value of a property of C. These are exactly the pairs where `leftMapping.apply(A, B).compareTo(rightMapping.apply(C)) > 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B)
        `rightMapping` - mapping function to apply to C
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C) where a property of (A,B) is greater than a property of C

    - #### greaterThanOrEqual

          public static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C> greaterThanOrEqual​(BiFunction<A,​B,​Property_> leftMapping,
                                                                                                                                          Function<C,​Property_> rightMapping)

      Joins every (A,B) and C where a value of property of (A,B) is greater than or equal to the value of a property of C. These are exactly the pairs where `leftMapping.apply(A, B).compareTo(rightMapping.apply(C)) >= 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B)
        `rightMapping` - mapping function to apply to C
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C) where a property of (A,B) is greater than or equal to a property of C

    - #### filtering

          public static <A,​B,​C> TriJoiner<A,​B,​C> filtering​(TriPredicate<A,​B,​C> filter)

      Applies a filter to the joined tuple (A,B,C), with the semantics of `TriConstraintStream.filter(TriPredicate)`.
      Type Parameters:
        `A` - type of the first fact in the tuple
        `B` - type of the second fact in the tuple
        `C` - type of the third fact in the tuple
      Parameters:
        `filter` - never null, filter to apply
      Returns:
        never null

    - #### overlapping

          public static <A,​B,​C,​Property_ extends Comparable<Property_>> TriJoiner<A,​B,​C> overlapping​(BiFunction<A,​B,​Property_> leftStartMapping,
                                                                                                                                   BiFunction<A,​B,​Property_> leftEndMapping,
                                                                                                                                   Function<C,​Property_> rightStartMapping,
                                                                                                                                   Function<C,​Property_> rightEndMapping)

      As defined by `overlapping(Function, Function)`.
      Type Parameters:
        `A` - the type of the first argument
        `B` - the type of the second argument
        `C` - the type of the third argument
        `Property_` - the type used to define the interval, comparable
      Parameters:
        `leftStartMapping` - maps the first and second arguments to their interval start point (inclusive)
        `leftEndMapping` - maps the first and second arguments to their interval end point (exclusive)
        `rightStartMapping` - maps the third argument to its interval start point (inclusive)
        `rightEndMapping` - maps the third argument to its interval end point (exclusive)
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C) where (A,B)'s and C's intervals (as defined by the function mapping) overlap

    - #### equal

          public static <A,​B,​C,​D,​Property_> QuadJoiner<A,​B,​C,​D> equal​(TriFunction<A,​B,​C,​Property_> leftMapping,
                                                                                                                Function<D,​Property_> rightMapping)

      Joins every (A,B,C) and D that share a property. These are exactly the pairs where `leftMapping.apply(A, B, C).equals(rightMapping.apply(D))`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of the object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A, B, C)
        `rightMapping` - mapping function to apply to D
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D) where a property of (A,B,C) equals that of D

    - #### lessThan

          public static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D> lessThan​(TriFunction<A,​B,​C,​Property_> leftMapping,
                                                                                                                                                 Function<D,​Property_> rightMapping)

      Joins every (A,B,C) and D where a value of property of (A,B,C) is less than the value of a property of D. These are exactly the pairs where `leftMapping.apply(A, B, C).compareTo(rightMapping.apply(D)) < 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C)
        `rightMapping` - mapping function to apply to D
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D) where a property of (A,B,C) is less than a property of D

    - #### lessThanOrEqual

          public static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D> lessThanOrEqual​(TriFunction<A,​B,​C,​Property_> leftMapping,
                                                                                                                                                        Function<D,​Property_> rightMapping)

      Joins every (A,B,C) and D where a value of property of (A,B,C) is less than or equal to the value of a property of D. These are exactly the pairs where `leftMapping.apply(A, B, C).compareTo(rightMapping.apply(D)) <= 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C)
        `rightMapping` - mapping function to apply to D
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D) where a property of (A,B,C) is less than or equal to a property of D

    - #### greaterThan

          public static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D> greaterThan​(TriFunction<A,​B,​C,​Property_> leftMapping,
                                                                                                                                                    Function<D,​Property_> rightMapping)

      Joins every (A,B,C) and D where a value of property of (A,B,C) is greater than the value of a property of D. These are exactly the pairs where `leftMapping.apply(A, B, C).compareTo(rightMapping.apply(D)) > 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C)
        `rightMapping` - mapping function to apply to D
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D) where a property of (A,B,C) is greater than a property of D

    - #### greaterThanOrEqual

          public static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D> greaterThanOrEqual​(TriFunction<A,​B,​C,​Property_> leftMapping,
                                                                                                                                                           Function<D,​Property_> rightMapping)

      Joins every (A,B,C) and D where a value of property of (A,B,C) is greater than or equal to the value of a property of D. These are exactly the pairs where `leftMapping.apply(A, B, C).compareTo(rightMapping.apply(D)) >= 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C)
        `rightMapping` - mapping function to apply to D
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D) where a property of (A,B,C) is greater than or equal to a property of D

    - #### filtering

          public static <A,​B,​C,​D> QuadJoiner<A,​B,​C,​D> filtering​(QuadPredicate<A,​B,​C,​D> filter)

      Applies a filter to the joined tuple (A,B,C,D), with the semantics of `QuadConstraintStream.filter(QuadPredicate)`.
      Type Parameters:
        `A` - type of the first fact in the tuple
        `B` - type of the second fact in the tuple
        `C` - type of the third fact in the tuple
        `D` - type of the fourth fact in the tuple
      Parameters:
        `filter` - never null, filter to apply
      Returns:
        never null

    - #### overlapping

          public static <A,​B,​C,​D,​Property_ extends Comparable<Property_>> QuadJoiner<A,​B,​C,​D> overlapping​(TriFunction<A,​B,​C,​Property_> leftStartMapping,
                                                                                                                                                    TriFunction<A,​B,​C,​Property_> leftEndMapping,
                                                                                                                                                    Function<D,​Property_> rightStartMapping,
                                                                                                                                                    Function<D,​Property_> rightEndMapping)

      As defined by `overlapping(Function, Function)`.
      Type Parameters:
        `A` - the type of the first argument
        `B` - the type of the second argument
        `C` - the type of the third argument
        `D` - the type of the fourth argument
        `Property_` - the type used to define the interval, comparable
      Parameters:
        `leftStartMapping` - maps the first, second and third arguments to their interval start point (inclusive)
        `leftEndMapping` - maps the first, second and third arguments to their interval end point (exclusive)
        `rightStartMapping` - maps the fourth argument to its interval start point (inclusive)
        `rightEndMapping` - maps the fourth argument to its interval end point (exclusive)
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D) where (A,B,C)'s and D's intervals (as defined by the function mapping) overlap

    - #### equal

          public static <A,​B,​C,​D,​E,​Property_> PentaJoiner<A,​B,​C,​D,​E> equal​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping,
                                                                                                                                 Function<E,​Property_> rightMapping)

      Joins every (A,B,C,D) and E that share a property. These are exactly the pairs where `leftMapping.apply(A, B, C, D).equals(rightMapping.apply(E))`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of the fourth object on the left
        `E` - the type of the object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C,D)
        `rightMapping` - mapping function to apply to E
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D,E) where a property of (A,B,C,D) equals that of E

    - #### lessThan

          public static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E> lessThan​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping,
                                                                                                                                                                  Function<E,​Property_> rightMapping)

      Joins every (A,B,C,D) and E where a value of property of (A,B,C,D) is less than the value of a property of E. These are exactly the pairs where `leftMapping.apply(A, B, C, D).compareTo(rightMapping.apply(E)) < 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of the fourth object on the left
        `E` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C,D)
        `rightMapping` - mapping function to apply to E
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D,E) where a property of (A,B,C,D) is less than a property of E

    - #### lessThanOrEqual

          public static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E> lessThanOrEqual​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping,
                                                                                                                                                                         Function<E,​Property_> rightMapping)

      Joins every (A,B,C,D) and E where a value of property of (A,B,C,D) is less than or equal to the value of a property of E. These are exactly the pairs where `leftMapping.apply(A, B, C, D).compareTo(rightMapping.apply(E)) <= 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of the fourth object on the left
        `E` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C,D)
        `rightMapping` - mapping function to apply to E
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D,E) where a property of (A,B,C,D) is less than or equal to a property of E

    - #### greaterThan

          public static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E> greaterThan​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping,
                                                                                                                                                                     Function<E,​Property_> rightMapping)

      Joins every (A,B,C,D) and E where a value of property of (A,B,C,D) is greater than the value of a property of E. These are exactly the pairs where `leftMapping.apply(A, B, C, D).compareTo(rightMapping.apply(E)) > 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of the fourth object on the left
        `E` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C,D)
        `rightMapping` - mapping function to apply to E
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D,E) where a property of (A,B,C,D) is greater than a property of E

    - #### greaterThanOrEqual

          public static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E> greaterThanOrEqual​(QuadFunction<A,​B,​C,​D,​Property_> leftMapping,
                                                                                                                                                                            Function<E,​Property_> rightMapping)

      Joins every (A,B,C,D) and E where a value of property of (A,B,C,D) is greater than or equal to the value of a property of E. These are exactly the pairs where `leftMapping.apply(A, B, C, D).compareTo(rightMapping.apply(E)) >= 0`.
      Type Parameters:
        `A` - the type of the first object on the left
        `B` - the type of the second object on the left
        `C` - the type of the third object on the left
        `D` - the type of the fourth object on the left
        `E` - the type of object on the right
        `Property_` - the type of the property to compare
      Parameters:
        `leftMapping` - mapping function to apply to (A,B,C,D)
        `rightMapping` - mapping function to apply to E
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D,E) where a property of (A,B,C,D) is greater than or equal to a property of E

    - #### filtering

          public static <A,​B,​C,​D,​E> PentaJoiner<A,​B,​C,​D,​E> filtering​(PentaPredicate<A,​B,​C,​D,​E> filter)

    - #### overlapping

          public static <A,​B,​C,​D,​E,​Property_ extends Comparable<Property_>> PentaJoiner<A,​B,​C,​D,​E> overlapping​(QuadFunction<A,​B,​C,​D,​Property_> leftStartMapping,
                                                                                                                                                                     QuadFunction<A,​B,​C,​D,​Property_> leftEndMapping,
                                                                                                                                                                     Function<E,​Property_> rightStartMapping,
                                                                                                                                                                     Function<E,​Property_> rightEndMapping)

      As defined by `overlapping(Function, Function)`.
      Type Parameters:
        `A` - the type of the first argument
        `B` - the type of the second argument
        `C` - the type of the third argument
        `D` - the type of the fourth argument
        `E` - the type of the fifth argument
        `Property_` - the type used to define the interval, comparable
      Parameters:
        `leftStartMapping` - maps the first, second, third and fourth arguments to their interval start point (inclusive)
        `leftEndMapping` - maps the first, second, third and fourth arguments to their interval end point (exclusive)
        `rightStartMapping` - maps the fifth argument to its interval start point (inclusive)
        `rightEndMapping` - maps the fifth argument to its interval end point (exclusive)
      Returns:
        never null, a joiner that filters the constraint stream to only include elements (A,B,C,D,E) where (A,B,C,D)'s and E's intervals (as defined by the function mapping) overlap