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

Interface QuadConstraintStream<A,B,C,D>

Type Parameters:

A - the type of the first matched fact (either a problem fact or a planning entity)

B - the type of the second matched fact (either a problem fact or a planning entity)

C - the type of the third matched fact (either a problem fact or a planning entity)

D - the type of the fourth matched fact (either a problem fact or a planning entity)

All Superinterfaces:

ConstraintStream

All Known Subinterfaces:

InnerQuadConstraintStream<A,B,C,D>

All Known Implementing Classes:

DroolsAbstractQuadConstraintStream, DroolsExistsQuadConstraintStream, DroolsFilterQuadConstraintStream, DroolsGroupingQuadConstraintStream, DroolsJoinQuadConstraintStream, DroolsScoringQuadConstraintStream

public interface QuadConstraintStream<A,B,C,D>
extends ConstraintStream

A ConstraintStream that matches four facts.

See Also:

ConstraintStream

Method Summary

Modifier and Type	Method	Description
QuadConstraintStream<A,B,C,D>	filter(QuadPredicate<A,B,C,D> predicate)	Exhaustively test each tuple of facts against the QuadPredicate and match if QuadPredicate.test(Object, Object, Object, Object) returns true.
<GroupKey_> UniConstraintStream<GroupKey_>	groupBy(QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping)	Convert the QuadConstraintStream to a UniConstraintStream, containing the set of tuples resulting from applying the group key mapping function on all tuples of the original stream.
<GroupKey_,ResultContainer_,Result_> BiConstraintStream<GroupKey_,Result_>	groupBy(QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)	Convert the QuadConstraintStream to a BiConstraintStream, consisting of unique tuples.
<GroupKeyA_,GroupKeyB_> BiConstraintStream<GroupKeyA_,GroupKeyB_>	groupBy(QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping)	Convert the QuadConstraintStream to a BiConstraintStream, consisting of unique tuples.
<GroupKeyA_,GroupKeyB_,ResultContainer_,Result_> TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_>	groupBy(QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)	Combines the semantics of groupBy(QuadFunction, QuadFunction) and groupBy(QuadConstraintCollector).
<GroupKeyA_,GroupKeyB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_>	groupBy(QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)	Combines the semantics of groupBy(QuadFunction, QuadFunction) and groupBy(QuadConstraintCollector).
<ResultContainer_,Result_> UniConstraintStream<Result_>	groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)	Convert the QuadConstraintStream to a UniConstraintStream, containing only a single tuple, the result of applying QuadConstraintCollector.
default <E> QuadConstraintStream<A,B,C,D>	ifExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E> joiner)	Create a new BiConstraintStream for every tuple of A, B, C and D where E exists for which the PentaJoiner is true (for the properties it extracts from the facts).
<E> QuadConstraintStream<A,B,C,D>	ifExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E>... joiners)	As defined by ifExists(Class, PentaJoiner).
default <E> QuadConstraintStream<A,B,C,D>	ifExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E> joiner1, PentaJoiner<A,B,C,D,E> joiner2)	As defined by ifExists(Class, PentaJoiner).
default <E> QuadConstraintStream<A,B,C,D>	ifExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E> joiner1, PentaJoiner<A,B,C,D,E> joiner2, PentaJoiner<A,B,C,D,E> joiner3)	As defined by ifExists(Class, PentaJoiner).
default <E> QuadConstraintStream<A,B,C,D>	ifExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E> joiner1, PentaJoiner<A,B,C,D,E> joiner2, PentaJoiner<A,B,C,D,E> joiner3, PentaJoiner<A,B,C,D,E> joiner4)	As defined by ifExists(Class, PentaJoiner).
default <E> QuadConstraintStream<A,B,C,D>	ifNotExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E> joiner)	Create a new BiConstraintStream for every tuple of A, B, C and D where E does not exist for which the PentaJoiner is true (for the properties it extracts from the facts).
<E> QuadConstraintStream<A,B,C,D>	ifNotExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E>... joiners)	As defined by ifNotExists(Class, PentaJoiner).
default <E> QuadConstraintStream<A,B,C,D>	ifNotExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E> joiner1, PentaJoiner<A,B,C,D,E> joiner2)	As defined by ifNotExists(Class, PentaJoiner).
default <E> QuadConstraintStream<A,B,C,D>	ifNotExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E> joiner1, PentaJoiner<A,B,C,D,E> joiner2, PentaJoiner<A,B,C,D,E> joiner3)	As defined by ifNotExists(Class, PentaJoiner).
default <E> QuadConstraintStream<A,B,C,D>	ifNotExists(Class<E> otherClass, PentaJoiner<A,B,C,D,E> joiner1, PentaJoiner<A,B,C,D,E> joiner2, PentaJoiner<A,B,C,D,E> joiner3, PentaJoiner<A,B,C,D,E> joiner4)	As defined by ifNotExists(Class, PentaJoiner).
Constraint	impact(String constraintPackage, String constraintName, Score<?> constraintWeight, ToIntQuadFunction<A,B,C,D> matchWeigher)	As defined by impact(String, Score, ToIntQuadFunction).
default Constraint	impact(String constraintName, Score<?> constraintWeight, ToIntQuadFunction<A,B,C,D> matchWeigher)	Positively or negatively impact the Score by the constraintWeight multiplied by the match weight.
Constraint	impactBigDecimal(String constraintPackage, String constraintName, Score<?> constraintWeight, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	As defined by impactBigDecimal(String, Score, QuadFunction).
default Constraint	impactBigDecimal(String constraintName, Score<?> constraintWeight, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	Positively or negatively impact the Score by the constraintWeight multiplied by the match weight.
Constraint	impactConfigurable(String constraintPackage, String constraintName, ToIntQuadFunction<A,B,C,D> matchWeigher)	As defined by impactConfigurable(String, ToIntQuadFunction).
default Constraint	impactConfigurable(String constraintName, ToIntQuadFunction<A,B,C,D> matchWeigher)	Positively or negatively impact the Score by the ConstraintWeight for each match.
Constraint	impactConfigurableBigDecimal(String constraintPackage, String constraintName, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	As defined by impactConfigurableBigDecimal(String, QuadFunction).
default Constraint	impactConfigurableBigDecimal(String constraintName, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	Positively or negatively impact the Score by the ConstraintWeight for each match.
Constraint	impactConfigurableLong(String constraintPackage, String constraintName, ToLongQuadFunction<A,B,C,D> matchWeigher)	As defined by impactConfigurableLong(String, ToLongQuadFunction).
default Constraint	impactConfigurableLong(String constraintName, ToLongQuadFunction<A,B,C,D> matchWeigher)	Positively or negatively impact the Score by the ConstraintWeight for each match.
Constraint	impactLong(String constraintPackage, String constraintName, Score<?> constraintWeight, ToLongQuadFunction<A,B,C,D> matchWeigher)	As defined by impactLong(String, Score, ToLongQuadFunction).
default Constraint	impactLong(String constraintName, Score<?> constraintWeight, ToLongQuadFunction<A,B,C,D> matchWeigher)	Positively or negatively impact the Score by the constraintWeight multiplied by the match weight.
Constraint	penalize(String constraintPackage, String constraintName, Score<?> constraintWeight, ToIntQuadFunction<A,B,C,D> matchWeigher)	As defined by penalize(String, Score, ToIntQuadFunction).
default Constraint	penalize(String constraintName, Score<?> constraintWeight, ToIntQuadFunction<A,B,C,D> matchWeigher)	Negatively impact the Score: subtract the constraintWeight multiplied by the match weight.
Constraint	penalizeBigDecimal(String constraintPackage, String constraintName, Score<?> constraintWeight, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	As defined by penalizeBigDecimal(String, Score, QuadFunction).
default Constraint	penalizeBigDecimal(String constraintName, Score<?> constraintWeight, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	Negatively impact the Score: subtract the constraintWeight multiplied by the match weight.
Constraint	penalizeConfigurable(String constraintPackage, String constraintName, ToIntQuadFunction<A,B,C,D> matchWeigher)	As defined by penalizeConfigurable(String, ToIntQuadFunction).
default Constraint	penalizeConfigurable(String constraintName, ToIntQuadFunction<A,B,C,D> matchWeigher)	Negatively impact the Score: subtract the ConstraintWeight multiplied by the match weight.
Constraint	penalizeConfigurableBigDecimal(String constraintPackage, String constraintName, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	As defined by penalizeConfigurableBigDecimal(String, QuadFunction).
default Constraint	penalizeConfigurableBigDecimal(String constraintName, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	Negatively impact the Score: subtract the ConstraintWeight multiplied by the match weight.
Constraint	penalizeConfigurableLong(String constraintPackage, String constraintName, ToLongQuadFunction<A,B,C,D> matchWeigher)	As defined by penalizeConfigurableLong(String, ToLongQuadFunction).
default Constraint	penalizeConfigurableLong(String constraintName, ToLongQuadFunction<A,B,C,D> matchWeigher)	Negatively impact the Score: subtract the ConstraintWeight multiplied by the match weight.
Constraint	penalizeLong(String constraintPackage, String constraintName, Score<?> constraintWeight, ToLongQuadFunction<A,B,C,D> matchWeigher)	As defined by penalizeLong(String, Score, ToLongQuadFunction).
default Constraint	penalizeLong(String constraintName, Score<?> constraintWeight, ToLongQuadFunction<A,B,C,D> matchWeigher)	Negatively impact the Score: subtract the constraintWeight multiplied by the match weight.
Constraint	reward(String constraintPackage, String constraintName, Score<?> constraintWeight, ToIntQuadFunction<A,B,C,D> matchWeigher)	As defined by reward(String, Score, ToIntQuadFunction).
default Constraint	reward(String constraintName, Score<?> constraintWeight, ToIntQuadFunction<A,B,C,D> matchWeigher)	Positively impact the Score: add the constraintWeight multiplied by the match weight.
Constraint	rewardBigDecimal(String constraintPackage, String constraintName, Score<?> constraintWeight, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	As defined by rewardBigDecimal(String, Score, QuadFunction).
default Constraint	rewardBigDecimal(String constraintName, Score<?> constraintWeight, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	Positively impact the Score: add the constraintWeight multiplied by the match weight.
Constraint	rewardConfigurable(String constraintPackage, String constraintName, ToIntQuadFunction<A,B,C,D> matchWeigher)	As defined by rewardConfigurable(String, ToIntQuadFunction).
default Constraint	rewardConfigurable(String constraintName, ToIntQuadFunction<A,B,C,D> matchWeigher)	Positively impact the Score: add the ConstraintWeight multiplied by the match weight.
Constraint	rewardConfigurableBigDecimal(String constraintPackage, String constraintName, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	As defined by rewardConfigurableBigDecimal(String, QuadFunction).
default Constraint	rewardConfigurableBigDecimal(String constraintName, QuadFunction<A,B,C,D,BigDecimal> matchWeigher)	Positively impact the Score: add the ConstraintWeight multiplied by the match weight.
Constraint	rewardConfigurableLong(String constraintPackage, String constraintName, ToLongQuadFunction<A,B,C,D> matchWeigher)	As defined by rewardConfigurableLong(String, ToLongQuadFunction).
default Constraint	rewardConfigurableLong(String constraintName, ToLongQuadFunction<A,B,C,D> matchWeigher)	Positively impact the Score: add the ConstraintWeight multiplied by the match weight.
Constraint	rewardLong(String constraintPackage, String constraintName, Score<?> constraintWeight, ToLongQuadFunction<A,B,C,D> matchWeigher)	As defined by rewardLong(String, Score, ToLongQuadFunction).
default Constraint	rewardLong(String constraintName, Score<?> constraintWeight, ToLongQuadFunction<A,B,C,D> matchWeigher)	Positively impact the Score: add the constraintWeight multiplied by the match weight.

Methods inherited from interface org.optaplanner.core.api.score.stream.ConstraintStream

getConstraintFactory, impact, impact, penalize, penalize, penalizeConfigurable, penalizeConfigurable, reward, reward, rewardConfigurable, rewardConfigurable

Method Detail

filter

QuadConstraintStream<A,B,C,D> filter(QuadPredicate<A,B,C,D> predicate)

Exhaustively test each tuple of facts against the QuadPredicate and match if QuadPredicate.test(Object, Object, Object, Object) returns true.

Important: This is slower and less scalable than TriConstraintStream.join(UniConstraintStream, QuadJoiner) with a proper QuadJoiner predicate (such as Joiners.equal(TriFunction, Function), because the latter applies hashing and/or indexing, so it doesn't create every combination just to filter it out.

Parameters:

predicate - never null

Returns:

never null

ifExists

default <E> QuadConstraintStream<A,B,C,D> ifExists(Class<E> otherClass,
                                                                     PentaJoiner<A,B,C,D,E> joiner)

Create a new BiConstraintStream for every tuple of A, B, C and D where E exists for which the PentaJoiner is true (for the properties it extracts from the facts).

This method has overloaded methods with multiple PentaJoiner parameters.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiner - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E exists for which the PentaJoiner is true

ifExists

default <E> QuadConstraintStream<A,B,C,D> ifExists(Class<E> otherClass,
                                                                     PentaJoiner<A,B,C,D,E> joiner1,
                                                                     PentaJoiner<A,B,C,D,E> joiner2)

As defined by ifExists(Class, PentaJoiner). For performance reasons, indexing joiners must be placed before filtering joiners.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E exists for which the PentaJoiners are true

ifExists

default <E> QuadConstraintStream<A,B,C,D> ifExists(Class<E> otherClass,
                                                                     PentaJoiner<A,B,C,D,E> joiner1,
                                                                     PentaJoiner<A,B,C,D,E> joiner2,
                                                                     PentaJoiner<A,B,C,D,E> joiner3)

As defined by ifExists(Class, PentaJoiner). For performance reasons, indexing joiners must be placed before filtering joiners.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

joiner3 - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E exists for which the PentaJoiners are true

ifExists

default <E> QuadConstraintStream<A,B,C,D> ifExists(Class<E> otherClass,
                                                                     PentaJoiner<A,B,C,D,E> joiner1,
                                                                     PentaJoiner<A,B,C,D,E> joiner2,
                                                                     PentaJoiner<A,B,C,D,E> joiner3,
                                                                     PentaJoiner<A,B,C,D,E> joiner4)

As defined by ifExists(Class, PentaJoiner). For performance reasons, indexing joiners must be placed before filtering joiners.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

joiner3 - never null

joiner4 - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E exists for which the PentaJoiners are true

ifExists

<E> QuadConstraintStream<A,B,C,D> ifExists(Class<E> otherClass,
                                                             PentaJoiner<A,B,C,D,E>... joiners)

As defined by ifExists(Class, PentaJoiner). For performance reasons, indexing joiners must be placed before filtering joiners.

This method causes Unchecked generics array creation for varargs parameter warnings, but we can't fix it with a SafeVarargs annotation because it's an interface method. Therefore, there are overloaded methods with up to 4 PentaJoiner parameters.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiners - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E exists for which the PentaJoiners are true

ifNotExists

default <E> QuadConstraintStream<A,B,C,D> ifNotExists(Class<E> otherClass,
                                                                        PentaJoiner<A,B,C,D,E> joiner)

Create a new BiConstraintStream for every tuple of A, B, C and D where E does not exist for which the PentaJoiner is true (for the properties it extracts from the facts).

This method has overloaded methods with multiple PentaJoiner parameters.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiner - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E does not exist for which the PentaJoiner is true

ifNotExists

default <E> QuadConstraintStream<A,B,C,D> ifNotExists(Class<E> otherClass,
                                                                        PentaJoiner<A,B,C,D,E> joiner1,
                                                                        PentaJoiner<A,B,C,D,E> joiner2)

As defined by ifNotExists(Class, PentaJoiner). For performance reasons, indexing joiners must be placed before filtering joiners.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E does not exist for which the PentaJoiners are true

ifNotExists

default <E> QuadConstraintStream<A,B,C,D> ifNotExists(Class<E> otherClass,
                                                                        PentaJoiner<A,B,C,D,E> joiner1,
                                                                        PentaJoiner<A,B,C,D,E> joiner2,
                                                                        PentaJoiner<A,B,C,D,E> joiner3)

As defined by ifNotExists(Class, PentaJoiner). For performance reasons, indexing joiners must be placed before filtering joiners.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

joiner3 - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E does not exist for which the PentaJoiners are true

ifNotExists

default <E> QuadConstraintStream<A,B,C,D> ifNotExists(Class<E> otherClass,
                                                                        PentaJoiner<A,B,C,D,E> joiner1,
                                                                        PentaJoiner<A,B,C,D,E> joiner2,
                                                                        PentaJoiner<A,B,C,D,E> joiner3,
                                                                        PentaJoiner<A,B,C,D,E> joiner4)

As defined by ifNotExists(Class, PentaJoiner). For performance reasons, indexing joiners must be placed before filtering joiners.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

joiner3 - never null

joiner4 - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E does not exist for which the PentaJoiners are true

ifNotExists

<E> QuadConstraintStream<A,B,C,D> ifNotExists(Class<E> otherClass,
                                                                PentaJoiner<A,B,C,D,E>... joiners)

As defined by ifNotExists(Class, PentaJoiner). For performance reasons, indexing joiners must be placed before filtering joiners.

This method causes Unchecked generics array creation for varargs parameter warnings, but we can't fix it with a SafeVarargs annotation because it's an interface method. Therefore, there are overloaded methods with up to 4 PentaJoiner parameters.

Type Parameters:

E - the type of the fifth matched fact

Parameters:

otherClass - never null

joiners - never null

Returns:

never null, a stream that matches every tuple of A, B, C and D where E does not exist for which the PentaJoiners are true

groupBy

<ResultContainer_,Result_> UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)

Convert the QuadConstraintStream to a UniConstraintStream, containing only a single tuple, the result of applying QuadConstraintCollector. UniConstraintStream which only has a single tuple, the result of applying QuadConstraintCollector.

Type Parameters:

ResultContainer_ - the mutable accumulation type (often hidden as an implementation detail)

Result_ - the type of a fact in the destination UniConstraintStream's tuple

Parameters:

collector - never null, the collector to perform the grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

Returns:

never null

groupBy

<GroupKey_> UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping)

Convert the QuadConstraintStream to a UniConstraintStream, containing the set of tuples resulting from applying the group key mapping function on all tuples of the original stream. Neither tuple of the new stream Objects.equals(Object, Object) any other.

Type Parameters:

GroupKey_ - the type of a fact in the destination UniConstraintStream's tuple

Parameters:

groupKeyMapping - never null, mapping function to convert each element in the stream to a different element

Returns:

never null

groupBy

<GroupKey_,ResultContainer_,Result_> BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping,
                                                                                                     QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)

Convert the QuadConstraintStream to a BiConstraintStream, consisting of unique tuples.

The first fact is the return value of the first group key mapping function, applied on the incoming tuple. The second fact is the return value of a given QuadConstraintCollector applied on all incoming tuples with the same first fact.

Type Parameters:

GroupKey_ - the type of the first fact in the destination BiConstraintStream's tuple

ResultContainer_ - the mutable accumulation type (often hidden as an implementation detail)

Result_ - the type of the second fact in the destination BiConstraintStream's tuple

Parameters:

groupKeyMapping - never null, function to convert the fact in the original tuple to a different fact

collector - never null, the collector to perform the grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

Returns:

never null

groupBy

<GroupKeyA_,GroupKeyB_> BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping,
                                                                                      QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping)

Convert the QuadConstraintStream to a BiConstraintStream, consisting of unique tuples.

The first fact is the return value of the first group key mapping function, applied on the incoming tuple. The second fact is the return value of the second group key mapping function, applied on all incoming tuples with the same first fact.

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination BiConstraintStream's tuple

GroupKeyB_ - the type of the second fact in the destination BiConstraintStream's tuple

Parameters:

groupKeyAMapping - never null, function to convert the facts in the original tuple to a new fact

groupKeyBMapping - never null, function to convert the facts in the original tuple to another new fact

Returns:

never null

groupBy

<GroupKeyA_,GroupKeyB_,ResultContainer_,Result_> TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping,
                                                                                                                                          QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping,
                                                                                                                                          QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)

Combines the semantics of groupBy(QuadFunction, QuadFunction) and groupBy(QuadConstraintCollector). That is, the first and second facts in the tuple follow the groupBy(QuadFunction, QuadFunction) semantics, and the third fact is the result of applying QuadConstraintCollector.finisher() on all the tuples of the original UniConstraintStream that belong to the group.

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination TriConstraintStream's tuple

GroupKeyB_ - the type of the second fact in the destination TriConstraintStream's tuple

ResultContainer_ - the mutable accumulation type (often hidden as an implementation detail)

Result_ - the type of the third fact in the destination TriConstraintStream's tuple

Parameters:

groupKeyAMapping - never null, function to convert the original tuple into a first fact

groupKeyBMapping - never null, function to convert the original tuple into a second fact

collector - never null, the collector to perform the grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

Returns:

never null

groupBy

<GroupKeyA_,GroupKeyB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                                    QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                                    QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC,
                                                                                                                                                                                                    QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)

Combines the semantics of groupBy(QuadFunction, QuadFunction) and groupBy(QuadConstraintCollector). That is, the first and second facts in the tuple follow the groupBy(QuadFunction, QuadFunction) semantics. The third fact is the result of applying the first QuadConstraintCollector.finisher() on all the tuples of the original QuadConstraintStream that belong to the group. The fourth fact is the result of applying the second QuadConstraintCollector.finisher() on all the tuples of the original QuadConstraintStream that belong to the group

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination QuadConstraintStream's tuple

GroupKeyB_ - the type of the second fact in the destination QuadConstraintStream's tuple

ResultContainerC_ - the mutable accumulation type (often hidden as an implementation detail)

ResultC_ - the type of the third fact in the destination QuadConstraintStream's tuple

ResultContainerD_ - the mutable accumulation type (often hidden as an implementation detail)

ResultD_ - the type of the fourth fact in the destination QuadConstraintStream's tuple

Parameters:

groupKeyAMapping - never null, function to convert the original tuple into a first fact

groupKeyBMapping - never null, function to convert the original tuple into a second fact

collectorC - never null, the collector to perform the first grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

collectorD - never null, the collector to perform the second grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

Returns:

never null

penalize

default Constraint penalize(String constraintName,
                            Score<?> constraintWeight,
                            ToIntQuadFunction<A,B,C,D> matchWeigher)

Negatively impact the Score: subtract the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.penalize(String, Score).

For non-int Score types use penalizeLong(String, Score, ToLongQuadFunction) or penalizeBigDecimal(String, Score, QuadFunction) instead.

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

penalize

Constraint penalize(String constraintPackage,
                    String constraintName,
                    Score<?> constraintWeight,
                    ToIntQuadFunction<A,B,C,D> matchWeigher)

As defined by penalize(String, Score, ToIntQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

penalizeLong

default Constraint penalizeLong(String constraintName,
                                Score<?> constraintWeight,
                                ToLongQuadFunction<A,B,C,D> matchWeigher)

Negatively impact the Score: subtract the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.penalize(String, Score).

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

penalizeLong

Constraint penalizeLong(String constraintPackage,
                        String constraintName,
                        Score<?> constraintWeight,
                        ToLongQuadFunction<A,B,C,D> matchWeigher)

As defined by penalizeLong(String, Score, ToLongQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

penalizeBigDecimal

default Constraint penalizeBigDecimal(String constraintName,
                                      Score<?> constraintWeight,
                                      QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

Negatively impact the Score: subtract the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.penalize(String, Score).

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

penalizeBigDecimal

Constraint penalizeBigDecimal(String constraintPackage,
                              String constraintName,
                              Score<?> constraintWeight,
                              QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

As defined by penalizeBigDecimal(String, Score, QuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

penalizeConfigurable

default Constraint penalizeConfigurable(String constraintName,
                                        ToIntQuadFunction<A,B,C,D> matchWeigher)

Negatively impact the Score: subtract the ConstraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.penalizeConfigurable(String).

For non-int Score types use penalizeConfigurableLong(String, ToLongQuadFunction) or penalizeConfigurableBigDecimal(String, QuadFunction) instead.

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

penalizeConfigurable

Constraint penalizeConfigurable(String constraintPackage,
                                String constraintName,
                                ToIntQuadFunction<A,B,C,D> matchWeigher)

As defined by penalizeConfigurable(String, ToIntQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null

penalizeConfigurableLong

default Constraint penalizeConfigurableLong(String constraintName,
                                            ToLongQuadFunction<A,B,C,D> matchWeigher)

Negatively impact the Score: subtract the ConstraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.penalizeConfigurable(String).

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

penalizeConfigurableLong

Constraint penalizeConfigurableLong(String constraintPackage,
                                    String constraintName,
                                    ToLongQuadFunction<A,B,C,D> matchWeigher)

As defined by penalizeConfigurableLong(String, ToLongQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null

penalizeConfigurableBigDecimal

default Constraint penalizeConfigurableBigDecimal(String constraintName,
                                                  QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

Negatively impact the Score: subtract the ConstraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.penalizeConfigurable(String).

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

penalizeConfigurableBigDecimal

Constraint penalizeConfigurableBigDecimal(String constraintPackage,
                                          String constraintName,
                                          QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

As defined by penalizeConfigurableBigDecimal(String, QuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null

reward

default Constraint reward(String constraintName,
                          Score<?> constraintWeight,
                          ToIntQuadFunction<A,B,C,D> matchWeigher)

Positively impact the Score: add the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.reward(String, Score).

For non-int Score types use rewardLong(String, Score, ToLongQuadFunction) or rewardBigDecimal(String, Score, QuadFunction) instead.

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

reward

Constraint reward(String constraintPackage,
                  String constraintName,
                  Score<?> constraintWeight,
                  ToIntQuadFunction<A,B,C,D> matchWeigher)

As defined by reward(String, Score, ToIntQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

rewardLong

default Constraint rewardLong(String constraintName,
                              Score<?> constraintWeight,
                              ToLongQuadFunction<A,B,C,D> matchWeigher)

Positively impact the Score: add the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.reward(String, Score).

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

rewardLong

Constraint rewardLong(String constraintPackage,
                      String constraintName,
                      Score<?> constraintWeight,
                      ToLongQuadFunction<A,B,C,D> matchWeigher)

As defined by rewardLong(String, Score, ToLongQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

rewardBigDecimal

default Constraint rewardBigDecimal(String constraintName,
                                    Score<?> constraintWeight,
                                    QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

Positively impact the Score: add the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.reward(String, Score).

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

rewardBigDecimal

Constraint rewardBigDecimal(String constraintPackage,
                            String constraintName,
                            Score<?> constraintWeight,
                            QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

As defined by rewardBigDecimal(String, Score, QuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

rewardConfigurable

default Constraint rewardConfigurable(String constraintName,
                                      ToIntQuadFunction<A,B,C,D> matchWeigher)

Positively impact the Score: add the ConstraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.rewardConfigurable(String).

For non-int Score types use rewardConfigurableLong(String, ToLongQuadFunction) or rewardConfigurableBigDecimal(String, QuadFunction) instead.

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

rewardConfigurable

Constraint rewardConfigurable(String constraintPackage,
                              String constraintName,
                              ToIntQuadFunction<A,B,C,D> matchWeigher)

As defined by rewardConfigurable(String, ToIntQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null

rewardConfigurableLong

default Constraint rewardConfigurableLong(String constraintName,
                                          ToLongQuadFunction<A,B,C,D> matchWeigher)

Positively impact the Score: add the ConstraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.rewardConfigurable(String).

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

rewardConfigurableLong

Constraint rewardConfigurableLong(String constraintPackage,
                                  String constraintName,
                                  ToLongQuadFunction<A,B,C,D> matchWeigher)

As defined by rewardConfigurableLong(String, ToLongQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null

rewardConfigurableBigDecimal

default Constraint rewardConfigurableBigDecimal(String constraintName,
                                                QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

Positively impact the Score: add the ConstraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.rewardConfigurable(String).

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

rewardConfigurableBigDecimal

Constraint rewardConfigurableBigDecimal(String constraintPackage,
                                        String constraintName,
                                        QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

As defined by rewardConfigurableBigDecimal(String, QuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null

impact

default Constraint impact(String constraintName,
                          Score<?> constraintWeight,
                          ToIntQuadFunction<A,B,C,D> matchWeigher)

Positively or negatively impact the Score by the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.impact(String, Score).

Use penalize(...) or reward(...) instead, unless this constraint can both have positive and negative weights.

For non-int Score types use impactLong(String, Score, ToLongQuadFunction) or impactBigDecimal(String, Score, QuadFunction) instead.

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

impact

Constraint impact(String constraintPackage,
                  String constraintName,
                  Score<?> constraintWeight,
                  ToIntQuadFunction<A,B,C,D> matchWeigher)

As defined by impact(String, Score, ToIntQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

impactLong

default Constraint impactLong(String constraintName,
                              Score<?> constraintWeight,
                              ToLongQuadFunction<A,B,C,D> matchWeigher)

Positively or negatively impact the Score by the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.impact(String, Score).

Use penalizeLong(...) or rewardLong(...) instead, unless this constraint can both have positive and negative weights.

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

impactLong

Constraint impactLong(String constraintPackage,
                      String constraintName,
                      Score<?> constraintWeight,
                      ToLongQuadFunction<A,B,C,D> matchWeigher)

As defined by impactLong(String, Score, ToLongQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

impactBigDecimal

default Constraint impactBigDecimal(String constraintName,
                                    Score<?> constraintWeight,
                                    QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

Positively or negatively impact the Score by the constraintWeight multiplied by the match weight. Otherwise as defined by ConstraintStream.impact(String, Score).

Use penalizeBigDecimal(...) or rewardBigDecimal(...) instead, unless this constraint can both have positive and negative weights.

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

constraintWeight - never null

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

impactBigDecimal

Constraint impactBigDecimal(String constraintPackage,
                            String constraintName,
                            Score<?> constraintWeight,
                            QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

As defined by impactBigDecimal(String, Score, QuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

constraintWeight - never null

matchWeigher - never null

Returns:

never null

impactConfigurable

default Constraint impactConfigurable(String constraintName,
                                      ToIntQuadFunction<A,B,C,D> matchWeigher)

Positively or negatively impact the Score by the ConstraintWeight for each match.

Use penalizeConfigurable(...) or rewardConfigurable(...) instead, unless this constraint can both have positive and negative weights.

For non-int Score types use impactConfigurableLong(String, ToLongQuadFunction) or impactConfigurableBigDecimal(String, QuadFunction) instead.

The constraintWeight comes from an ConstraintWeight annotated member on the ConstraintConfiguration, so end users can change the constraint weights dynamically. This constraint may be deactivated if the ConstraintWeight is zero. If there is no ConstraintConfiguration, use ConstraintStream.impact(String, Score) instead.

The Constraint.getConstraintPackage() defaults to ConstraintConfiguration.constraintPackage().

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

impactConfigurable

Constraint impactConfigurable(String constraintPackage,
                              String constraintName,
                              ToIntQuadFunction<A,B,C,D> matchWeigher)

As defined by impactConfigurable(String, ToIntQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null

impactConfigurableLong

default Constraint impactConfigurableLong(String constraintName,
                                          ToLongQuadFunction<A,B,C,D> matchWeigher)

Positively or negatively impact the Score by the ConstraintWeight for each match.

Use penalizeConfigurableLong(...) or rewardConfigurableLong(...) instead, unless this constraint can both have positive and negative weights.

The constraintWeight comes from an ConstraintWeight annotated member on the ConstraintConfiguration, so end users can change the constraint weights dynamically. This constraint may be deactivated if the ConstraintWeight is zero. If there is no ConstraintConfiguration, use ConstraintStream.impact(String, Score) instead.

The Constraint.getConstraintPackage() defaults to ConstraintConfiguration.constraintPackage().

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

impactConfigurableLong

Constraint impactConfigurableLong(String constraintPackage,
                                  String constraintName,
                                  ToLongQuadFunction<A,B,C,D> matchWeigher)

As defined by impactConfigurableLong(String, ToLongQuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null

impactConfigurableBigDecimal

default Constraint impactConfigurableBigDecimal(String constraintName,
                                                QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

Positively or negatively impact the Score by the ConstraintWeight for each match.

Use penalizeConfigurableBigDecimal(...) or rewardConfigurableBigDecimal(...) instead, unless this constraint can both have positive and negative weights.

The constraintWeight comes from an ConstraintWeight annotated member on the ConstraintConfiguration, so end users can change the constraint weights dynamically. This constraint may be deactivated if the ConstraintWeight is zero. If there is no ConstraintConfiguration, use ConstraintStream.impact(String, Score) instead.

The Constraint.getConstraintPackage() defaults to ConstraintConfiguration.constraintPackage().

Parameters:

constraintName - never null, shows up in ConstraintMatchTotal during score justification

matchWeigher - never null, the result of this function (matchWeight) is multiplied by the constraintWeight

Returns:

never null

impactConfigurableBigDecimal

Constraint impactConfigurableBigDecimal(String constraintPackage,
                                        String constraintName,
                                        QuadFunction<A,B,C,D,BigDecimal> matchWeigher)

As defined by impactConfigurableBigDecimal(String, QuadFunction).

Parameters:

constraintPackage - never null

constraintName - never null

matchWeigher - never null

Returns:

never null