java.lang.Object
- ai.timefold.solver.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 Deprecated Methods
Modifier and Type	Method	Description
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Double>`	`average(ToIntQuadFunction<A,B,C,D> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Double>`	`average(ToIntTriFunction<A,B,C> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,Double>`	`average(ToIntBiFunction<A,B> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,Double>`	`average(ToIntFunction<A> groupValueMapping)`	Returns a collector that calculates an average of an `int` property of the elements that are being grouped.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,BigDecimal>`	`averageBigDecimal(QuadFunction<A,B,C,D,BigDecimal> groupValueMapping)`	As defined by `averageBigDecimal(Function)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,BigDecimal>`	`averageBigDecimal(TriFunction<A,B,C,BigDecimal> groupValueMapping)`	As defined by `averageBigDecimal(Function)`.
`static <A,B> BiConstraintCollector<A,B,?,BigDecimal>`	`averageBigDecimal(BiFunction<A,B,BigDecimal> groupValueMapping)`	As defined by `averageBigDecimal(Function)`.
`static <A> UniConstraintCollector<A,?,BigDecimal>`	`averageBigDecimal(Function<A,BigDecimal> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,BigDecimal>`	`averageBigInteger(QuadFunction<A,B,C,D,BigInteger> groupValueMapping)`	As defined by `averageBigInteger(Function)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,BigDecimal>`	`averageBigInteger(TriFunction<A,B,C,BigInteger> groupValueMapping)`	As defined by `averageBigInteger(Function)`.
`static <A,B> BiConstraintCollector<A,B,?,BigDecimal>`	`averageBigInteger(BiFunction<A,B,BigInteger> groupValueMapping)`	As defined by `averageBigInteger(Function)`.
`static <A> UniConstraintCollector<A,?,BigDecimal>`	`averageBigInteger(Function<A,BigInteger> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Duration>`	`averageDuration(QuadFunction<A,B,C,D,Duration> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Duration>`	`averageDuration(TriFunction<A,B,C,Duration> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,Duration>`	`averageDuration(BiFunction<A,B,Duration> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,Duration>`	`averageDuration(Function<A,Duration> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Double>`	`averageLong(ToLongQuadFunction<A,B,C,D> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Double>`	`averageLong(ToLongTriFunction<A,B,C> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,Double>`	`averageLong(ToLongBiFunction<A,B> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,Double>`	`averageLong(ToLongFunction<A> groupValueMapping)`	As defined by `average(ToIntFunction)`.
`static <A,B,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResult1_,SubResult2_,SubResult3_> BiConstraintCollector<A,B,?,Result_>`	`compose(BiConstraintCollector<A,B,SubResultContainer1_,SubResult1_> subCollector1, BiConstraintCollector<A,B,SubResultContainer2_,SubResult2_> subCollector2, BiConstraintCollector<A,B,SubResultContainer3_,SubResult3_> subCollector3, TriFunction<SubResult1_,SubResult2_,SubResult3_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, TriFunction)`.
`static <A,B,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResultContainer4_,SubResult1_,SubResult2_,SubResult3_,SubResult4_> BiConstraintCollector<A,B,?,Result_>`	`compose(BiConstraintCollector<A,B,SubResultContainer1_,SubResult1_> subCollector1, BiConstraintCollector<A,B,SubResultContainer2_,SubResult2_> subCollector2, BiConstraintCollector<A,B,SubResultContainer3_,SubResult3_> subCollector3, BiConstraintCollector<A,B,SubResultContainer4_,SubResult4_> subCollector4, QuadFunction<SubResult1_,SubResult2_,SubResult3_,SubResult4_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, QuadFunction)`.
`static <A,B,Result_,SubResultContainer1_,SubResultContainer2_,SubResult1_,SubResult2_> BiConstraintCollector<A,B,?,Result_>`	`compose(BiConstraintCollector<A,B,SubResultContainer1_,SubResult1_> subCollector1, BiConstraintCollector<A,B,SubResultContainer2_,SubResult2_> subCollector2, BiFunction<SubResult1_,SubResult2_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, BiFunction)`.
`static <A,B,C,D,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResult1_,SubResult2_,SubResult3_> QuadConstraintCollector<A,B,C,D,?,Result_>`	`compose(QuadConstraintCollector<A,B,C,D,SubResultContainer1_,SubResult1_> subCollector1, QuadConstraintCollector<A,B,C,D,SubResultContainer2_,SubResult2_> subCollector2, QuadConstraintCollector<A,B,C,D,SubResultContainer3_,SubResult3_> subCollector3, TriFunction<SubResult1_,SubResult2_,SubResult3_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, TriFunction)`.
`static <A,B,C,D,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResultContainer4_,SubResult1_,SubResult2_,SubResult3_,SubResult4_> QuadConstraintCollector<A,B,C,D,?,Result_>`	`compose(QuadConstraintCollector<A,B,C,D,SubResultContainer1_,SubResult1_> subCollector1, QuadConstraintCollector<A,B,C,D,SubResultContainer2_,SubResult2_> subCollector2, QuadConstraintCollector<A,B,C,D,SubResultContainer3_,SubResult3_> subCollector3, QuadConstraintCollector<A,B,C,D,SubResultContainer4_,SubResult4_> subCollector4, QuadFunction<SubResult1_,SubResult2_,SubResult3_,SubResult4_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, QuadFunction)`.
`static <A,B,C,D,Result_,SubResultContainer1_,SubResultContainer2_,SubResult1_,SubResult2_> QuadConstraintCollector<A,B,C,D,?,Result_>`	`compose(QuadConstraintCollector<A,B,C,D,SubResultContainer1_,SubResult1_> subCollector1, QuadConstraintCollector<A,B,C,D,SubResultContainer2_,SubResult2_> subCollector2, BiFunction<SubResult1_,SubResult2_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, BiFunction)`.
`static <A,B,C,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResult1_,SubResult2_,SubResult3_> TriConstraintCollector<A,B,C,?,Result_>`	`compose(TriConstraintCollector<A,B,C,SubResultContainer1_,SubResult1_> subCollector1, TriConstraintCollector<A,B,C,SubResultContainer2_,SubResult2_> subCollector2, TriConstraintCollector<A,B,C,SubResultContainer3_,SubResult3_> subCollector3, TriFunction<SubResult1_,SubResult2_,SubResult3_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, TriFunction)`.
`static <A,B,C,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResultContainer4_,SubResult1_,SubResult2_,SubResult3_,SubResult4_> TriConstraintCollector<A,B,C,?,Result_>`	`compose(TriConstraintCollector<A,B,C,SubResultContainer1_,SubResult1_> subCollector1, TriConstraintCollector<A,B,C,SubResultContainer2_,SubResult2_> subCollector2, TriConstraintCollector<A,B,C,SubResultContainer3_,SubResult3_> subCollector3, TriConstraintCollector<A,B,C,SubResultContainer4_,SubResult4_> subCollector4, QuadFunction<SubResult1_,SubResult2_,SubResult3_,SubResult4_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, QuadFunction)`.
`static <A,B,C,Result_,SubResultContainer1_,SubResultContainer2_,SubResult1_,SubResult2_> TriConstraintCollector<A,B,C,?,Result_>`	`compose(TriConstraintCollector<A,B,C,SubResultContainer1_,SubResult1_> subCollector1, TriConstraintCollector<A,B,C,SubResultContainer2_,SubResult2_> subCollector2, BiFunction<SubResult1_,SubResult2_,Result_> composeFunction)`	As defined by `compose(UniConstraintCollector, UniConstraintCollector, BiFunction)`.
`static <A,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResult1_,SubResult2_,SubResult3_> UniConstraintCollector<A,?,Result_>`	`compose(UniConstraintCollector<A,SubResultContainer1_,SubResult1_> subCollector1, UniConstraintCollector<A,SubResultContainer2_,SubResult2_> subCollector2, UniConstraintCollector<A,SubResultContainer3_,SubResult3_> subCollector3, TriFunction<SubResult1_,SubResult2_,SubResult3_,Result_> composeFunction)`	Returns a constraint collector the result of which is a composition of other constraint collectors.
`static <A,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResultContainer4_,SubResult1_,SubResult2_,SubResult3_,SubResult4_> UniConstraintCollector<A,?,Result_>`	`compose(UniConstraintCollector<A,SubResultContainer1_,SubResult1_> subCollector1, UniConstraintCollector<A,SubResultContainer2_,SubResult2_> subCollector2, UniConstraintCollector<A,SubResultContainer3_,SubResult3_> subCollector3, UniConstraintCollector<A,SubResultContainer4_,SubResult4_> subCollector4, QuadFunction<SubResult1_,SubResult2_,SubResult3_,SubResult4_,Result_> composeFunction)`	Returns a constraint collector the result of which is a composition of other constraint collectors.
`static <A,Result_,SubResultContainer1_,SubResultContainer2_,SubResult1_,SubResult2_> UniConstraintCollector<A,?,Result_>`	`compose(UniConstraintCollector<A,SubResultContainer1_,SubResult1_> subCollector1, UniConstraintCollector<A,SubResultContainer2_,SubResult2_> subCollector2, BiFunction<SubResult1_,SubResult2_,Result_> composeFunction)`	Returns a constraint collector the result of which is a composition of other constraint collectors.
`static <A,B,C,D,ResultContainer_,Result_> QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>`	`conditionally(QuadPredicate<A,B,C,D> condition, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> delegate)`	As defined by `conditionally(Predicate, UniConstraintCollector)`.
`static <A,B,C,ResultContainer_,Result_> TriConstraintCollector<A,B,C,ResultContainer_,Result_>`	`conditionally(TriPredicate<A,B,C> condition, TriConstraintCollector<A,B,C,ResultContainer_,Result_> delegate)`	As defined by `conditionally(Predicate, UniConstraintCollector)`.
`static <A,B,ResultContainer_,Result_> BiConstraintCollector<A,B,ResultContainer_,Result_>`	`conditionally(BiPredicate<A,B> condition, BiConstraintCollector<A,B,ResultContainer_,Result_> delegate)`	As defined by `conditionally(Predicate, UniConstraintCollector)`.
`static <A,ResultContainer_,Result_> UniConstraintCollector<A,ResultContainer_,Result_>`	`conditionally(Predicate<A> condition, UniConstraintCollector<A,ResultContainer_,Result_> delegate)`	Returns a collector that delegates to the underlying collector if and only if the input tuple meets the given condition.
`static <A> UniConstraintCollector<A,?,Integer>`	`count()`	Returns a collector that counts the number of elements that are being grouped.
`static <A,B> BiConstraintCollector<A,B,?,Integer>`	`countBi()`	As defined by `count()`.
`static <A> UniConstraintCollector<A,?,Integer>`	`countDistinct()`	As defined by `countDistinct(Function)`, with `Function.identity()` as the argument.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer>`	`countDistinct(QuadFunction<A,B,C,D,?> groupValueMapping)`	As defined by `countDistinct(Function)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Integer>`	`countDistinct(TriFunction<A,B,C,?> groupValueMapping)`	As defined by `countDistinct(Function)`.
`static <A,B> BiConstraintCollector<A,B,?,Integer>`	`countDistinct(BiFunction<A,B,?> groupValueMapping)`	As defined by `countDistinct(Function)`.
`static <A> UniConstraintCollector<A,?,Integer>`	`countDistinct(Function<A,?> groupValueMapping)`	Returns a collector that counts the number of unique elements that are being grouped.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long>`	`countDistinctLong(QuadFunction<A,B,C,D,?> groupValueMapping)`	As defined by `countDistinct(Function)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Long>`	`countDistinctLong(TriFunction<A,B,C,?> groupValueMapping)`	As defined by `countDistinct(Function)`.
`static <A,B> BiConstraintCollector<A,B,?,Long>`	`countDistinctLong(BiFunction<A,B,?> groupValueMapping)`	As defined by `countDistinct(Function)`.
`static <A> UniConstraintCollector<A,?,Long>`	`countDistinctLong(Function<A,?> groupValueMapping)`	As defined by `countDistinct(Function)`.
`static <A> UniConstraintCollector<A,?,Long>`	`countLong()`	As defined by `count()`.
`static <A,B> BiConstraintCollector<A,B,?,Long>`	`countLongBi()`	As defined by `count()`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long>`	`countLongQuad()`	As defined by `count()`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Long>`	`countLongTri()`	As defined by `count()`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer>`	`countQuad()`	As defined by `count()`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Integer>`	`countTri()`	As defined by `count()`.
`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,C,D,Mapped extends Comparable<? super 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<? super Mapped> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `max(QuadFunction, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,B,C,D,Mapped,Comparable_ extends Comparable<? super Comparable_>> QuadConstraintCollector<A,B,C,D,?,Mapped>`	`max(QuadFunction<A,B,C,D,Mapped> groupValueMapping, Function<Mapped,Comparable_> comparableFunction)`	As defined by `max(Function, Function)`, only with a custom `Comparator`.
`static <A,B,C,Mapped extends Comparable<? super 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<? super Mapped> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `max(TriFunction, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,B,C,Mapped,Comparable_ extends Comparable<? super Comparable_>> TriConstraintCollector<A,B,C,?,Mapped>`	`max(TriFunction<A,B,C,Mapped> groupValueMapping, Function<Mapped,Comparable_> comparableFunction)`	As defined by `max(Function, Function)`, only with a custom `Comparator`.
`static <A> UniConstraintCollector<A,?,A>`	`max(Comparator<? super A> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `max(Function, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,B,Mapped extends Comparable<? super 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<? super Mapped> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `max(BiFunction, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,B,Mapped,Comparable_ extends Comparable<? super Comparable_>> BiConstraintCollector<A,B,?,Mapped>`	`max(BiFunction<A,B,Mapped> groupValueMapping, Function<Mapped,Comparable_> comparableFunction)`	As defined by `max(Function, Function)`, only with a custom `Comparator`.
`static <A,Mapped extends Comparable<? super 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<? super Mapped> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `max(Function, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,Mapped,Comparable_ extends Comparable<? super Comparable_>> UniConstraintCollector<A,?,Mapped>`	`max(Function<A,Mapped> groupValueMapping, Function<Mapped,Comparable_> comparableFunction)`	Returns a collector that finds a maximum value in a group of elements.
`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,C,D,Mapped extends Comparable<? super 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<? super Mapped> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `min(QuadFunction, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,B,C,D,Mapped,Comparable_ extends Comparable<? super Comparable_>> QuadConstraintCollector<A,B,C,D,?,Mapped>`	`min(QuadFunction<A,B,C,D,Mapped> groupValueMapping, Function<Mapped,Comparable_> comparableFunction)`	As defined by `min(Function, Function)`.
`static <A,B,C,Mapped extends Comparable<? super 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<? super Mapped> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `min(TriFunction, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,B,C,Mapped,Comparable_ extends Comparable<? super Comparable_>> TriConstraintCollector<A,B,C,?,Mapped>`	`min(TriFunction<A,B,C,Mapped> groupValueMapping, Function<Mapped,Comparable_> comparableFunction)`	As defined by `min(Function, Function)`.
`static <A> UniConstraintCollector<A,?,A>`	`min(Comparator<? super A> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `min(Function, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,B,Mapped extends Comparable<? super 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<? super Mapped> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `min(BiFunction, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,B,Mapped,Comparable_ extends Comparable<? super Comparable_>> BiConstraintCollector<A,B,?,Mapped>`	`min(BiFunction<A,B,Mapped> groupValueMapping, Function<Mapped,Comparable_> comparableFunction)`	As defined by `min(Function, Function)`.
`static <A,Mapped extends Comparable<? super 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<? super Mapped> comparator)`	Deprecated, for removal: This API element is subject to removal in a future version. Deprecated in favor of `min(Function, Function)`, as this method can lead to unavoidable score corruptions.
`static <A,Mapped,Comparable_ extends Comparable<? super Comparable_>> UniConstraintCollector<A,?,Mapped>`	`min(Function<A,Mapped> groupValueMapping, Function<Mapped,Comparable_> comparableFunction)`	Returns a collector that finds a minimum value in a group of `Comparable` elements.
`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)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Integer>`	`sum(ToIntQuadFunction<? super A,? super B,? super C,? super D> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Integer>`	`sum(ToIntTriFunction<? super A,? super B,? super C> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`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)`	As defined by `sum(ToIntFunction)`.
`static <A,B,Result> BiConstraintCollector<A,B,?,Result>`	`sum(BiFunction<? super A,? super B,Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)`	As defined by `sum(ToIntFunction)`.
`static <A,Result> UniConstraintCollector<A,?,Result>`	`sum(Function<? super A,Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)`	As defined by `sum(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,Integer>`	`sum(ToIntBiFunction<? super A,? super B> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,Integer>`	`sum(ToIntFunction<? super A> groupValueMapping)`	Returns a collector that sums an `int` property of the elements that are being grouped.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,BigDecimal>`	`sumBigDecimal(QuadFunction<? super A,? super B,? super C,? super D,BigDecimal> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,BigDecimal>`	`sumBigDecimal(TriFunction<? super A,? super B,? super C,BigDecimal> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,BigDecimal>`	`sumBigDecimal(BiFunction<? super A,? super B,BigDecimal> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,BigDecimal>`	`sumBigDecimal(Function<? super A,BigDecimal> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,BigInteger>`	`sumBigInteger(QuadFunction<? super A,? super B,? super C,? super D,BigInteger> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,BigInteger>`	`sumBigInteger(TriFunction<? super A,? super B,? super C,BigInteger> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,BigInteger>`	`sumBigInteger(BiFunction<? super A,? super B,BigInteger> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,BigInteger>`	`sumBigInteger(Function<? super A,BigInteger> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Duration>`	`sumDuration(QuadFunction<? super A,? super B,? super C,? super D,Duration> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Duration>`	`sumDuration(TriFunction<? super A,? super B,? super C,Duration> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,Duration>`	`sumDuration(BiFunction<? super A,? super B,Duration> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,Duration>`	`sumDuration(Function<? super A,Duration> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Long>`	`sumLong(ToLongQuadFunction<? super A,? super B,? super C,? super D> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Long>`	`sumLong(ToLongTriFunction<? super A,? super B,? super C> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,Long>`	`sumLong(ToLongBiFunction<? super A,? super B> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,Long>`	`sumLong(ToLongFunction<? super A> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Period>`	`sumPeriod(QuadFunction<? super A,? super B,? super C,? super D,Period> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B,C> TriConstraintCollector<A,B,C,?,Period>`	`sumPeriod(TriFunction<? super A,? super B,? super C,Period> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A,B> BiConstraintCollector<A,B,?,Period>`	`sumPeriod(BiFunction<? super A,? super B,Period> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`static <A> UniConstraintCollector<A,?,Period>`	`sumPeriod(Function<? super A,Period> groupValueMapping)`	As defined by `sum(ToIntFunction)`.
`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)`	Deprecated. Prefer `toList(QuadFunction)`, `toSet(QuadFunction)` or `toSortedSet(QuadFunction)`
`static <A,B,C,Mapped,Result extends Collection<Mapped>> TriConstraintCollector<A,B,C,?,Result>`	`toCollection(TriFunction<A,B,C,Mapped> groupValueMapping, IntFunction<Result> collectionFunction)`	Deprecated. Prefer `toList(TriFunction)`, `toSet(TriFunction)` or `toSortedSet(TriFunction)`
`static <A,B,Mapped,Result extends Collection<Mapped>> BiConstraintCollector<A,B,?,Result>`	`toCollection(BiFunction<A,B,Mapped> groupValueMapping, IntFunction<Result> collectionFunction)`	Deprecated. Prefer `toList(BiFunction)`, `toSet(BiFunction)` or `toSortedSet(BiFunction)`
`static <A,Mapped,Result extends Collection<Mapped>> UniConstraintCollector<A,?,Result>`	`toCollection(Function<A,Mapped> groupValueMapping, IntFunction<Result> collectionFunction)`	Deprecated. Prefer `toList(Function)`, `toSet(Function)` or `toSortedSet(Function)`
`static <A,Result extends Collection<A>> UniConstraintCollector<A,?,Result>`	`toCollection(IntFunction<Result> collectionFunction)`	Deprecated. Prefer `toList()`, `toSet()` or `toSortedSet()`
`static <A> UniConstraintCollector<A,?,List<A>>`	`toList()`	Creates constraint collector that returns `List` of the same element type as the `ConstraintStream`.
`static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,List<Mapped>>`	`toList(QuadFunction<A,B,C,D,Mapped> groupValueMapping)`	As defined by `toList(Function)`.
`static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,List<Mapped>>`	`toList(TriFunction<A,B,C,Mapped> groupValueMapping)`	As defined by `toList(Function)`.
`static <A,B,Mapped> BiConstraintCollector<A,B,?,List<Mapped>>`	`toList(BiFunction<A,B,Mapped> groupValueMapping)`	As defined by `toList(Function)`.
`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,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,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> UniConstraintCollector<A,?,Set<A>>`	`toSet()`	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,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,Key extends Comparable<? super 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<? super 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<? super 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<? super 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<? super 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<? super 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,B,Key extends Comparable<? super 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<? super 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<? super 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<? super 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<? super 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<? super 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 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,C,D,Mapped extends Comparable<? super 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,D,Mapped> QuadConstraintCollector<A,B,C,D,?,SortedSet<Mapped>>`	`toSortedSet(QuadFunction<A,B,C,D,Mapped> groupValueMapping, Comparator<? super Mapped> comparator)`	As defined by `toSortedSet(Function, Comparator)`.
`static <A,B,C,Mapped extends Comparable<? super Mapped>> TriConstraintCollector<A,B,C,?,SortedSet<Mapped>>`	`toSortedSet(TriFunction<A,B,C,Mapped> groupValueMapping)`	As defined by `toSortedSet(Function)`.
`static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,SortedSet<Mapped>>`	`toSortedSet(TriFunction<A,B,C,Mapped> groupValueMapping, Comparator<? super Mapped> comparator)`	As defined by `toSortedSet(Function, Comparator)`.
`static <A> UniConstraintCollector<A,?,SortedSet<A>>`	`toSortedSet(Comparator<? super A> comparator)`	As defined by `toSortedSet()`, only with a custom `Comparator`.
`static <A,B,Mapped extends Comparable<? super Mapped>> BiConstraintCollector<A,B,?,SortedSet<Mapped>>`	`toSortedSet(BiFunction<A,B,Mapped> groupValueMapping)`	As defined by `toSortedSet(Function)`.
`static <A,B,Mapped> BiConstraintCollector<A,B,?,SortedSet<Mapped>>`	`toSortedSet(BiFunction<A,B,Mapped> groupValueMapping, Comparator<? super Mapped> comparator)`	As defined by `toSortedSet(Function, Comparator)`.
`static <A,Mapped extends Comparable<? super 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,Mapped> UniConstraintCollector<A,?,SortedSet<Mapped>>`	`toSortedSet(Function<A,Mapped> groupValueMapping, Comparator<? super Mapped> comparator)`	As defined by `toSortedSet(Function)`, only with a custom `Comparator`.

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()
```
Returns a collector that counts the number of elements that are being grouped.
For example, [Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)] with .groupBy(count()) returns 5.
The default result of the collector (e.g. when never called) is 0.

Type Parameters:

A - type of the matched fact

Returns:

never null

countLong

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

As defined by count().

countBi

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

As defined by count().

countLongBi

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

As defined by count().

countTri

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

As defined by count().

countLongTri

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

As defined by count().

countQuad

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

As defined by count().

countLongQuad

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

As defined by count().

countDistinct
```
public static <A> UniConstraintCollector<A,?,Integer> countDistinct()
```
As defined by countDistinct(Function), with Function.identity() as the argument.

countDistinct
```
public static <A> UniConstraintCollector<A,?,Integer> countDistinct(Function<A,?> groupValueMapping)
```
Returns a collector that counts the number of unique elements that are being grouped. Uniqueness is determined by equality.
For example, [Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)] with .groupBy(countDistinct(Person::getAge)) returns 3, one for age 20, 25 and 30 each.
The default result of the collector (e.g. when never called) is 0.

Type Parameters:

A - type of the matched fact

Returns:

never null

countDistinctLong

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

As defined by countDistinct(Function).

countDistinct

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

As defined by countDistinct(Function).

countDistinctLong

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

As defined by countDistinct(Function).

countDistinct

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

As defined by countDistinct(Function).

countDistinctLong

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

As defined by countDistinct(Function).

countDistinct

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

As defined by countDistinct(Function).

countDistinctLong

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

As defined by countDistinct(Function).

sum
```
public static <A> UniConstraintCollector<A,?,Integer> sum(ToIntFunction<? super A> groupValueMapping)
```
Returns a collector that sums an int property of the elements that are being grouped.
For example, [Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)] with .groupBy(sum(Person::getAge)) returns 125.
The default result of the collector (e.g. when never called) is 0.

Type Parameters:

A - type of the matched fact

Returns:

never null

sumLong

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

As defined by sum(ToIntFunction).

sum

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

As defined by sum(ToIntFunction).

sumBigDecimal

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

As defined by sum(ToIntFunction).

sumBigInteger

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

As defined by sum(ToIntFunction).

sumDuration

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

As defined by sum(ToIntFunction).

sumPeriod

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

As defined by sum(ToIntFunction).

sum

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

As defined by sum(ToIntFunction).

sumLong

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

As defined by sum(ToIntFunction).

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)

As defined by sum(ToIntFunction).

sumBigDecimal

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

As defined by sum(ToIntFunction).

sumBigInteger

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

As defined by sum(ToIntFunction).

sumDuration

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

As defined by sum(ToIntFunction).

sumPeriod

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

As defined by sum(ToIntFunction).

sum

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

As defined by sum(ToIntFunction).

sumLong

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

As defined by sum(ToIntFunction).

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)

As defined by sum(ToIntFunction).

sumBigDecimal

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

As defined by sum(ToIntFunction).

sumBigInteger

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

As defined by sum(ToIntFunction).

sumDuration

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

As defined by sum(ToIntFunction).

sumPeriod

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

As defined by sum(ToIntFunction).

sum

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

As defined by sum(ToIntFunction).

sumLong

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

As defined by sum(ToIntFunction).

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)

As defined by sum(ToIntFunction).

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)

As defined by sum(ToIntFunction).

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)

As defined by sum(ToIntFunction).

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)

As defined by sum(ToIntFunction).

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)

As defined by sum(ToIntFunction).

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)).
The default result of the collector (e.g. when never called) is null.

Type Parameters:

A - type of the matched fact

Returns:

never null

min
```
public static <A,Mapped extends Comparable<? super 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.
The default result of the collector (e.g. when never called) is null.

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,Mapped,Comparable_ extends Comparable<? super Comparable_>> UniConstraintCollector<A,?,Mapped> min(Function<A,Mapped> groupValueMapping,
                                                                                                                                            Function<Mapped,Comparable_> comparableFunction)
```
Returns a collector that finds a minimum value in a group of Comparable elements. The elements will be compared according to the value returned by the comparable function.
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::name, Person::age)) returns Ann or Eric, as both have the same age.
The default result of the collector (e.g. when never called) is null.

Type Parameters:

A - type of the matched fact

Mapped - type of the result

Comparable_ - type of the comparable property

Parameters:

groupValueMapping - never null, maps facts from the matched type to the result type

comparableFunction - never null, maps facts from the matched type to the comparable property

Returns:

never null

min
```
@Deprecated(forRemoval=true)
public static <A> UniConstraintCollector<A,?,A> min(Comparator<? super A> comparator)
```
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated in favor of min(Function, Function), as this method can lead to unavoidable score corruptions.

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

min

@Deprecated(forRemoval=true)
public static <A,Mapped> UniConstraintCollector<A,?,Mapped> min(Function<A,Mapped> groupValueMapping,
                                                                                  Comparator<? super Mapped> comparator)

Deprecated, for removal: This API element is subject to removal in a future version.

Deprecated in favor of min(Function, Function), as this method can lead to unavoidable score corruptions.

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

min

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

As defined by min(Function).

min

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

As defined by min(Function, Function).

min

@Deprecated(forRemoval=true)
public static <A,B,Mapped> BiConstraintCollector<A,B,?,Mapped> min(BiFunction<A,B,Mapped> groupValueMapping,
                                                                                                 Comparator<? super Mapped> comparator)

Deprecated, for removal: This API element is subject to removal in a future version.

Deprecated in favor of min(BiFunction, Function), as this method can lead to unavoidable score corruptions.

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

min

public static <A,B,C,Mapped extends Comparable<? super 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,Comparable_ extends Comparable<? super Comparable_>> TriConstraintCollector<A,B,C,?,Mapped> min(TriFunction<A,B,C,Mapped> groupValueMapping,
                                                                                                                                                                            Function<Mapped,Comparable_> comparableFunction)

As defined by min(Function, Function).

min

@Deprecated(forRemoval=true)
public static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Mapped> min(TriFunction<A,B,C,Mapped> groupValueMapping,
                                                                                                                  Comparator<? super Mapped> comparator)

Deprecated, for removal: This API element is subject to removal in a future version.

Deprecated in favor of min(TriFunction, Function), as this method can lead to unavoidable score corruptions.

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

min

public static <A,B,C,D,Mapped extends Comparable<? super 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,Comparable_ extends Comparable<? super Comparable_>> QuadConstraintCollector<A,B,C,D,?,Mapped> min(QuadFunction<A,B,C,D,Mapped> groupValueMapping,
                                                                                                                                                                                             Function<Mapped,Comparable_> comparableFunction)

As defined by min(Function, Function).

min

@Deprecated(forRemoval=true)
public static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Mapped> min(QuadFunction<A,B,C,D,Mapped> groupValueMapping,
                                                                                                                                   Comparator<? super Mapped> comparator)

Deprecated, for removal: This API element is subject to removal in a future version.

Deprecated in favor of min(QuadFunction, Function), as this method can lead to unavoidable score corruptions.

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)).
The default result of the collector (e.g. when never called) is null.

Type Parameters:

A - type of the matched fact

Returns:

never null

max
```
public static <A,Mapped extends Comparable<? super 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.
The default result of the collector (e.g. when never called) is null.

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
```
@Deprecated(forRemoval=true)
public static <A> UniConstraintCollector<A,?,A> max(Comparator<? super A> comparator)
```
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated in favor of max(Function, Function), as this method can lead to unavoidable score corruptions.

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

max
```
public static <A,Mapped,Comparable_ extends Comparable<? super Comparable_>> UniConstraintCollector<A,?,Mapped> max(Function<A,Mapped> groupValueMapping,
                                                                                                                                            Function<Mapped,Comparable_> comparableFunction)
```
Returns a collector that finds a maximum value in a group of elements. The elements will be compared according to the value returned by the comparable function.
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::name, Person::age)) returns Cathy or David, as both have the same age.
The default result of the collector (e.g. when never called) is null.

Type Parameters:

A - type of the matched fact

Mapped - type of the result

Comparable_ - type of the comparable property

Parameters:

groupValueMapping - never null, maps facts from the matched type to the result type

comparableFunction - never null, maps facts from the matched type to the comparable property

Returns:

never null

max

@Deprecated(forRemoval=true)
public static <A,Mapped> UniConstraintCollector<A,?,Mapped> max(Function<A,Mapped> groupValueMapping,
                                                                                  Comparator<? super Mapped> comparator)

Deprecated, for removal: This API element is subject to removal in a future version.

Deprecated in favor of max(Function, Function), as this method can lead to unavoidable score corruptions.

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

max

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

As defined by max(Function).

max

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

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

max

@Deprecated(forRemoval=true)
public static <A,B,Mapped> BiConstraintCollector<A,B,?,Mapped> max(BiFunction<A,B,Mapped> groupValueMapping,
                                                                                                 Comparator<? super Mapped> comparator)

Deprecated, for removal: This API element is subject to removal in a future version.

Deprecated in favor of max(BiFunction, Function), as this method can lead to unavoidable score corruptions.

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

max

public static <A,B,C,Mapped extends Comparable<? super 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,Comparable_ extends Comparable<? super Comparable_>> TriConstraintCollector<A,B,C,?,Mapped> max(TriFunction<A,B,C,Mapped> groupValueMapping,
                                                                                                                                                                            Function<Mapped,Comparable_> comparableFunction)

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

max

@Deprecated(forRemoval=true)
public static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Mapped> max(TriFunction<A,B,C,Mapped> groupValueMapping,
                                                                                                                  Comparator<? super Mapped> comparator)

Deprecated, for removal: This API element is subject to removal in a future version.

Deprecated in favor of max(TriFunction, Function), as this method can lead to unavoidable score corruptions.

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

max

public static <A,B,C,D,Mapped extends Comparable<? super 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,Comparable_ extends Comparable<? super Comparable_>> QuadConstraintCollector<A,B,C,D,?,Mapped> max(QuadFunction<A,B,C,D,Mapped> groupValueMapping,
                                                                                                                                                                                             Function<Mapped,Comparable_> comparableFunction)

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

max

@Deprecated(forRemoval=true)
public static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Mapped> max(QuadFunction<A,B,C,D,Mapped> groupValueMapping,
                                                                                                                                   Comparator<? super Mapped> comparator)

Deprecated, for removal: This API element is subject to removal in a future version.

Deprecated in favor of max(QuadFunction, Function), as this method can lead to unavoidable score corruptions.

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

toCollection

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

Deprecated.

Prefer toList(), toSet() or toSortedSet()

average
```
public static <A> UniConstraintCollector<A,?,Double> average(ToIntFunction<A> groupValueMapping)
```
Returns a collector that calculates an average of an int property of the elements that are being grouped.
For example, [Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)] with .groupBy(average(Person::getAge)) returns 25.
The default result of the collector (e.g. when never called) is null.

Type Parameters:

A - type of the matched fact

Returns:

never null

averageLong

public static <A> UniConstraintCollector<A,?,Double> averageLong(ToLongFunction<A> groupValueMapping)

As defined by average(ToIntFunction).

averageBigDecimal
```
public static <A> UniConstraintCollector<A,?,BigDecimal> averageBigDecimal(Function<A,BigDecimal> groupValueMapping)
```
As defined by average(ToIntFunction). The scale of the resulting BigDecimal will be equal to the scale of the sum of all the input tuples, with rounding mode RoundingMode.HALF_EVEN.

averageBigInteger
```
public static <A> UniConstraintCollector<A,?,BigDecimal> averageBigInteger(Function<A,BigInteger> groupValueMapping)
```
As defined by average(ToIntFunction). The scale of the resulting BigDecimal will be equal to the scale of the sum of all the input tuples, with rounding mode RoundingMode.HALF_EVEN.

averageDuration

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

As defined by average(ToIntFunction).

average

public static <A,B> BiConstraintCollector<A,B,?,Double> average(ToIntBiFunction<A,B> groupValueMapping)

As defined by average(ToIntFunction).

averageLong

public static <A,B> BiConstraintCollector<A,B,?,Double> averageLong(ToLongBiFunction<A,B> groupValueMapping)

As defined by average(ToIntFunction).

averageBigDecimal

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

As defined by averageBigDecimal(Function).

averageBigInteger

public static <A,B> BiConstraintCollector<A,B,?,BigDecimal> averageBigInteger(BiFunction<A,B,BigInteger> groupValueMapping)

As defined by averageBigInteger(Function).

averageDuration

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

As defined by average(ToIntFunction).

average

public static <A,B,C> TriConstraintCollector<A,B,C,?,Double> average(ToIntTriFunction<A,B,C> groupValueMapping)

As defined by average(ToIntFunction).

averageLong

public static <A,B,C> TriConstraintCollector<A,B,C,?,Double> averageLong(ToLongTriFunction<A,B,C> groupValueMapping)

As defined by average(ToIntFunction).

averageBigDecimal

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

As defined by averageBigDecimal(Function).

averageBigInteger

public static <A,B,C> TriConstraintCollector<A,B,C,?,BigDecimal> averageBigInteger(TriFunction<A,B,C,BigInteger> groupValueMapping)

As defined by averageBigInteger(Function).

averageDuration

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

As defined by average(ToIntFunction).

average

public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Double> average(ToIntQuadFunction<A,B,C,D> groupValueMapping)

As defined by average(ToIntFunction).

averageLong

public static <A,B,C,D> QuadConstraintCollector<A,B,C,D,?,Double> averageLong(ToLongQuadFunction<A,B,C,D> groupValueMapping)

As defined by average(ToIntFunction).

averageBigDecimal

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

As defined by averageBigDecimal(Function).

averageBigInteger

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

As defined by averageBigInteger(Function).

averageDuration

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

As defined by average(ToIntFunction).

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().
The default result of the collector (e.g. when never called) is an empty Set.

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.
The default result of the collector (e.g. when never called) is an empty SortedSet.

Type Parameters:

A - type of the matched fact

Returns:

never null

toSortedSet

public static <A> UniConstraintCollector<A,?,SortedSet<A>> toSortedSet(Comparator<? super A> comparator)

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

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().
The default result of the collector (e.g. when never called) is an empty List.

Type Parameters:

A - type of the matched fact

Returns:

never null

toCollection

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

Deprecated.

Prefer toList(Function), toSet(Function) or toSortedSet(Function)

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().
The default result of the collector (e.g. when never called) is an empty Set.

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<? super Mapped>> UniConstraintCollector<A,?,SortedSet<Mapped>> toSortedSet(Function<A,Mapped> groupValueMapping)
```
Creates constraint collector that returns SortedSet of the same element type as the ConstraintStream.
The default result of the collector (e.g. when never called) is an empty SortedSet.

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> UniConstraintCollector<A,?,SortedSet<Mapped>> toSortedSet(Function<A,Mapped> groupValueMapping,
                                                                                                     Comparator<? super Mapped> comparator)

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

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).
The default result of the collector (e.g. when never called) is an empty List.

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

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

Deprecated.

Prefer toList(BiFunction), toSet(BiFunction) or toSortedSet(BiFunction)

toSet

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

As defined by toSet(Function).

toSortedSet

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

As defined by toSortedSet(Function).

toSortedSet

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

As defined by toSortedSet(Function, Comparator).

toList

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

As defined by toList(Function).

toCollection

@Deprecated
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)

Deprecated.

Prefer toList(TriFunction), toSet(TriFunction) or toSortedSet(TriFunction)

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

toSortedSet

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

As defined by toSortedSet(Function).

toSortedSet

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

As defined by toSortedSet(Function, Comparator).

toList

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

As defined by toList(Function).

toCollection

@Deprecated
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)

Deprecated.

Prefer toList(QuadFunction), toSet(QuadFunction) or toSortedSet(QuadFunction)

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

toSortedSet

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

As defined by toSortedSet(Function).

toSortedSet

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

As defined by toSortedSet(Function, Comparator).

toList

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

As defined by toList(Function).

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).
The default result of the collector (e.g. when never called) is an empty Map.

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.
The default result of the collector (e.g. when never called) is an empty Map.

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).
The default result of the collector (e.g. when never called) is an empty Map.

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<? super 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.
The default result of the collector (e.g. when never called) is an empty SortedMap.

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<? super 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.

The default result of the collector (e.g. when never called) is an empty SortedMap.

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<? super 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"}.

The default result of the collector (e.g. when never called) is an empty SortedMap.

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

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

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

toSortedMap

public static <A,B,Key extends Comparable<? super 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).

toSortedMap

public static <A,B,Key extends Comparable<? super 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).

toSortedMap

public static <A,B,Key extends Comparable<? super 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).

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

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

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

toSortedMap

public static <A,B,C,Key extends Comparable<? super 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).

toSortedMap

public static <A,B,C,Key extends Comparable<? super 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).

toSortedMap

public static <A,B,C,Key extends Comparable<? super 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).

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

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

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

toSortedMap

public static <A,B,C,D,Key extends Comparable<? super 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).

toSortedMap

public static <A,B,C,D,Key extends Comparable<? super 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).

toSortedMap

public static <A,B,C,D,Key extends Comparable<? super 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).

conditionally
```
public static <A,ResultContainer_,Result_> UniConstraintCollector<A,ResultContainer_,Result_> conditionally(Predicate<A> condition,
                                                                                                                                    UniConstraintCollector<A,ResultContainer_,Result_> delegate)
```
Returns a collector that delegates to the underlying collector if and only if the input tuple meets the given condition.
The result of the collector is always the underlying collector's result. Therefore the default result of the collector (e.g. when never called) is the default result of the underlying collector.

Type Parameters:

A - generic type of the tuple variable

ResultContainer_ - generic type of the result container

Result_ - generic type of the collector's return value

Parameters:

condition - never null, condition to meet in order to delegate to the underlying collector

delegate - never null, the underlying collector to delegate to

Returns:

never null

conditionally

public static <A,B,ResultContainer_,Result_> BiConstraintCollector<A,B,ResultContainer_,Result_> conditionally(BiPredicate<A,B> condition,
                                                                                                                                                   BiConstraintCollector<A,B,ResultContainer_,Result_> delegate)

As defined by conditionally(Predicate, UniConstraintCollector).

conditionally

public static <A,B,C,ResultContainer_,Result_> TriConstraintCollector<A,B,C,ResultContainer_,Result_> conditionally(TriPredicate<A,B,C> condition,
                                                                                                                                                                    TriConstraintCollector<A,B,C,ResultContainer_,Result_> delegate)

As defined by conditionally(Predicate, UniConstraintCollector).

conditionally

public static <A,B,C,D,ResultContainer_,Result_> QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> conditionally(QuadPredicate<A,B,C,D> condition,
                                                                                                                                                                                     QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> delegate)

As defined by conditionally(Predicate, UniConstraintCollector).

compose

public static <A,Result_,SubResultContainer1_,SubResultContainer2_,SubResult1_,SubResult2_> UniConstraintCollector<A,?,Result_> compose(UniConstraintCollector<A,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                  UniConstraintCollector<A,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                  BiFunction<SubResult1_,SubResult2_,Result_> composeFunction)

Returns a constraint collector the result of which is a composition of other constraint collectors. The return value of this collector, incl. the default return value, depends solely on the compose function.

Type Parameters:: A - generic type of the tuple variable; Result_ - generic type of the parent collector's return value; SubResultContainer1_ - generic type of the first sub collector's result container; SubResultContainer2_ - generic type of the second sub collector's result container; SubResult1_ - generic type of the first sub collector's return value; SubResult2_ - generic type of the second sub collector's return value
Parameters:: subCollector1 - never null, first collector to compose; subCollector2 - never null, second collector to compose; composeFunction - never null, turns results of the sub collectors to a result of the parent collector
Returns:: never null

compose

public static <A,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResult1_,SubResult2_,SubResult3_> UniConstraintCollector<A,?,Result_> compose(UniConstraintCollector<A,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                               UniConstraintCollector<A,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                               UniConstraintCollector<A,SubResultContainer3_,SubResult3_> subCollector3,
                                                                                                                                                                                                                               TriFunction<SubResult1_,SubResult2_,SubResult3_,Result_> composeFunction)

Returns a constraint collector the result of which is a composition of other constraint collectors. The return value of this collector, incl. the default return value, depends solely on the compose function.

Type Parameters:: A - generic type of the tuple variable; Result_ - generic type of the parent collector's return value; SubResultContainer1_ - generic type of the first sub collector's result container; SubResultContainer2_ - generic type of the second sub collector's result container; SubResultContainer3_ - generic type of the third sub collector's result container; SubResult1_ - generic type of the first sub collector's return value; SubResult2_ - generic type of the second sub collector's return value; SubResult3_ - generic type of the third sub collector's return value
Parameters:: subCollector1 - never null, first collector to compose; subCollector2 - never null, second collector to compose; subCollector3 - never null, third collector to compose; composeFunction - never null, turns results of the sub collectors to a result of the parent collector
Returns:: never null

compose

public static <A,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResultContainer4_,SubResult1_,SubResult2_,SubResult3_,SubResult4_> UniConstraintCollector<A,?,Result_> compose(UniConstraintCollector<A,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                                                                            UniConstraintCollector<A,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                                                                            UniConstraintCollector<A,SubResultContainer3_,SubResult3_> subCollector3,
                                                                                                                                                                                                                                                                            UniConstraintCollector<A,SubResultContainer4_,SubResult4_> subCollector4,
                                                                                                                                                                                                                                                                            QuadFunction<SubResult1_,SubResult2_,SubResult3_,SubResult4_,Result_> composeFunction)

Returns a constraint collector the result of which is a composition of other constraint collectors. The return value of this collector, incl. the default return value, depends solely on the compose function.

Type Parameters:: A - generic type of the tuple variable; Result_ - generic type of the parent collector's return value; SubResultContainer1_ - generic type of the first sub collector's result container; SubResultContainer2_ - generic type of the second sub collector's result container; SubResultContainer3_ - generic type of the third sub collector's result container; SubResultContainer4_ - generic type of the fourth sub collector's result container; SubResult1_ - generic type of the first sub collector's return value; SubResult2_ - generic type of the second sub collector's return value; SubResult3_ - generic type of the third sub collector's return value; SubResult4_ - generic type of the fourth sub collector's return value
Parameters:: subCollector1 - never null, first collector to compose; subCollector2 - never null, second collector to compose; subCollector3 - never null, third collector to compose; subCollector4 - never null, fourth collector to compose; composeFunction - never null, turns results of the sub collectors to a result of the parent collector
Returns:: never null

compose

public static <A,B,Result_,SubResultContainer1_,SubResultContainer2_,SubResult1_,SubResult2_> BiConstraintCollector<A,B,?,Result_> compose(BiConstraintCollector<A,B,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                 BiConstraintCollector<A,B,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                 BiFunction<SubResult1_,SubResult2_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, BiFunction).

compose

public static <A,B,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResult1_,SubResult2_,SubResult3_> BiConstraintCollector<A,B,?,Result_> compose(BiConstraintCollector<A,B,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                                              BiConstraintCollector<A,B,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                                              BiConstraintCollector<A,B,SubResultContainer3_,SubResult3_> subCollector3,
                                                                                                                                                                                                                                              TriFunction<SubResult1_,SubResult2_,SubResult3_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, TriFunction).

compose

public static <A,B,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResultContainer4_,SubResult1_,SubResult2_,SubResult3_,SubResult4_> BiConstraintCollector<A,B,?,Result_> compose(BiConstraintCollector<A,B,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                                                                                           BiConstraintCollector<A,B,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                                                                                           BiConstraintCollector<A,B,SubResultContainer3_,SubResult3_> subCollector3,
                                                                                                                                                                                                                                                                                           BiConstraintCollector<A,B,SubResultContainer4_,SubResult4_> subCollector4,
                                                                                                                                                                                                                                                                                           QuadFunction<SubResult1_,SubResult2_,SubResult3_,SubResult4_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, QuadFunction).

compose

public static <A,B,C,Result_,SubResultContainer1_,SubResultContainer2_,SubResult1_,SubResult2_> TriConstraintCollector<A,B,C,?,Result_> compose(TriConstraintCollector<A,B,C,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                  TriConstraintCollector<A,B,C,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                  BiFunction<SubResult1_,SubResult2_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, BiFunction).

compose

public static <A,B,C,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResult1_,SubResult2_,SubResult3_> TriConstraintCollector<A,B,C,?,Result_> compose(TriConstraintCollector<A,B,C,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                                                               TriConstraintCollector<A,B,C,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                                                               TriConstraintCollector<A,B,C,SubResultContainer3_,SubResult3_> subCollector3,
                                                                                                                                                                                                                                                               TriFunction<SubResult1_,SubResult2_,SubResult3_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, TriFunction).

compose

public static <A,B,C,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResultContainer4_,SubResult1_,SubResult2_,SubResult3_,SubResult4_> TriConstraintCollector<A,B,C,?,Result_> compose(TriConstraintCollector<A,B,C,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                                                                                                            TriConstraintCollector<A,B,C,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                                                                                                            TriConstraintCollector<A,B,C,SubResultContainer3_,SubResult3_> subCollector3,
                                                                                                                                                                                                                                                                                                            TriConstraintCollector<A,B,C,SubResultContainer4_,SubResult4_> subCollector4,
                                                                                                                                                                                                                                                                                                            QuadFunction<SubResult1_,SubResult2_,SubResult3_,SubResult4_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, QuadFunction).

compose

public static <A,B,C,D,Result_,SubResultContainer1_,SubResultContainer2_,SubResult1_,SubResult2_> QuadConstraintCollector<A,B,C,D,?,Result_> compose(QuadConstraintCollector<A,B,C,D,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                                   QuadConstraintCollector<A,B,C,D,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                                   BiFunction<SubResult1_,SubResult2_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, BiFunction).

compose

public static <A,B,C,D,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResult1_,SubResult2_,SubResult3_> QuadConstraintCollector<A,B,C,D,?,Result_> compose(QuadConstraintCollector<A,B,C,D,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                                                                                QuadConstraintCollector<A,B,C,D,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                                                                                QuadConstraintCollector<A,B,C,D,SubResultContainer3_,SubResult3_> subCollector3,
                                                                                                                                                                                                                                                                                TriFunction<SubResult1_,SubResult2_,SubResult3_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, TriFunction).

compose

public static <A,B,C,D,Result_,SubResultContainer1_,SubResultContainer2_,SubResultContainer3_,SubResultContainer4_,SubResult1_,SubResult2_,SubResult3_,SubResult4_> QuadConstraintCollector<A,B,C,D,?,Result_> compose(QuadConstraintCollector<A,B,C,D,SubResultContainer1_,SubResult1_> subCollector1,
                                                                                                                                                                                                                                                                                                                             QuadConstraintCollector<A,B,C,D,SubResultContainer2_,SubResult2_> subCollector2,
                                                                                                                                                                                                                                                                                                                             QuadConstraintCollector<A,B,C,D,SubResultContainer3_,SubResult3_> subCollector3,
                                                                                                                                                                                                                                                                                                                             QuadConstraintCollector<A,B,C,D,SubResultContainer4_,SubResult4_> subCollector4,
                                                                                                                                                                                                                                                                                                                             QuadFunction<SubResult1_,SubResult2_,SubResult3_,SubResult4_,Result_> composeFunction)

As defined by compose(UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, UniConstraintCollector, QuadFunction).

Class ConstraintCollectors

Method Summary

Methods inherited from class java.lang.Object

Method Detail

count

countLong

countBi

countLongBi

countTri

countLongTri

countQuad

countLongQuad

countDistinct

countDistinct

countDistinctLong

countDistinct

countDistinctLong

countDistinct

countDistinctLong

countDistinct

countDistinctLong

sum

sumLong

sum

sumBigDecimal

sumBigInteger

sumDuration

sumPeriod

sum

sumLong

sum

sumBigDecimal

sumBigInteger

sumDuration

sumPeriod

sum

sumLong

sum

sumBigDecimal

sumBigInteger

sumDuration

sumPeriod

sum

sumLong

sum

sumBigDecimal

sumBigInteger

sumDuration

sumPeriod

min

min

min

min

min

min

min

min

min

min

min

min

min

min

max

max

max

max

max

max

max

max

max

max

max

max

max

max

toCollection

average

averageLong