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

```
public final class ConstraintCollectors
extends Object
```
Creates an UniConstraintCollector, BiConstraintCollector, ... instance for use in UniConstraintStream.groupBy(Function, UniConstraintCollector), ...

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`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,?,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,?,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>`	`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>`	`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,?,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,?,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,?,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,?,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,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,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,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,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,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,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,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,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,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,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,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> 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> 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,?,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,?,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,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> 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> UniConstraintCollector<A,?,A>`	`max(Comparator<A> comparator)`	As defined by `max()`, only with a custom `Comparator`.
`static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,Mapped>`	`max(BiFunction<A,B,Mapped> groupValueMapping)`	As defined by `max(Function)`.
`static <A,B,Mapped> BiConstraintCollector<A,B,?,Mapped>`	`max(BiFunction<A,B,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `max(Function)`, only with a custom `Comparator`.
`static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,Mapped>`	`max(Function<A,Mapped> groupValueMapping)`	Returns a collector that finds a maximum value in a group of `Comparable` elements.
`static <A,Mapped> UniConstraintCollector<A,?,Mapped>`	`max(Function<A,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `max(Function)`, only with a custom `Comparator`.
`static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,Mapped>`	`max(QuadFunction<A,B,C,D,Mapped> groupValueMapping)`	As defined by `max(Function)`.
`static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Mapped>`	`max(QuadFunction<A,B,C,D,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `max(Function)`, only with a custom `Comparator`.
`static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,Mapped>`	`max(TriFunction<A,B,C,Mapped> groupValueMapping)`	As defined by `max(Function)`.
`static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Mapped>`	`max(TriFunction<A,B,C,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `max(Function)`, only with a custom `Comparator`.
`static <A extends Comparable<A>> UniConstraintCollector<A,?,A>`	`min()`	Returns a collector that finds a minimum value in a group of `Comparable` elements.
`static <A> UniConstraintCollector<A,?,A>`	`min(Comparator<A> comparator)`	As defined by `min()`, only with a custom `Comparator`.
`static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,Mapped>`	`min(BiFunction<A,B,Mapped> groupValueMapping)`	As defined by `min(Function)`.
`static <A,B,Mapped> BiConstraintCollector<A,B,?,Mapped>`	`min(BiFunction<A,B,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `min(Function)`, only with a custom `Comparator`.
`static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,Mapped>`	`min(Function<A,Mapped> groupValueMapping)`	Returns a collector that finds a minimum value in a group of `Comparable` elements.
`static <A,Mapped> UniConstraintCollector<A,?,Mapped>`	`min(Function<A,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `min(Function)`, only with a custom `Comparator`.
`static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,Mapped>`	`min(QuadFunction<A,B,C,D,Mapped> groupValueMapping)`	As defined by `min(Function)`.
`static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Mapped>`	`min(QuadFunction<A,B,C,D,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `min(Function)`, only with a custom `Comparator`.
`static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,Mapped>`	`min(TriFunction<A,B,C,Mapped> groupValueMapping)`	As defined by `min(Function)`.
`static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Mapped>`	`min(TriFunction<A,B,C,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `min(Function)`, only with a custom `Comparator`.
`static <A,B,Result> BiConstraintCollector<A,B,?,Result>`	`sum(BiFunction<? super A,? super B,Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)`	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,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> 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,?,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,?,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,?,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,?,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,?,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,?,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,?,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,?,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> 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,Mapped,Result extends Collection<Mapped>> BiConstraintCollector<A,B,?,Result>`	`toCollection(BiFunction<A,B,Mapped> groupValueMapping, IntFunction<Result> collectionFunction)`	Deprecated. in favor of `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. in favor of `toList(Function)`, `toSet(Function)` or `toSortedSet(Function)`
`static <A,Result extends Collection<A>> UniConstraintCollector<A,?,Result>`	`toCollection(IntFunction<Result> collectionFunction)`	Deprecated. in favor of `toList()`, `toSet()` or `toSortedSet()`
`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. in favor of `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. in favor of `toList(TriFunction)`, `toSet(TriFunction)` or `toSortedSet(TriFunction)`
`static <A> UniConstraintCollector<A,?,List<A>>`	`toList()`	Creates constraint collector that returns `List` of the same element type as the `ConstraintStream`.
`static <A,B,Mapped> BiConstraintCollector<A,B,?,List<Mapped>>`	`toList(BiFunction<A,B,Mapped> groupValueMapping)`	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,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,Key,Value> BiConstraintCollector<A,B,?,Map<Key,Set<Value>>>`	`toMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper)`	As defined by `toMap(Function, Function)`.
`static <A,B,Key,Value> BiConstraintCollector<A,B,?,Map<Key,Value>>`	`toMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)`	As defined by `toMap(Function, Function, BinaryOperator)`.
`static <A,B,Key,Value,ValueSet extends Set<Value>> BiConstraintCollector<A,B,?,Map<Key,ValueSet>>`	`toMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)`	As defined by `toMap(Function, Function, IntFunction)`.
`static <A,Key,Value> UniConstraintCollector<A,?,Map<Key,Set<Value>>>`	`toMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper)`	Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.
`static <A,Key,Value> UniConstraintCollector<A,?,Map<Key,Value>>`	`toMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)`	Creates a constraint collector that returns a `Map`.
`static <A,Key,Value,ValueSet extends Set<Value>> UniConstraintCollector<A,?,Map<Key,ValueSet>>`	`toMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)`	Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.
`static <A,B,C,D,Key,Value> QuadConstraintCollector<A,B,C,D,?,Map<Key,Set<Value>>>`	`toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper)`	As defined by `toMap(Function, Function)`.
`static <A,B,C,D,Key,Value> QuadConstraintCollector<A,B,C,D,?,Map<Key,Value>>`	`toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)`	As defined by `toMap(Function, Function, BinaryOperator)`.
`static <A,B,C,D,Key,Value,ValueSet extends Set<Value>> QuadConstraintCollector<A,B,C,D,?,Map<Key,ValueSet>>`	`toMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)`	As defined by `toMap(Function, Function, IntFunction)`.
`static <A,B,C,Key,Value> TriConstraintCollector<A,B,C,?,Map<Key,Set<Value>>>`	`toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper)`	As defined by `toMap(Function, Function)`.
`static <A,B,C,Key,Value> TriConstraintCollector<A,B,C,?,Map<Key,Value>>`	`toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)`	As defined by `toMap(Function, Function, BinaryOperator)`.
`static <A,B,C,Key,Value,ValueSet extends Set<Value>> TriConstraintCollector<A,B,C,?,Map<Key,ValueSet>>`	`toMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)`	As defined by `toMap(Function, Function, IntFunction)`.
`static <A> UniConstraintCollector<A,?,Set<A>>`	`toSet()`	Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`.
`static <A,B,Mapped> BiConstraintCollector<A,B,?,Set<Mapped>>`	`toSet(BiFunction<A,B,Mapped> groupValueMapping)`	As defined by `toSet(Function)`.
`static <A,Mapped> UniConstraintCollector<A,?,Set<Mapped>>`	`toSet(Function<A,Mapped> groupValueMapping)`	Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`.
`static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,Set<Mapped>>`	`toSet(QuadFunction<A,B,C,D,Mapped> groupValueMapping)`	As defined by `toSet(Function)`.
`static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,Set<Mapped>>`	`toSet(TriFunction<A,B,C,Mapped> groupValueMapping)`	As defined by `toSet(Function)`.
`static <A,B,Key extends Comparable<Key>,Value> BiConstraintCollector<A,B,?,SortedMap<Key,Set<Value>>>`	`toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper)`	As defined by `toSortedMap(Function, Function)`.
`static <A,B,Key extends Comparable<Key>,Value> BiConstraintCollector<A,B,?,SortedMap<Key,Value>>`	`toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)`	As defined by `toSortedMap(Function, Function, BinaryOperator)`.
`static <A,B,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> BiConstraintCollector<A,B,?,SortedMap<Key,ValueSet>>`	`toSortedMap(BiFunction<? super A,? super B,? extends Key> keyMapper, BiFunction<? super A,? super B,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)`	As defined by `toSortedMap(Function, Function, IntFunction)`.
`static <A,Key extends Comparable<Key>,Value> UniConstraintCollector<A,?,SortedMap<Key,Set<Value>>>`	`toSortedMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper)`	Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.
`static <A,Key extends Comparable<Key>,Value> UniConstraintCollector<A,?,SortedMap<Key,Value>>`	`toSortedMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)`	Creates a constraint collector that returns a `SortedMap`.
`static <A,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> UniConstraintCollector<A,?,SortedMap<Key,ValueSet>>`	`toSortedMap(Function<? super A,? extends Key> keyMapper, Function<? super A,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)`	Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.
`static <A,B,C,D,Key extends Comparable<Key>,Value> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,Set<Value>>>`	`toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper)`	As defined by `toSortedMap(Function, Function)`.
`static <A,B,C,D,Key extends Comparable<Key>,Value> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,Value>>`	`toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)`	As defined by `toSortedMap(Function, Function, BinaryOperator)`.
`static <A,B,C,D,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> QuadConstraintCollector<A,B,C,D,?,SortedMap<Key,ValueSet>>`	`toSortedMap(QuadFunction<? super A,? super B,? super C,? super D,? extends Key> keyMapper, QuadFunction<? super A,? super B,? super C,? super D,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)`	As defined by `toSortedMap(Function, Function, IntFunction)`.
`static <A,B,C,Key extends Comparable<Key>,Value> TriConstraintCollector<A,B,C,?,SortedMap<Key,Set<Value>>>`	`toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper)`	As defined by `toSortedMap(Function, Function)`.
`static <A,B,C,Key extends Comparable<Key>,Value> TriConstraintCollector<A,B,C,?,SortedMap<Key,Value>>`	`toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)`	As defined by `toSortedMap(Function, Function, BinaryOperator)`.
`static <A,B,C,Key extends Comparable<Key>,Value,ValueSet extends Set<Value>> TriConstraintCollector<A,B,C,?,SortedMap<Key,ValueSet>>`	`toSortedMap(TriFunction<? super A,? super B,? super C,? extends Key> keyMapper, TriFunction<? super A,? super B,? super C,? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)`	As defined by `toSortedMap(Function, Function, IntFunction)`.
`static <A extends Comparable<A>> UniConstraintCollector<A,?,SortedSet<A>>`	`toSortedSet()`	Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
`static <A> UniConstraintCollector<A,?,SortedSet<A>>`	`toSortedSet(Comparator<A> comparator)`	As defined by `toSortedSet()`, only with a custom `Comparator`.
`static <A,B,Mapped extends Comparable<Mapped>> BiConstraintCollector<A,B,?,SortedSet<Mapped>>`	`toSortedSet(BiFunction<A,B,Mapped> groupValueMapping)`	As defined by `toSortedSet(Function)`.
`static <A,B,Mapped> BiConstraintCollector<A,B,?,SortedSet<Mapped>>`	`toSortedSet(BiFunction<A,B,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `toSortedSet(Function, Comparator)`.
`static <A,Mapped extends Comparable<Mapped>> UniConstraintCollector<A,?,SortedSet<Mapped>>`	`toSortedSet(Function<A,Mapped> groupValueMapping)`	Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
`static <A,Mapped> UniConstraintCollector<A,?,SortedSet<Mapped>>`	`toSortedSet(Function<A,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `toSortedSet(Function)`, only with a custom `Comparator`.
`static <A,B,C,D,Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,B,C,D,?,SortedSet<Mapped>>`	`toSortedSet(QuadFunction<A,B,C,D,Mapped> groupValueMapping)`	As defined by `toSortedSet(Function)`.
`static <A,B,C,D,Mapped> QuadConstraintCollector<A,B,C,D,?,SortedSet<Mapped>>`	`toSortedSet(QuadFunction<A,B,C,D,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `toSortedSet(Function, Comparator)`.
`static <A,B,C,Mapped extends Comparable<Mapped>> TriConstraintCollector<A,B,C,?,SortedSet<Mapped>>`	`toSortedSet(TriFunction<A,B,C,Mapped> groupValueMapping)`	As defined by `toSortedSet(Function)`.
`static <A,B,C,Mapped> TriConstraintCollector<A,B,C,?,SortedSet<Mapped>>`	`toSortedSet(TriFunction<A,B,C,Mapped> groupValueMapping, Comparator<Mapped> comparator)`	As defined by `toSortedSet(Function, 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<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> UniConstraintCollector<A,?,A> min(Comparator<A> comparator)

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

min

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

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

min

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

As defined by min(Function).

min

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

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

min

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

As defined by min(Function).

min

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

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

min

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

As defined by min(Function).

min

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

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

max
```
public static <A extends Comparable<A>> UniConstraintCollector<A,?,A> max()
```
Returns a collector that finds a maximum value in a group of Comparable elements.
Important: The Comparable's Comparable.compareTo(Object) must be consistent with equals, such that e1.compareTo(e2) == 0 has the same boolean value as e1.equals(e2). In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same PlanningSolution state, due to incremental score calculation.
For example, [Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)] with .groupBy(max()) returns either Cathy or David arbitrarily, assuming the objects are Comparable by the age field. To avoid this, always end your Comparator by an identity comparison, such as Comparator.comparing(Person::getAge).comparing(Person::getId)).
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<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

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

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

max

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

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

max

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

As defined by max(Function).

max

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

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

max

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

As defined by max(Function).

max

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

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

max

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

As defined by max(Function).

max

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

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

toCollection

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

Deprecated.

in favor of 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<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.

in favor of 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<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<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.

in favor of 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<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<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.

in favor of 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<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<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.

in favor of 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<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<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<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<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<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<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<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<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<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<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<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<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<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<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

max

max

max

max

max

max

max

max

max

max

toCollection

average

averageLong

averageBigDecimal

averageBigInteger

averageDuration

average

averageLong

averageBigDecimal

averageBigInteger

averageDuration