org.optaplanner.core.api.score.stream

## Class ConstraintCollectors

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

-     public final class ConstraintCollectors
      extends Object

  Creates an `UniConstraintCollector`, `BiConstraintCollector`, ... instance for use in `UniConstraintStream.groupBy(Function, UniConstraintCollector)`, ...

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <A> UniConstraintCollector<A,?,Integer>` | `count()`
    `static <A,B> BiConstraintCollector<A,B,?,Integer>` | `countBi()`
    `static <A> UniConstraintCollector<A,?,Integer>` | `countDistinct()`
    `static <A,B> BiConstraintCollector<A,B,?,Integer>` | `countDistinct(BiFunction<A,B,?> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,Integer>` | `countDistinct(Function<A,?> groupValueMapping)`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer>` | `countDistinct(QuadFunction<A,B,C,D,?> groupValueMapping)`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,Integer>` | `countDistinct(TriFunction<A,B,C,?> groupValueMapping)`
    `static <A,B> BiConstraintCollector<A,B,?,Long>` | `countDistinctLong(BiFunction<A,B,?> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,Long>` | `countDistinctLong(Function<A,?> groupValueMapping)`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long>` | `countDistinctLong(QuadFunction<A,B,C,D,?> groupValueMapping)`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,Long>` | `countDistinctLong(TriFunction<A,B,C,?> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,Long>` | `countLong()`
    `static <A,B> BiConstraintCollector<A,B,?,Long>` | `countLongBi()`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long>` | `countLongQuad()`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,Long>` | `countLongTri()`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer>` | `countQuad()`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,Integer>` | `countTri()`
    `static <A extends Comparable<A>> UniConstraintCollector<A,?,A>` | `max()` Returns a collector that finds a maximum value in a group of `Comparable` elements.
    `static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,Mapped>` | `max(BiFunction<A,B,Mapped> groupValueMapping)` As defined by `max(Function)`.
    `static <A,B,Mapped> BiConstraintCollector<A,B,?,Mapped>` | `max(BiFunction<A,B,Mapped> groupValueMapping, Comparator<Mapped> comparator)` As defined by `max(Function)`, only with a custom `Comparator`.
    `static <A> UniConstraintCollector<A,?,A>` | `max(Comparator<A> comparator)` As defined by `max()`, only with a custom `Comparator`.
    `static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,Mapped>` | `max(Function<A,Mapped> groupValueMapping)` Returns a collector that finds a maximum value in a group of `Comparable` elements.
    `static <A,Mapped> UniConstraintCollector<A,?,Mapped>` | `max(Function<A,Mapped> groupValueMapping, Comparator<Mapped> comparator)` As defined by `max(Function)`, only with a custom `Comparator`.
    `static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,Mapped>` | `max(QuadFunction<A,B,C,D,Mapped> groupValueMapping)` As defined by `max(Function)`.
    `static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Mapped>` | `max(QuadFunction<A,B,C,D,Mapped> groupValueMapping, Comparator<Mapped> comparator)` As defined by `max(Function)`, only with a custom `Comparator`.
    `static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,Mapped>` | `max(TriFunction<A,B,C,Mapped> groupValueMapping)` As defined by `max(Function)`.
    `static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Mapped>` | `max(TriFunction<A,B,C,Mapped> groupValueMapping, Comparator<Mapped> comparator)` As defined by `max(Function)`, only with a custom `Comparator`.
    `static <A extends Comparable<A>> UniConstraintCollector<A,?,A>` | `min()` Returns a collector that finds a minimum value in a group of `Comparable` elements.
    `static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,Mapped>` | `min(BiFunction<A,B,Mapped> groupValueMapping)` As defined by `min(Function)`.
    `static <A,B,Mapped> BiConstraintCollector<A,B,?,Mapped>` | `min(BiFunction<A,B,Mapped> groupValueMapping, Comparator<Mapped> comparator)` As defined by `min(Function)`, only with a custom `Comparator`.
    `static <A> UniConstraintCollector<A,?,A>` | `min(Comparator<A> comparator)` As defined by `min()`, only with a custom `Comparator`.
    `static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,Mapped>` | `min(Function<A,Mapped> groupValueMapping)` Returns a collector that finds a minimum value in a group of `Comparable` elements.
    `static <A,Mapped> UniConstraintCollector<A,?,Mapped>` | `min(Function<A,Mapped> groupValueMapping, Comparator<Mapped> comparator)` As defined by `min(Function)`, only with a custom `Comparator`.
    `static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,Mapped>` | `min(QuadFunction<A,B,C,D,Mapped> groupValueMapping)` As defined by `min(Function)`.
    `static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Mapped>` | `min(QuadFunction<A,B,C,D,Mapped> groupValueMapping, Comparator<Mapped> comparator)` As defined by `min(Function)`, only with a custom `Comparator`.
    `static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,Mapped>` | `min(TriFunction<A,B,C,Mapped> groupValueMapping)` As defined by `min(Function)`.
    `static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Mapped>` | `min(TriFunction<A,B,C,Mapped> groupValueMapping, Comparator<Mapped> comparator)` As defined by `min(Function)`, only with a custom `Comparator`.
    `static <A,B,Result> BiConstraintCollector<A,B,?,Result>` | `sum(BiFunction<? super A,? super B,Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)`
    `static <A,Result> UniConstraintCollector<A,?,Result>` | `sum(Function<? super A,Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)`
    `static <A,B,C,D,Result> QuadConstraintCollector<A,B,C,D,?,Result>` | `sum(QuadFunction<? super A,? super B,? super C,? super D,Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)`
    `static <A,B> BiConstraintCollector<A,B,?,Integer>` | `sum(ToIntBiFunction<? super A,? super B> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,Integer>` | `sum(ToIntFunction<? super A> groupValueMapping)`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer>` | `sum(ToIntQuadFunction<? super A,? super B,? super C,? super D> groupValueMapping)`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,Integer>` | `sum(ToIntTriFunction<? super A,? super B,? super C> groupValueMapping)`
    `static <A,B,C,Result> TriConstraintCollector<A,B,C,?,Result>` | `sum(TriFunction<? super A,? super B,? super C,Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)`
    `static <A,B> BiConstraintCollector<A,B,?,BigDecimal>` | `sumBigDecimal(BiFunction<? super A,? super B,BigDecimal> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,BigDecimal>` | `sumBigDecimal(Function<? super A,BigDecimal> groupValueMapping)`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,BigDecimal>` | `sumBigDecimal(QuadFunction<? super A,? super B,? super C,? super D,BigDecimal> groupValueMapping)`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,BigDecimal>` | `sumBigDecimal(TriFunction<? super A,? super B,? super C,BigDecimal> groupValueMapping)`
    `static <A,B> BiConstraintCollector<A,B,?,BigInteger>` | `sumBigInteger(BiFunction<? super A,? super B,BigInteger> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,BigInteger>` | `sumBigInteger(Function<? super A,BigInteger> groupValueMapping)`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,BigInteger>` | `sumBigInteger(QuadFunction<? super A,? super B,? super C,? super D,BigInteger> groupValueMapping)`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,BigInteger>` | `sumBigInteger(TriFunction<? super A,? super B,? super C,BigInteger> groupValueMapping)`
    `static <A,B> BiConstraintCollector<A,B,?,Duration>` | `sumDuration(BiFunction<? super A,? super B,Duration> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,Duration>` | `sumDuration(Function<? super A,Duration> groupValueMapping)`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Duration>` | `sumDuration(QuadFunction<? super A,? super B,? super C,? super D,Duration> groupValueMapping)`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,Duration>` | `sumDuration(TriFunction<? super A,? super B,? super C,Duration> groupValueMapping)`
    `static <A,B> BiConstraintCollector<A,B,?,Long>` | `sumLong(ToLongBiFunction<? super A,? super B> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,Long>` | `sumLong(ToLongFunction<? super A> groupValueMapping)`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long>` | `sumLong(ToLongQuadFunction<? super A,? super B,? super C,? super D> groupValueMapping)`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,Long>` | `sumLong(ToLongTriFunction<? super A,? super B,? super C> groupValueMapping)`
    `static <A,B> BiConstraintCollector<A,B,?,Period>` | `sumPeriod(BiFunction<? super A,? super B,Period> groupValueMapping)`
    `static <A> UniConstraintCollector<A,?,Period>` | `sumPeriod(Function<? super A,Period> groupValueMapping)`
    `static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Period>` | `sumPeriod(QuadFunction<? super A,? super B,? super C,? super D,Period> groupValueMapping)`
    `static <A,B,C> TriConstraintCollector<A,B,C,?,Period>` | `sumPeriod(TriFunction<? super A,? super B,? super C,Period> groupValueMapping)`
    `static <A,B,Mapped,Result extends Collection<Mapped>> BiConstraintCollector<A,B,?,Result>` | `toCollection(BiFunction<A,B,Mapped> groupValueMapping, IntFunction<Result> collectionFunction)`
    `static <A,Mapped,Result extends Collection<Mapped>> UniConstraintCollector<A,?,Result>` | `toCollection(Function<A,Mapped> groupValueMapping, IntFunction<Result> collectionFunction)`
    `static <A,Result extends Collection<A>> UniConstraintCollector<A,?,Result>` | `toCollection(IntFunction<Result> collectionFunction)`
    `static <A,B,C,D,Mapped,Result extends Collection<Mapped>> QuadConstraintCollector<A,B,C,D,?,Result>` | `toCollection(QuadFunction<A,B,C,D,Mapped> groupValueMapping, IntFunction<Result> collectionFunction)`
    `static <A,B,C,Mapped,Result extends Collection<Mapped>> TriConstraintCollector<A,B,C,?,Result>` | `toCollection(TriFunction<A,B,C,Mapped> groupValueMapping, IntFunction<Result> collectionFunction)`
    `static <A> UniConstraintCollector<A,?,List<A>>` | `toList()` Creates constraint collector that returns `List` of the same element type as the `ConstraintStream`.
    `static <A,B,Mapped> BiConstraintCollector<A,B,?,List<Mapped>>` | `toList(BiFunction<A,B,Mapped> groupValueMapping)` Creates constraint collector that returns `List` of the given element type.
    `static <A,Mapped> UniConstraintCollector<A,?,List<Mapped>>` | `toList(Function<A,Mapped> groupValueMapping)` Creates constraint collector that returns `List` of the given element type.
    `static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,List<Mapped>>` | `toList(QuadFunction<A,B,C,D,Mapped> groupValueMapping)` Creates constraint collector that returns `List` of the given element type.
    `static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,List<Mapped>>` | `toList(TriFunction<A,B,C,Mapped> groupValueMapping)` Creates constraint collector that returns `List` of the given element type.
    `static <A,B,Key,Value> BiConstraintCollector<A,B,?,Map<Key,Set<Value>>>` | `toMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper)` As defined by `toMap(Function, Function)`.
    `static <A,B,Key,Value> BiConstraintCollector<A,B,?,Map<Key,Value>>` | `toMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` As defined by `toMap(Function, Function, BinaryOperator)`.
    `static <A,B,Key,Value,ValueSet extends Set<Value>> BiConstraintCollector<A,B,?,Map<Key,ValueSet>>` | `toMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` As defined by `toMap(Function, Function, IntFunction)`.
    `static <A,Key,Value> UniConstraintCollector<A,?,Map<Key,Set<Value>>>` | `toMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper)` Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.
    `static <A,Key,Value> UniConstraintCollector<A,?,Map<Key,Value>>` | `toMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` Creates a constraint collector that returns a `Map`.
    `static <A,Key,Value,ValueSet extends Set<Value>> UniConstraintCollector<A,?,Map<Key,ValueSet>>` | `toMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.
    `static <A,B,C,D,Key,Value> QuadConstraintCollector<A,B,C,D,?,Map<Key,Set<Value>>>` | `toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper)` As defined by `toMap(Function, Function)`.
    `static <A,B,C,D,Key,Value> QuadConstraintCollector<A,B,C,D,?,Map<Key,Value>>` | `toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` As defined by `toMap(Function, Function, BinaryOperator)`.
    `static <A,B,C,D,Key,Value,ValueSet extends Set<Value>> QuadConstraintCollector<A,B,C,D,?,Map<Key,ValueSet>>` | `toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` As defined by `toMap(Function, Function, IntFunction)`.
    `static <A,B,C,Key,Value> TriConstraintCollector<A,B,C,?,Map<Key,Set<Value>>>` | `toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper)` As defined by `toMap(Function, Function)`.
    `static <A,B,C,Key,Value> TriConstraintCollector<A,B,C,?,Map<Key,Value>>` | `toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` As defined by `toMap(Function, Function, BinaryOperator)`.
    `static <A,B,C,Key,Value,ValueSet extends Set<Value>> TriConstraintCollector<A,B,C,?,Map<Key,ValueSet>>` | `toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` As defined by `toMap(Function, Function, IntFunction)`.
    `static <A> UniConstraintCollector<A,?,Set<A>>` | `toSet()` Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`.
    `static <A,B,Mapped> BiConstraintCollector<A,B,?,Set<Mapped>>` | `toSet(BiFunction<A,B,Mapped> groupValueMapping)` As defined by `toSet(Function)`.
    `static <A,Mapped> UniConstraintCollector<A,?,Set<Mapped>>` | `toSet(Function<A,Mapped> groupValueMapping)` Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`.
    `static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Set<Mapped>>` | `toSet(QuadFunction<A,B,C,D,Mapped> groupValueMapping)` As defined by `toSet(Function)`.
    `static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Set<Mapped>>` | `toSet(TriFunction<A,B,C,Mapped> groupValueMapping)` As defined by `toSet(Function)`.
    `static <A,B,Key extends Comparable<Key>,Value> BiConstraintCollector<A,B,?,SortedMap<Key,Set<Value>>>` | `toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper)` As defined by `toSortedMap(Function, Function)`.
    `static <A,B,Key extends Comparable<Key>,Value> BiConstraintCollector<A,B,?,SortedMap<Key,Value>>` | `toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` As defined by `toSortedMap(Function, Function, BinaryOperator)`.
    `static <A,B,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> BiConstraintCollector<A,B,?,SortedMap<Key,ValueSet>>` | `toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` As defined by `toSortedMap(Function, Function, IntFunction)`.
    `static <A,Key extends Comparable<Key>,Value> UniConstraintCollector<A,?,SortedMap<Key,Set<Value>>>` | `toSortedMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper)` Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.
    `static <A,Key extends Comparable<Key>,Value> UniConstraintCollector<A,?,SortedMap<Key,Value>>` | `toSortedMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` Creates a constraint collector that returns a `SortedMap`.
    `static <A,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> UniConstraintCollector<A,?,SortedMap<Key,ValueSet>>` | `toSortedMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.
    `static <A,B,C,D,Key extends Comparable<Key>,Value> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,Set<Value>>>` | `toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper)` As defined by `toSortedMap(Function, Function)`.
    `static <A,B,C,D,Key extends Comparable<Key>,Value> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,Value>>` | `toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` As defined by `toSortedMap(Function, Function, BinaryOperator)`.
    `static <A,B,C,D,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,ValueSet>>` | `toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` As defined by `toSortedMap(Function, Function, IntFunction)`.
    `static <A,B,C,Key extends Comparable<Key>,Value> TriConstraintCollector<A,B,C,?,SortedMap<Key,Set<Value>>>` | `toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper)` As defined by `toSortedMap(Function, Function)`.
    `static <A,B,C,Key extends Comparable<Key>,Value> TriConstraintCollector<A,B,C,?,SortedMap<Key,Value>>` | `toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` As defined by `toSortedMap(Function, Function, BinaryOperator)`.
    `static <A,B,C,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> TriConstraintCollector<A,B,C,?,SortedMap<Key,ValueSet>>` | `toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` As defined by `toSortedMap(Function, Function, IntFunction)`.
    `static <A extends Comparable<A>> UniConstraintCollector<A,?,SortedSet<A>>` | `toSortedSet()` Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
    `static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,SortedSet<Mapped>>` | `toSortedSet(BiFunction<A,B,Mapped> groupValueMapping)` As defined by `toSortedSet(Function)`.
    `static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,SortedSet<Mapped>>` | `toSortedSet(Function<A,Mapped> groupValueMapping)` Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
    `static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,SortedSet<Mapped>>` | `toSortedSet(QuadFunction<A,B,C,D,Mapped> groupValueMapping)` As defined by `toSortedSet(Function)`.
    `static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,SortedSet<Mapped>>` | `toSortedSet(TriFunction<A,B,C,Mapped> groupValueMapping)` As defined by `toSortedSet(Function)`.

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

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

- - ### Method Detail

    - #### count

          public static <A> UniConstraintCollector<A,?,Integer> count()

    - #### countLong

          public static <A> UniConstraintCollector<A,?,Long> countLong()

    - #### countBi

          public static <A,B> BiConstraintCollector<A,B,?,Integer> countBi()

    - #### countLongBi

          public static <A,B> BiConstraintCollector<A,B,?,Long> countLongBi()

    - #### countTri

          public static <A,B,C> TriConstraintCollector<A,B,C,?,Integer> countTri()

    - #### countLongTri

          public static <A,B,C> TriConstraintCollector<A,B,C,?,Long> countLongTri()

    - #### countQuad

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer> countQuad()

    - #### countLongQuad

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long> countLongQuad()

    - #### countDistinct

          public static <A> UniConstraintCollector<A,?,Integer> countDistinct()

    - #### countDistinct

          public static <A> UniConstraintCollector<A,?,Integer> countDistinct(Function<A,?> groupValueMapping)

    - #### countDistinctLong

          public static <A> UniConstraintCollector<A,?,Long> countDistinctLong(Function<A,?> groupValueMapping)

    - #### countDistinct

          public static <A,B> BiConstraintCollector<A,B,?,Integer> countDistinct(BiFunction<A,B,?> groupValueMapping)

    - #### countDistinctLong

          public static <A,B> BiConstraintCollector<A,B,?,Long> countDistinctLong(BiFunction<A,B,?> groupValueMapping)

    - #### countDistinct

          public static <A,B,C> TriConstraintCollector<A,B,C,?,Integer> countDistinct(TriFunction<A,B,C,?> groupValueMapping)

    - #### countDistinctLong

          public static <A,B,C> TriConstraintCollector<A,B,C,?,Long> countDistinctLong(TriFunction<A,B,C,?> groupValueMapping)

    - #### countDistinct

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer> countDistinct(QuadFunction<A,B,C,D,?> groupValueMapping)

    - #### countDistinctLong

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long> countDistinctLong(QuadFunction<A,B,C,D,?> groupValueMapping)

    - #### sum

          public static <A> UniConstraintCollector<A,?,Integer> sum(ToIntFunction<? super A> groupValueMapping)

    - #### sumLong

          public static <A> UniConstraintCollector<A,?,Long> sumLong(ToLongFunction<? super A> groupValueMapping)

    - #### sum

          public static <A,Result> UniConstraintCollector<A,?,Result> sum(Function<? super A,Result> groupValueMapping,
                                                                          Result zero,
                                                                          BinaryOperator<Result> adder,
                                                                          BinaryOperator<Result> subtractor)

    - #### sumBigDecimal

          public static <A> UniConstraintCollector<A,?,BigDecimal> sumBigDecimal(Function<? super A,BigDecimal> groupValueMapping)

    - #### sumBigInteger

          public static <A> UniConstraintCollector<A,?,BigInteger> sumBigInteger(Function<? super A,BigInteger> groupValueMapping)

    - #### sumDuration

          public static <A> UniConstraintCollector<A,?,Duration> sumDuration(Function<? super A,Duration> groupValueMapping)

    - #### sumPeriod

          public static <A> UniConstraintCollector<A,?,Period> sumPeriod(Function<? super A,Period> groupValueMapping)

    - #### sum

          public static <A,B> BiConstraintCollector<A,B,?,Integer> sum(ToIntBiFunction<? super A,? super B> groupValueMapping)

    - #### sumLong

          public static <A,B> BiConstraintCollector<A,B,?,Long> sumLong(ToLongBiFunction<? super A,? super B> groupValueMapping)

    - #### sum

          public static <A,B,Result> BiConstraintCollector<A,B,?,Result> sum(BiFunction<? super A,? super B,Result> groupValueMapping,
                                                                             Result zero,
                                                                             BinaryOperator<Result> adder,
                                                                             BinaryOperator<Result> subtractor)

    - #### sumBigDecimal

          public static <A,B> BiConstraintCollector<A,B,?,BigDecimal> sumBigDecimal(BiFunction<? super A,? super B,BigDecimal> groupValueMapping)

    - #### sumBigInteger

          public static <A,B> BiConstraintCollector<A,B,?,BigInteger> sumBigInteger(BiFunction<? super A,? super B,BigInteger> groupValueMapping)

    - #### sumDuration

          public static <A,B> BiConstraintCollector<A,B,?,Duration> sumDuration(BiFunction<? super A,? super B,Duration> groupValueMapping)

    - #### sumPeriod

          public static <A,B> BiConstraintCollector<A,B,?,Period> sumPeriod(BiFunction<? super A,? super B,Period> groupValueMapping)

    - #### sum

          public static <A,B,C> TriConstraintCollector<A,B,C,?,Integer> sum(ToIntTriFunction<? super A,? super B,? super C> groupValueMapping)

    - #### sumLong

          public static <A,B,C> TriConstraintCollector<A,B,C,?,Long> sumLong(ToLongTriFunction<? super A,? super B,? super C> groupValueMapping)

    - #### sum

          public static <A,B,C,Result> TriConstraintCollector<A,B,C,?,Result> sum(TriFunction<? super A,? super B,? super C,Result> groupValueMapping,
                                                                                  Result zero,
                                                                                  BinaryOperator<Result> adder,
                                                                                  BinaryOperator<Result> subtractor)

    - #### sumBigDecimal

          public static <A,B,C> TriConstraintCollector<A,B,C,?,BigDecimal> sumBigDecimal(TriFunction<? super A,? super B,? super C,BigDecimal> groupValueMapping)

    - #### sumBigInteger

          public static <A,B,C> TriConstraintCollector<A,B,C,?,BigInteger> sumBigInteger(TriFunction<? super A,? super B,? super C,BigInteger> groupValueMapping)

    - #### sumDuration

          public static <A,B,C> TriConstraintCollector<A,B,C,?,Duration> sumDuration(TriFunction<? super A,? super B,? super C,Duration> groupValueMapping)

    - #### sumPeriod

          public static <A,B,C> TriConstraintCollector<A,B,C,?,Period> sumPeriod(TriFunction<? super A,? super B,? super C,Period> groupValueMapping)

    - #### sum

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer> sum(ToIntQuadFunction<? super A,? super B,? super C,? super D> groupValueMapping)

    - #### sumLong

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long> sumLong(ToLongQuadFunction<? super A,? super B,? super C,? super D> groupValueMapping)

    - #### sum

          public static <A,B,C,D,Result> QuadConstraintCollector<A,B,C,D,?,Result> sum(QuadFunction<? super A,? super B,? super C,? super D,Result> groupValueMapping,
                                                                                       Result zero,
                                                                                       BinaryOperator<Result> adder,
                                                                                       BinaryOperator<Result> subtractor)

    - #### sumBigDecimal

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,BigDecimal> sumBigDecimal(QuadFunction<? super A,? super B,? super C,? super D,BigDecimal> groupValueMapping)

    - #### sumBigInteger

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,BigInteger> sumBigInteger(QuadFunction<? super A,? super B,? super C,? super D,BigInteger> groupValueMapping)

    - #### sumDuration

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Duration> sumDuration(QuadFunction<? super A,? super B,? super C,? super D,Duration> groupValueMapping)

    - #### sumPeriod

          public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Period> sumPeriod(QuadFunction<? super A,? super B,? super C,? super D,Period> groupValueMapping)

    - #### min

          public static <A extends Comparable<A>> UniConstraintCollector<A,?,A> min()

      Returns a collector that finds a minimum value in a group of `Comparable` elements.

      Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that `e1.compareTo(e2) == 0` has the same boolean value as `e1.equals(e2)`. In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(min())` returns either `Ann` or `Eric` arbitrarily, assuming the objects are `Comparable` by the `age` field. To avoid this, always end your `Comparator` by an identity comparison, such as `Comparator.comparing(Person::getAge).comparing(Person::getId))`.

      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### min

          public static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,Mapped> min(Function<A,Mapped> groupValueMapping)

      Returns a collector that finds a minimum value in a group of `Comparable` elements.

      Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that `e1.compareTo(e2) == 0` has the same boolean value as `e1.equals(e2)`. In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(min(Person::getAge))` returns `20`.

      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of the result
      Parameters:
        `groupValueMapping` - never null, maps facts from the matched type to the result type
      Returns:
        never null

    - #### min

          public static <A> UniConstraintCollector<A,?,A> min(Comparator<A> comparator)

      As defined by `min()`, only with a custom `Comparator`.

    - #### min

          public static <A,Mapped> UniConstraintCollector<A,?,Mapped> min(Function<A,Mapped> groupValueMapping,
                                                                          Comparator<Mapped> comparator)

      As defined by `min(Function)`, only with a custom `Comparator`.

    - #### min

          public static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,Mapped> min(BiFunction<A,B,Mapped> groupValueMapping)

      As defined by `min(Function)`.

    - #### min

          public static <A,B,Mapped> BiConstraintCollector<A,B,?,Mapped> min(BiFunction<A,B,Mapped> groupValueMapping,
                                                                             Comparator<Mapped> comparator)

      As defined by `min(Function)`, only with a custom `Comparator`.

    - #### min

          public static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,Mapped> min(TriFunction<A,B,C,Mapped> groupValueMapping)

      As defined by `min(Function)`.

    - #### min

          public static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Mapped> min(TriFunction<A,B,C,Mapped> groupValueMapping,
                                                                                  Comparator<Mapped> comparator)

      As defined by `min(Function)`, only with a custom `Comparator`.

    - #### min

          public static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,Mapped> min(QuadFunction<A,B,C,D,Mapped> groupValueMapping)

      As defined by `min(Function)`.

    - #### min

          public static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Mapped> min(QuadFunction<A,B,C,D,Mapped> groupValueMapping,
                                                                                       Comparator<Mapped> comparator)

      As defined by `min(Function)`, only with a custom `Comparator`.

    - #### max

          public static <A extends Comparable<A>> UniConstraintCollector<A,?,A> max()

      Returns a collector that finds a maximum value in a group of `Comparable` elements.

      Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that `e1.compareTo(e2) == 0` has the same boolean value as `e1.equals(e2)`. In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(max())` returns either `Cathy` or `David` arbitrarily, assuming the objects are `Comparable` by the `age` field. To avoid this, always end your `Comparator` by an identity comparison, such as `Comparator.comparing(Person::getAge).comparing(Person::getId))`.

      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### max

          public static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,Mapped> max(Function<A,Mapped> groupValueMapping)

      Returns a collector that finds a maximum value in a group of `Comparable` elements.

      Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that `e1.compareTo(e2) == 0` has the same boolean value as `e1.equals(e2)`. In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(max(Person::getAge))` returns `30`.

      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of the result
      Parameters:
        `groupValueMapping` - never null, maps facts from the matched type to the result type
      Returns:
        never null

    - #### max

          public static <A> UniConstraintCollector<A,?,A> max(Comparator<A> comparator)

      As defined by `max()`, only with a custom `Comparator`.

    - #### max

          public static <A,Mapped> UniConstraintCollector<A,?,Mapped> max(Function<A,Mapped> groupValueMapping,
                                                                          Comparator<Mapped> comparator)

      As defined by `max(Function)`, only with a custom `Comparator`.

    - #### max

          public static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,Mapped> max(BiFunction<A,B,Mapped> groupValueMapping)

      As defined by `max(Function)`.

    - #### max

          public static <A,B,Mapped> BiConstraintCollector<A,B,?,Mapped> max(BiFunction<A,B,Mapped> groupValueMapping,
                                                                             Comparator<Mapped> comparator)

      As defined by `max(Function)`, only with a custom `Comparator`.

    - #### max

          public static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,Mapped> max(TriFunction<A,B,C,Mapped> groupValueMapping)

      As defined by `max(Function)`.

    - #### max

          public static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Mapped> max(TriFunction<A,B,C,Mapped> groupValueMapping,
                                                                                  Comparator<Mapped> comparator)

      As defined by `max(Function)`, only with a custom `Comparator`.

    - #### max

          public static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,Mapped> max(QuadFunction<A,B,C,D,Mapped> groupValueMapping)

      As defined by `max(Function)`.

    - #### max

          public static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Mapped> max(QuadFunction<A,B,C,D,Mapped> groupValueMapping,
                                                                                       Comparator<Mapped> comparator)

      As defined by `max(Function)`, only with a custom `Comparator`.

    - #### toCollection

          public static <A,Result extends Collection<A>> UniConstraintCollector<A,?,Result> toCollection(IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A> UniConstraintCollector<A,?,Set<A>> toSet()

      Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.
      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### toSortedSet

          public static <A extends Comparable<A>> UniConstraintCollector<A,?,SortedSet<A>> toSortedSet()

      Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### toList

          public static <A> UniConstraintCollector<A,?,List<A>> toList()

      Creates constraint collector that returns `List` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.
      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### toCollection

          public static <A,Mapped,Result extends Collection<Mapped>> UniConstraintCollector<A,?,Result> toCollection(Function<A,Mapped> groupValueMapping,
                                                                                                                     IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A,Mapped> UniConstraintCollector<A,?,Set<Mapped>> toSet(Function<A,Mapped> groupValueMapping)

      Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.
      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toSortedSet

          public static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,SortedSet<Mapped>> toSortedSet(Function<A,Mapped> groupValueMapping)

      Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toList

          public static <A,Mapped> UniConstraintCollector<A,?,List<Mapped>> toList(Function<A,Mapped> groupValueMapping)

      Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(Function)`.
      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of elements in the resulting collection
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting collection
      Returns:
        never null

    - #### toCollection

          public static <A,B,Mapped,Result extends Collection<Mapped>> BiConstraintCollector<A,B,?,Result> toCollection(BiFunction<A,B,Mapped> groupValueMapping,
                                                                                                                        IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A,B,Mapped> BiConstraintCollector<A,B,?,Set<Mapped>> toSet(BiFunction<A,B,Mapped> groupValueMapping)

      As defined by `toSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toSortedSet

          public static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,SortedSet<Mapped>> toSortedSet(BiFunction<A,B,Mapped> groupValueMapping)

      As defined by `toSortedSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toList

          public static <A,B,Mapped> BiConstraintCollector<A,B,?,List<Mapped>> toList(BiFunction<A,B,Mapped> groupValueMapping)

      Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(BiFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Mapped` - type of elements in the resulting collection
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting collection
      Returns:
        never null

    - #### toCollection

          public static <A,B,C,Mapped,Result extends Collection<Mapped>> TriConstraintCollector<A,B,C,?,Result> toCollection(TriFunction<A,B,C,Mapped> groupValueMapping,
                                                                                                                             IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Set<Mapped>> toSet(TriFunction<A,B,C,Mapped> groupValueMapping)

      As defined by `toSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toSortedSet

          public static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,SortedSet<Mapped>> toSortedSet(TriFunction<A,B,C,Mapped> groupValueMapping)

      As defined by `toSortedSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toList

          public static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,List<Mapped>> toList(TriFunction<A,B,C,Mapped> groupValueMapping)

      Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(TriFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Mapped` - type of elements in the resulting collection
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting collection
      Returns:
        never null

    - #### toCollection

          public static <A,B,C,D,Mapped,Result extends Collection<Mapped>> QuadConstraintCollector<A,B,C,D,?,Result> toCollection(QuadFunction<A,B,C,D,Mapped> groupValueMapping,
                                                                                                                                  IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Set<Mapped>> toSet(QuadFunction<A,B,C,D,Mapped> groupValueMapping)

      As defined by `toSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toSortedSet

          public static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,SortedSet<Mapped>> toSortedSet(QuadFunction<A,B,C,D,Mapped> groupValueMapping)

      As defined by `toSortedSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toList

          public static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,List<Mapped>> toList(QuadFunction<A,B,C,D,Mapped> groupValueMapping)

      Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(QuadFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Mapped` - type of elements in the resulting collection
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting collection
      Returns:
        never null

    - #### toMap

          public static <A,Key,Value> UniConstraintCollector<A,?,Map<Key,Set<Value>>> toMap(Function<? super A,? extends Key> keyMapper,
                                                                                            Function<? super A,? extends Value> valueMapper)

      Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

      Makes no guarantees on iteration order, neither for map entries, nor for the value sets. For stable iteration order, use `toSortedMap(Function, Function, IntFunction)`.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toMap

          public static <A,Key,Value,ValueSet extends Set<Value>> UniConstraintCollector<A,?,Map<Key,ValueSet>> toMap(Function<? super A,? extends Key> keyMapper,
                                                                                                                      Function<? super A,? extends Value> valueMapper,
                                                                                                                      IntFunction<ValueSet> valueSetFunction)

      Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

      Iteration order of value collections depends on the `Set` provided. Makes no guarantees on iteration order for map entries, use `toSortedMap(Function, Function, IntFunction)` for that.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toMap

          public static <A,Key,Value> UniConstraintCollector<A,?,Map<Key,Value>> toMap(Function<? super A,? extends Key> keyMapper,
                                                                                       Function<? super A,? extends Value> valueMapper,
                                                                                       BinaryOperator<Value> mergeFunction)

      Creates a constraint collector that returns a `Map`.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName, (name1, name2) -> name1 + " and " + name2)` returns `{20: "Ann and Eric", 25: "Beth", 30: "Cathy and David"}`.

      Makes no guarantees on iteration order for map entries. For stable iteration order, use `toSortedMap(Function, Function, BinaryOperator)`.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toSortedMap

          public static <A,Key extends Comparable<Key>,Value> UniConstraintCollector<A,?,SortedMap<Key,Set<Value>>> toSortedMap(Function<? super A,? extends Key> keyMapper,
                                                                                                                                Function<? super A,? extends Value> valueMapper)

      Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

      Makes no guarantees on iteration order for the value sets, use `toSortedMap(Function, Function, IntFunction)` for that.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toSortedMap

          public static <A,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> UniConstraintCollector<A,?,SortedMap<Key,ValueSet>> toSortedMap(Function<? super A,? extends Key> keyMapper,
                                                                                                                                                          Function<? super A,? extends Value> valueMapper,
                                                                                                                                                          IntFunction<ValueSet> valueSetFunction)

      Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

      Iteration order of value collections depends on the `Set` provided.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toSortedMap

          public static <A,Key extends Comparable<Key>,Value> UniConstraintCollector<A,?,SortedMap<Key,Value>> toSortedMap(Function<? super A,? extends Key> keyMapper,
                                                                                                                           Function<? super A,? extends Value> valueMapper,
                                                                                                                           BinaryOperator<Value> mergeFunction)

      Creates a constraint collector that returns a `SortedMap`.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName, (name1, name2) -> name1 + " and " + name2)` returns `{20: "Ann and Eric", 25: "Beth", 30: "Cathy and David"}`.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toMap

          public static <A,B,Key,Value> BiConstraintCollector<A,B,?,Map<Key,Set<Value>>> toMap(BiFunction<? super A,? super B,? extends Key> keyMapper,
                                                                                               BiFunction<? super A,? super B,? extends Value> valueMapper)

      As defined by `toMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toMap

          public static <A,B,Key,Value,ValueSet extends Set<Value>> BiConstraintCollector<A,B,?,Map<Key,ValueSet>> toMap(BiFunction<? super A,? super B,? extends Key> keyMapper,
                                                                                                                         BiFunction<? super A,? super B,? extends Value> valueMapper,
                                                                                                                         IntFunction<ValueSet> valueSetFunction)

      As defined by `toMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toMap

          public static <A,B,Key,Value> BiConstraintCollector<A,B,?,Map<Key,Value>> toMap(BiFunction<? super A,? super B,? extends Key> keyMapper,
                                                                                          BiFunction<? super A,? super B,? extends Value> valueMapper,
                                                                                          BinaryOperator<Value> mergeFunction)

      As defined by `toMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,Key extends Comparable<Key>,Value> BiConstraintCollector<A,B,?,SortedMap<Key,Set<Value>>> toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper,
                                                                                                                                   BiFunction<? super A,? super B,? extends Value> valueMapper)

      As defined by `toSortedMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> BiConstraintCollector<A,B,?,SortedMap<Key,ValueSet>> toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper,
                                                                                                                                                             BiFunction<? super A,? super B,? extends Value> valueMapper,
                                                                                                                                                             IntFunction<ValueSet> valueSetFunction)

      As defined by `toSortedMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,Key extends Comparable<Key>,Value> BiConstraintCollector<A,B,?,SortedMap<Key,Value>> toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper,
                                                                                                                              BiFunction<? super A,? super B,? extends Value> valueMapper,
                                                                                                                              BinaryOperator<Value> mergeFunction)

      As defined by `toSortedMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toMap

          public static <A,B,C,Key,Value> TriConstraintCollector<A,B,C,?,Map<Key,Set<Value>>> toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper,
                                                                                                    TriFunction<? super A,? super B,? super C,? extends Value> valueMapper)

      As defined by `toMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toMap

          public static <A,B,C,Key,Value,ValueSet extends Set<Value>> TriConstraintCollector<A,B,C,?,Map<Key,ValueSet>> toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper,
                                                                                                                              TriFunction<? super A,? super B,? super C,? extends Value> valueMapper,
                                                                                                                              IntFunction<ValueSet> valueSetFunction)

      As defined by `toMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toMap

          public static <A,B,C,Key,Value> TriConstraintCollector<A,B,C,?,Map<Key,Value>> toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper,
                                                                                               TriFunction<? super A,? super B,? super C,? extends Value> valueMapper,
                                                                                               BinaryOperator<Value> mergeFunction)

      As defined by `toMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,C,Key extends Comparable<Key>,Value> TriConstraintCollector<A,B,C,?,SortedMap<Key,Set<Value>>> toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper,
                                                                                                                                        TriFunction<? super A,? super B,? super C,? extends Value> valueMapper)

      As defined by `toSortedMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,C,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> TriConstraintCollector<A,B,C,?,SortedMap<Key,ValueSet>> toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper,
                                                                                                                                                                  TriFunction<? super A,? super B,? super C,? extends Value> valueMapper,
                                                                                                                                                                  IntFunction<ValueSet> valueSetFunction)

      As defined by `toSortedMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,C,Key extends Comparable<Key>,Value> TriConstraintCollector<A,B,C,?,SortedMap<Key,Value>> toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper,
                                                                                                                                   TriFunction<? super A,? super B,? super C,? extends Value> valueMapper,
                                                                                                                                   BinaryOperator<Value> mergeFunction)

      As defined by `toSortedMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toMap

          public static <A,B,C,D,Key,Value> QuadConstraintCollector<A,B,C,D,?,Map<Key,Set<Value>>> toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper,
                                                                                                         QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper)

      As defined by `toMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toMap

          public static <A,B,C,D,Key,Value,ValueSet extends Set<Value>> QuadConstraintCollector<A,B,C,D,?,Map<Key,ValueSet>> toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper,
                                                                                                                                   QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper,
                                                                                                                                   IntFunction<ValueSet> valueSetFunction)

      As defined by `toMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toMap

          public static <A,B,C,D,Key,Value> QuadConstraintCollector<A,B,C,D,?,Map<Key,Value>> toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper,
                                                                                                    QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper,
                                                                                                    BinaryOperator<Value> mergeFunction)

      As defined by `toMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,C,D,Key extends Comparable<Key>,Value> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,Set<Value>>> toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper,
                                                                                                                                             QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper)

      As defined by `toSortedMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,C,D,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,ValueSet>> toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper,
                                                                                                                                                                       QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper,
                                                                                                                                                                       IntFunction<ValueSet> valueSetFunction)

      As defined by `toSortedMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toSortedMap

          public static <A,B,C,D,Key extends Comparable<Key>,Value> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,Value>> toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper,
                                                                                                                                        QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper,
                                                                                                                                        BinaryOperator<Value> mergeFunction)

      As defined by `toSortedMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

Copyright © 2006–2020 JBoss by Red Hat. All rights reserved.