Package ai.timefold.solver.core.impl.score.stream.bavet.uni

Class BavetAbstractUniConstraintStream<Solution_,A>

java.lang.Object

ai.timefold.solver.core.impl.score.stream.common.AbstractConstraintStream<Solution_>

ai.timefold.solver.core.impl.score.stream.bavet.common.BavetAbstractConstraintStream<Solution_>

ai.timefold.solver.core.impl.score.stream.bavet.uni.BavetAbstractUniConstraintStream<Solution_,A>

All Implemented Interfaces:

ConstraintStream, UniConstraintStream<A>, InnerUniConstraintStream<A>

Direct Known Subclasses:

BavetAftBridgeUniConstraintStream, BavetForEachUniConstraintStream, BavetForeBridgeUniConstraintStream, BavetUniConcatUniConstraintStream

public abstract class BavetAbstractUniConstraintStream<Solution_,A>
extends BavetAbstractConstraintStream<Solution_>
implements InnerUniConstraintStream<A>

Field Summary

Fields inherited from class ai.timefold.solver.core.impl.score.stream.bavet.common.BavetAbstractConstraintStream

childStreamList, constraintFactory, parent

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory, BavetAbstractConstraintStream<Solution_> parent)
protected	BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory, RetrievalSemantics retrievalSemantics)

Method Summary

Modifier and Type	Method	Description
<B> BiConstraintStream<A,B>	concat(BiConstraintStream<A,B> otherStream, Function<A,B> paddingFunction)	Returns a new BiConstraintStream containing all the tuples of both this UniConstraintStream and the provided BiConstraintStream.
<B, C, D> QuadConstraintStream<A,B,C,D>	concat(QuadConstraintStream<A,B,C,D> otherStream, Function<A,B> paddingFunctionB, Function<A,C> paddingFunctionC, Function<A,D> paddingFunctionD)	Returns a new QuadConstraintStream containing all the tuples of both this UniConstraintStream and the provided QuadConstraintStream.
<B, C> TriConstraintStream<A,B,C>	concat(TriConstraintStream<A,B,C> otherStream, Function<A,B> paddingFunctionB, Function<A,C> paddingFunctionC)	Returns a new TriConstraintStream containing all the tuples of both this UniConstraintStream and the provided TriConstraintStream.
UniConstraintStream<A>	concat(UniConstraintStream<A> otherStream)	Returns a new UniConstraintStream containing all the tuples of both this UniConstraintStream and the provided UniConstraintStream.
UniConstraintStream<A>	distinct()	Transforms the stream in such a way that all the tuples going through it are distinct.
<ResultB_> BiConstraintStream<A,ResultB_>	expand(Function<A,ResultB_> mapping)	Adds a fact to the end of the tuple, increasing the cardinality of the stream.
<ResultB_, ResultC_> TriConstraintStream<A,ResultB_,ResultC_>	expand(Function<A,ResultB_> mappingB, Function<A,ResultC_> mappingC)	Adds two facts to the end of the tuple, increasing the cardinality of the stream.
<ResultB_, ResultC_, ResultD_> QuadConstraintStream<A,ResultB_,ResultC_,ResultD_>	expand(Function<A,ResultB_> mappingB, Function<A,ResultC_> mappingC, Function<A,ResultD_> mappingD)	Adds three facts to the end of the tuple, increasing the cardinality of the stream.
BavetAbstractUniConstraintStream<Solution_,A>	filter(Predicate<A> predicate)	Exhaustively test each fact against the Predicate and match if Predicate.test(Object) returns true.
<ResultA_> UniConstraintStream<ResultA_>	flattenLast(Function<A,Iterable<ResultA_>> mapping)	Takes each tuple and applies a mapping on it, which turns the tuple into a Iterable.
protected final Function<A,Collection<?>>	getDefaultIndictedObjectsMapping()
protected final BiFunction<A,Score<?>,DefaultConstraintJustification>	getDefaultJustificationMapping()
<ResultContainer_, Result_> UniConstraintStream<Result_>	groupBy(UniConstraintCollector<A,ResultContainer_,Result_> collector)	Convert the UniConstraintStream to a different UniConstraintStream, containing only a single tuple, the result of applying UniConstraintCollector.
<ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_,ResultB_>	groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA, UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB)	Convert the UniConstraintStream to a BiConstraintStream, containing only a single tuple, the result of applying two UniConstraintCollectors.
<ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_> TriConstraintStream<ResultA_,ResultB_,ResultC_>	groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA, UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB, UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC)	Convert the UniConstraintStream to a TriConstraintStream, containing only a single tuple, the result of applying three UniConstraintCollectors.
<ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_> QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_>	groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA, UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB, UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC, UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)	Convert the UniConstraintStream to a QuadConstraintStream, containing only a single tuple, the result of applying four UniConstraintCollectors.
<GroupKey_> UniConstraintStream<GroupKey_>	groupBy(Function<A,GroupKey_> groupKeyMapping)	Convert the UniConstraintStream to a different 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(Function<A,GroupKey_> groupKeyMapping, UniConstraintCollector<A,ResultContainer_,Result_> collector)	Convert the UniConstraintStream to a BiConstraintStream, consisting of unique tuples with two facts.
<GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_> TriConstraintStream<GroupKey_,ResultB_,ResultC_>	groupBy(Function<A,GroupKey_> groupKeyMapping, UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB, UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC)	Convert the UniConstraintStream to a TriConstraintStream, consisting of unique tuples with three facts.
<GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_> QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_>	groupBy(Function<A,GroupKey_> groupKeyMapping, UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB, UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC, UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)	Convert the UniConstraintStream to a QuadConstraintStream, consisting of unique tuples with four facts.
<GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_,GroupKeyB_>	groupBy(Function<A,GroupKeyA_> groupKeyAMapping, Function<A,GroupKeyB_> groupKeyBMapping)	Convert the UniConstraintStream to a BiConstraintStream, consisting of unique tuples with two facts.
<GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_>	groupBy(Function<A,GroupKeyA_> groupKeyAMapping, Function<A,GroupKeyB_> groupKeyBMapping, UniConstraintCollector<A,ResultContainer_,Result_> collector)	Combines the semantics of UniConstraintStream.groupBy(Function, Function) and UniConstraintStream.groupBy(UniConstraintCollector).
<GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_>	groupBy(Function<A,GroupKeyA_> groupKeyAMapping, Function<A,GroupKeyB_> groupKeyBMapping, UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC, UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)	Combines the semantics of UniConstraintStream.groupBy(Function, Function) and UniConstraintStream.groupBy(UniConstraintCollector).
<GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_>	groupBy(Function<A,GroupKeyA_> groupKeyAMapping, Function<A,GroupKeyB_> groupKeyBMapping, Function<A,GroupKeyC_> groupKeyCMapping)	Convert the UniConstraintStream to a TriConstraintStream, consisting of unique tuples with three facts.
<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_>	groupBy(Function<A,GroupKeyA_> groupKeyAMapping, Function<A,GroupKeyB_> groupKeyBMapping, Function<A,GroupKeyC_> groupKeyCMapping, UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)	Combines the semantics of UniConstraintStream.groupBy(Function, Function) and UniConstraintStream.groupBy(UniConstraintCollector).
<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_>	groupBy(Function<A,GroupKeyA_> groupKeyAMapping, Function<A,GroupKeyB_> groupKeyBMapping, Function<A,GroupKeyC_> groupKeyCMapping, Function<A,GroupKeyD_> groupKeyDMapping)	Convert the UniConstraintStream to a QuadConstraintStream, consisting of unique tuples with four facts.
final <B> UniConstraintStream<A>	ifExists(UniConstraintStream<B> otherStream, BiJoiner<A,B>... joiners)	As defined by UniConstraintStream.ifExists(UniConstraintStream, BiJoiner).
final <B> UniConstraintStream<A>	ifNotExists(UniConstraintStream<B> otherStream, BiJoiner<A,B>... joiners)	As defined by UniConstraintStream.ifNotExists(UniConstraintStream, BiJoiner).
<Score_ extends Score<Score_>> UniConstraintBuilder<A,Score_>	innerImpact(Score_ constraintWeight, Function<A,BigDecimal> matchWeigher, ScoreImpactType scoreImpactType)
<Score_ extends Score<Score_>> UniConstraintBuilder<A,Score_>	innerImpact(Score_ constraintWeight, ToIntFunction<A> matchWeigher, ScoreImpactType scoreImpactType)
<Score_ extends Score<Score_>> UniConstraintBuilder<A,Score_>	innerImpact(Score_ constraintWeight, ToLongFunction<A> matchWeigher, ScoreImpactType scoreImpactType)
final <B> BiConstraintStream<A,B>	join(UniConstraintStream<B> otherStream, BiJoiner<A,B>... joiners)	As defined by UniConstraintStream.join(UniConstraintStream, BiJoiner).
final <B> BiConstraintStream<A,B>	join(UniConstraintStream<B> otherStream, BiJoinerComber<A,B> joinerComber)	Allows ConstraintFactory.forEachUniquePair(Class) to reuse the joiner combing logic.
<ResultA_> UniConstraintStream<ResultA_>	map(Function<A,ResultA_> mapping)	Transforms the stream in such a way that tuples are remapped using the given function.
<ResultA_, ResultB_> BiConstraintStream<ResultA_,ResultB_>	map(Function<A,ResultA_> mappingA, Function<A,ResultB_> mappingB)	As defined by UniConstraintStream.map(Function), only resulting in BiConstraintStream.
<ResultA_, ResultB_, ResultC_> TriConstraintStream<ResultA_,ResultB_,ResultC_>	map(Function<A,ResultA_> mappingA, Function<A,ResultB_> mappingB, Function<A,ResultC_> mappingC)	As defined by UniConstraintStream.map(Function), only resulting in TriConstraintStream.
<ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_>	map(Function<A,ResultA_> mappingA, Function<A,ResultB_> mappingB, Function<A,ResultC_> mappingC, Function<A,ResultD_> mappingD)	As defined by UniConstraintStream.map(Function), only resulting in QuadConstraintStream.

Methods inherited from class ai.timefold.solver.core.impl.score.stream.bavet.common.BavetAbstractConstraintStream

assertEmptyChildStreamList, buildConstraint, buildNode, collectActiveConstraintStreams, getChildStreamList, getConstraintFactory, getParent, getTupleSource, guaranteesDistinct, shareAndAddChild

Methods inherited from class ai.timefold.solver.core.impl.score.stream.common.AbstractConstraintStream

getRetrievalSemantics

Methods inherited from class java.lang.Object

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

Methods inherited from interface ai.timefold.solver.core.api.score.stream.ConstraintStream

getConstraintFactory

Methods inherited from interface ai.timefold.solver.core.impl.score.stream.common.uni.InnerUniConstraintStream

getRetrievalSemantics, guaranteesDistinct, ifExists, ifExistsIncludingUnassigned, ifNotExists, ifNotExistsIncludingUnassigned, impact, impact, impact, impactBigDecimal, impactConfigurable, impactConfigurableBigDecimal, impactConfigurableLong, impactLong, join, penalize, penalize, penalize, penalizeBigDecimal, penalizeConfigurable, penalizeConfigurable, penalizeConfigurable, penalizeConfigurableBigDecimal, penalizeConfigurableLong, penalizeLong, reward, reward, reward, rewardBigDecimal, rewardConfigurable, rewardConfigurable, rewardConfigurable, rewardConfigurableBigDecimal, rewardConfigurableLong, rewardLong

Methods inherited from interface ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream

complement, concat, concat, concat, ifExists, ifExists, ifExists, ifExists, ifExists, ifExists, ifExists, ifExists, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifExistsIncludingUnassigned, ifExistsIncludingUnassigned, ifExistsIncludingUnassigned, ifExistsIncludingUnassigned, ifExistsOther, ifExistsOther, ifExistsOther, ifExistsOther, ifExistsOther, ifExistsOther, ifExistsOtherIncludingNullVars, ifExistsOtherIncludingNullVars, ifExistsOtherIncludingNullVars, ifExistsOtherIncludingNullVars, ifExistsOtherIncludingNullVars, ifExistsOtherIncludingNullVars, ifExistsOtherIncludingUnassigned, ifExistsOtherIncludingUnassigned, ifExistsOtherIncludingUnassigned, ifExistsOtherIncludingUnassigned, ifExistsOtherIncludingUnassigned, ifExistsOtherIncludingUnassigned, ifNotExists, ifNotExists, ifNotExists, ifNotExists, ifNotExists, ifNotExists, ifNotExists, ifNotExists, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, ifNotExistsIncludingUnassigned, ifNotExistsIncludingUnassigned, ifNotExistsIncludingUnassigned, ifNotExistsIncludingUnassigned, ifNotExistsOther, ifNotExistsOther, ifNotExistsOther, ifNotExistsOther, ifNotExistsOther, ifNotExistsOther, ifNotExistsOtherIncludingNullVars, ifNotExistsOtherIncludingNullVars, ifNotExistsOtherIncludingNullVars, ifNotExistsOtherIncludingNullVars, ifNotExistsOtherIncludingNullVars, ifNotExistsOtherIncludingNullVars, ifNotExistsOtherIncludingUnassigned, ifNotExistsOtherIncludingUnassigned, ifNotExistsOtherIncludingUnassigned, ifNotExistsOtherIncludingUnassigned, ifNotExistsOtherIncludingUnassigned, ifNotExistsOtherIncludingUnassigned, impact, impact, impact, impactBigDecimal, impactBigDecimal, impactConfigurable, impactConfigurable, impactConfigurable, impactConfigurableBigDecimal, impactConfigurableBigDecimal, impactConfigurableLong, impactConfigurableLong, impactLong, impactLong, join, join, join, join, join, join, join, join, join, join, penalize, penalize, penalize, penalizeBigDecimal, penalizeBigDecimal, penalizeBigDecimal, penalizeConfigurable, penalizeConfigurable, penalizeConfigurable, penalizeConfigurableBigDecimal, penalizeConfigurableBigDecimal, penalizeConfigurableLong, penalizeConfigurableLong, penalizeLong, penalizeLong, penalizeLong, reward, reward, reward, rewardBigDecimal, rewardBigDecimal, rewardConfigurable, rewardConfigurable, rewardConfigurable, rewardConfigurableBigDecimal, rewardConfigurableBigDecimal, rewardConfigurableLong, rewardConfigurableLong, rewardLong, rewardLong

Constructor Details

BavetAbstractUniConstraintStream

protected BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
 BavetAbstractConstraintStream<Solution_> parent)

BavetAbstractUniConstraintStream

protected BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
 RetrievalSemantics retrievalSemantics)

Method Details

filter

public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A> predicate)

Description copied from interface: UniConstraintStream

Exhaustively test each fact against the Predicate and match if Predicate.test(Object) returns true.

Specified by:

filter in interface UniConstraintStream<Solution_>

Parameters:

predicate - never null

Returns:

never null

join

@SafeVarargs
public final <B> BiConstraintStream<A,B> join(UniConstraintStream<B> otherStream,
 BiJoiner<A,B>... joiners)

Description copied from interface: UniConstraintStream

As defined by UniConstraintStream.join(UniConstraintStream, BiJoiner). If multiple BiJoiners are provided, for performance reasons, the 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 BiJoiner parameters.

Specified by:

join in interface UniConstraintStream<Solution_>

Type Parameters:

B - the type of the second matched fact

Parameters:

otherStream - never null

joiners - never null

Returns:

never null, a stream that matches every combination of A and B for which all the joiners are true

join

public final <B> BiConstraintStream<A,B> join(UniConstraintStream<B> otherStream,
 BiJoinerComber<A,B> joinerComber)

Description copied from interface: InnerUniConstraintStream

Allows ConstraintFactory.forEachUniquePair(Class) to reuse the joiner combing logic.

Specified by:

join in interface InnerUniConstraintStream<Solution_>

Parameters:

otherStream - never null

joinerComber - never null

Returns:

never null

ifExists

@SafeVarargs
public final <B> UniConstraintStream<A> ifExists(UniConstraintStream<B> otherStream,
 BiJoiner<A,B>... joiners)

Description copied from interface: UniConstraintStream

As defined by UniConstraintStream.ifExists(UniConstraintStream, BiJoiner). 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 BiJoiner parameters.

Specified by:

ifExists in interface UniConstraintStream<Solution_>

Type Parameters:

B - the type of the second matched fact

Parameters:

otherStream - never null

joiners - never null

Returns:

never null, a stream that matches every A where B exists for which all the BiJoiners are true

ifNotExists

@SafeVarargs
public final <B> UniConstraintStream<A> ifNotExists(UniConstraintStream<B> otherStream,
 BiJoiner<A,B>... joiners)

Description copied from interface: UniConstraintStream

As defined by UniConstraintStream.ifNotExists(UniConstraintStream, BiJoiner). 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 BiJoiner parameters.

Specified by:

ifNotExists in interface UniConstraintStream<Solution_>

Type Parameters:

B - the type of the second matched fact

Parameters:

otherStream - never null

joiners - never null

Returns:

never null, a stream that matches every A where B does not exist for which all the BiJoiners are true

groupBy

public <ResultContainer_,
Result_>
UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_> collector)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a different UniConstraintStream, containing only a single tuple, the result of applying UniConstraintCollector.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

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

public <ResultContainerA_,
ResultA_,
ResultContainerB_,
ResultB_>
BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA,
 UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a BiConstraintStream, containing only a single tuple, the result of applying two UniConstraintCollectors.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

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

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

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

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

Parameters:

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

collectorB - 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

groupBy

public <ResultContainerA_,
ResultA_,
ResultContainerB_,
ResultB_,
ResultContainerC_,
ResultC_>
TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA,
 UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB,
 UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a TriConstraintStream, containing only a single tuple, the result of applying three UniConstraintCollectors.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

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

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

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

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

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

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

Parameters:

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

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

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

Returns:

never null

groupBy

public <ResultContainerA_,
ResultA_,
ResultContainerB_,
ResultB_,
ResultContainerC_,
ResultC_,
ResultContainerD_,
ResultD_>
QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA,
 UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB,
 UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC,
 UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a QuadConstraintStream, containing only a single tuple, the result of applying four UniConstraintCollectors.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

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

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

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

ResultB_ - 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:

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

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

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

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

Returns:

never null

groupBy

public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_> groupKeyMapping)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a different 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.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKey_ - the type of a fact in the destination UniConstraintStream's tuple; must honor the general contract of hashCode.

Parameters:

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

Returns:

never null

groupBy

public <GroupKey_,
ResultContainerB_,
ResultB_,
ResultContainerC_,
ResultC_>
TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_> groupKeyMapping,
 UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB,
 UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a TriConstraintStream, consisting of unique tuples with three facts.

The first fact is the return value of the group key mapping function, applied on the incoming tuple. The remaining facts are the return value of the respective UniConstraintCollector applied on all incoming tuples with the same first fact.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKey_ - the type of the first fact in the destination TriConstraintStream's tuple; must honor the general contract of hashCode.

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

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

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

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

Parameters:

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

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

collectorC - 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

groupBy

public <GroupKey_,
ResultContainerB_,
ResultB_,
ResultContainerC_,
ResultC_,
ResultContainerD_,
ResultD_>
QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_> groupKeyMapping,
 UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB,
 UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC,
 UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a QuadConstraintStream, consisting of unique tuples with four facts.

The first fact is the return value of the group key mapping function, applied on the incoming tuple. The remaining facts are the return value of the respective UniConstraintCollector applied on all incoming tuples with the same first fact.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKey_ - the type of the first fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

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

ResultB_ - 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:

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

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

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

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

Returns:

never null

groupBy

public <GroupKey_,
ResultContainer_,
Result_>
BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_> groupKeyMapping,
 UniConstraintCollector<A,ResultContainer_,Result_> collector)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a BiConstraintStream, consisting of unique tuples with two facts.

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

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKey_ - the type of the first fact in the destination BiConstraintStream's tuple; must honor the general contract of hashCode.

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

public <GroupKeyA_,
GroupKeyB_>
BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_> groupKeyAMapping,
 Function<A,GroupKeyB_> groupKeyBMapping)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a BiConstraintStream, consisting of unique tuples with two facts.

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.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination BiConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyB_ - the type of the second fact in the destination BiConstraintStream's tuple; must honor the general contract of hashCode.

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

Returns:

never null

groupBy

public <GroupKeyA_,
GroupKeyB_,
ResultContainer_,
Result_>
TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_> groupKeyAMapping,
 Function<A,GroupKeyB_> groupKeyBMapping,
 UniConstraintCollector<A,ResultContainer_,Result_> collector)

Description copied from interface: UniConstraintStream

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

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination TriConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyB_ - the type of the second fact in the destination TriConstraintStream's tuple; must honor the general contract of hashCode.

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

public <GroupKeyA_,
GroupKeyB_,
ResultContainerC_,
ResultC_,
ResultContainerD_,
ResultD_>
QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_> groupKeyAMapping,
 Function<A,GroupKeyB_> groupKeyBMapping,
 UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC,
 UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)

Description copied from interface: UniConstraintStream

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

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyB_ - the type of the second fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

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

groupBy

public <GroupKeyA_,
GroupKeyB_,
GroupKeyC_>
TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_> groupKeyAMapping,
 Function<A,GroupKeyB_> groupKeyBMapping,
 Function<A,GroupKeyC_> groupKeyCMapping)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a TriConstraintStream, consisting of unique tuples with three facts.

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. The third fact is the return value of the third group key mapping function, applied on all incoming tuples with the same first fact.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination TriConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyB_ - the type of the second fact in the destination TriConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyC_ - the type of the third fact in the destination TriConstraintStream's tuple; must honor the general contract of hashCode.

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

groupKeyCMapping - never null, function to convert the original tuple into a third fact

Returns:

never null

groupBy

public <GroupKeyA_,
GroupKeyB_,
GroupKeyC_,
ResultContainerD_,
ResultD_>
QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_> groupKeyAMapping,
 Function<A,GroupKeyB_> groupKeyBMapping,
 Function<A,GroupKeyC_> groupKeyCMapping,
 UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)

Description copied from interface: UniConstraintStream

Combines the semantics of UniConstraintStream.groupBy(Function, Function) and UniConstraintStream.groupBy(UniConstraintCollector). That is, the first three facts in the tuple follow the UniConstraintStream.groupBy(Function, Function) semantics. The final fact is the result of applying the first UniConstraintCollector.finisher() on all the tuples of the original UniConstraintStream that belong to the group.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyB_ - the type of the second fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyC_ - the type of the third fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

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

groupKeyCMapping - never null, function to convert the original tuple into a third fact

collectorD - 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

public <GroupKeyA_,
GroupKeyB_,
GroupKeyC_,
GroupKeyD_>
QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_> groupKeyAMapping,
 Function<A,GroupKeyB_> groupKeyBMapping,
 Function<A,GroupKeyC_> groupKeyCMapping,
 Function<A,GroupKeyD_> groupKeyDMapping)

Description copied from interface: UniConstraintStream

Convert the UniConstraintStream to a QuadConstraintStream, consisting of unique tuples with four facts.

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. The third fact is the return value of the third group key mapping function, applied on all incoming tuples with the same first fact. The fourth fact is the return value of the fourth group key mapping function, applied on all incoming tuples with the same first fact.

Specified by:

groupBy in interface UniConstraintStream<Solution_>

Type Parameters:

GroupKeyA_ - the type of the first fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyB_ - the type of the second fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyC_ - the type of the third fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

GroupKeyD_ - the type of the fourth fact in the destination QuadConstraintStream's tuple; must honor the general contract of hashCode.

Parameters:

groupKeyAMapping - * calling map(Person::getAge) on such stream will produce a stream of Integers * [20, 25, 30],

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

groupKeyCMapping - never null, function to convert the original tuple into a third fact

groupKeyDMapping - never null, function to convert the original tuple into a fourth fact

Returns:

never null

distinct

public UniConstraintStream<A> distinct()

Description copied from interface: UniConstraintStream

Transforms the stream in such a way that all the tuples going through it are distinct. (No two tuples will equal.)

By default, tuples going through a constraint stream are distinct. However, operations such as UniConstraintStream.map(Function) may create a stream which breaks that promise. By calling this method on such a stream, duplicate copies of the same tuple will be omitted at a performance cost.

Specified by:

distinct in interface InnerUniConstraintStream<Solution_>

Specified by:

distinct in interface UniConstraintStream<Solution_>

Returns:

never null

concat

public UniConstraintStream<A> concat(UniConstraintStream<A> otherStream)

Description copied from interface: UniConstraintStream

Returns a new UniConstraintStream containing all the tuples of both this UniConstraintStream and the provided UniConstraintStream. Tuples in both this UniConstraintStream and the provided UniConstraintStream will appear at least twice.

For instance, if this stream consists of [A, B, C] and the other stream consists of [C, D, E], this.concat(other) will consist of [A, B, C, C, D, E]. This operation can be thought of as an or between streams.

Specified by:

concat in interface UniConstraintStream<Solution_>

Parameters:

otherStream - never null

Returns:

never null

concat

public <B> BiConstraintStream<A,B> concat(BiConstraintStream<A,B> otherStream,
 Function<A,B> paddingFunction)

Description copied from interface: UniConstraintStream

Returns a new BiConstraintStream containing all the tuples of both this UniConstraintStream and the provided BiConstraintStream. The UniConstraintStream tuples will be padded from the right by the result of the padding function.

For instance, if this stream consists of [A, B, C] and the other stream consists of [(C1, C2), (D1, D2), (E1, E2)], this.concat(other, a -> null) will consist of [(A, null), (B, null), (C, null), (C1, C2), (D1, D2), (E1, E2)].

This operation can be thought of as an or between streams.

Specified by:

concat in interface UniConstraintStream<Solution_>

Parameters:

otherStream - never null

paddingFunction - never null, function to find the padding for the second fact

Returns:

never null

concat

public <B,
C> TriConstraintStream<A,B,C> concat(TriConstraintStream<A,B,C> otherStream,
 Function<A,B> paddingFunctionB,
 Function<A,C> paddingFunctionC)

Description copied from interface: UniConstraintStream

Returns a new TriConstraintStream containing all the tuples of both this UniConstraintStream and the provided TriConstraintStream. The UniConstraintStream tuples will be padded from the right by the result of the padding functions.

For instance, if this stream consists of [A, B, C] and the other stream consists of [(C1, C2, C3), (D1, D2, D3), (E1, E2, E3)], this.concat(other, a -> null, a -> null) will consist of [(A, null), (B, null), (C, null), (C1, C2, C3), (D1, D2, D3), (E1, E2, E3)].

This operation can be thought of as an or between streams.

Specified by:

concat in interface UniConstraintStream<Solution_>

Parameters:

otherStream - never null

paddingFunctionB - never null, function to find the padding for the second fact

paddingFunctionC - never null, function to find the padding for the third fact

Returns:

never null

concat

public <B,
C,
D> QuadConstraintStream<A,B,C,D> concat(QuadConstraintStream<A,B,C,D> otherStream,
 Function<A,B> paddingFunctionB,
 Function<A,C> paddingFunctionC,
 Function<A,D> paddingFunctionD)

Description copied from interface: UniConstraintStream

Returns a new QuadConstraintStream containing all the tuples of both this UniConstraintStream and the provided QuadConstraintStream. The UniConstraintStream tuples will be padded from the right by the result of the padding functions.

For instance, if this stream consists of [A, B, C] and the other stream consists of [(C1, C2, C3, C4), (D1, D2, D3, D4), (E1, E2, E3, E4)], this.concat(other, a -> null, a -> null, a -> null) will consist of [(A, null), (B, null), (C, null), (C1, C2, C3, C4), (D1, D2, D3, D4), (E1, E2, E3, E4)].

This operation can be thought of as an or between streams.

Specified by:

concat in interface UniConstraintStream<Solution_>

Parameters:

otherStream - never null

paddingFunctionB - never null, function to find the padding for the second fact

paddingFunctionC - never null, function to find the padding for the third fact

paddingFunctionD - never null, function to find the padding for the fourth fact

Returns:

never null

map

public <ResultA_> UniConstraintStream<ResultA_> map(Function<A,ResultA_> mapping)

Description copied from interface: UniConstraintStream

Transforms the stream in such a way that tuples are remapped using the given function. This may produce a stream with duplicate tuples. See UniConstraintStream.distinct() for details.

There are several recommendations for implementing the mapping function:

• Purity. The mapping function should only depend on its input. That is, given the same input, it always returns the same output.
• Bijectivity. No two input tuples should map to the same output tuple, or to tuples that are equal. Not following this recommendation creates a constraint stream with duplicate tuples, and may force you to use UniConstraintStream.distinct() later, which comes at a performance cost.
• Immutable data carriers. The objects returned by the mapping function should be identified by their contents and nothing else. If two of them have contents which equal, then they should likewise equal and preferably be the same instance. The objects returned by the mapping function should also be immutable, meaning their contents should not be allowed to change.

Simple example: assuming a constraint stream of tuples of Persons [Ann(age = 20), Beth(age = 25), Cathy(age = 30)], calling map(Person::getAge) on such stream will produce a stream of Integers [20, 25, 30],

Example with a non-bijective mapping function: assuming a constraint stream of tuples of Persons [Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)], calling map(Person::getAge) on such stream will produce a stream of Integers [20, 25, 30, 30, 20].

Use with caution, as the increased memory allocation rates coming from tuple creation may negatively affect performance.

Specified by:

map in interface UniConstraintStream<Solution_>

Type Parameters:

ResultA_ - the type of the only fact in the resulting UniConstraintStream's tuple

Parameters:

mapping - never null, function to convert the original tuple into the new tuple

Returns:

never null

map

public <ResultA_,
ResultB_>
BiConstraintStream<ResultA_,ResultB_> map(Function<A,ResultA_> mappingA,
 Function<A,ResultB_> mappingB)

Description copied from interface: UniConstraintStream

As defined by UniConstraintStream.map(Function), only resulting in BiConstraintStream.

Specified by:

map in interface UniConstraintStream<Solution_>

Type Parameters:

ResultA_ - the type of the first fact in the resulting BiConstraintStream's tuple

ResultB_ - the type of the first fact in the resulting BiConstraintStream's tuple

Parameters:

mappingA - never null, function to convert the original tuple into the first fact of a new tuple

mappingB - never null, function to convert the original tuple into the second fact of a new tuple

Returns:

never null

map

public <ResultA_,
ResultB_,
ResultC_>
TriConstraintStream<ResultA_,ResultB_,ResultC_> map(Function<A,ResultA_> mappingA,
 Function<A,ResultB_> mappingB,
 Function<A,ResultC_> mappingC)

Description copied from interface: UniConstraintStream

As defined by UniConstraintStream.map(Function), only resulting in TriConstraintStream.

Specified by:

map in interface UniConstraintStream<Solution_>

Type Parameters:

ResultA_ - the type of the first fact in the resulting TriConstraintStream's tuple

ResultB_ - the type of the first fact in the resulting TriConstraintStream's tuple

ResultC_ - the type of the third fact in the resulting TriConstraintStream's tuple

Parameters:

mappingA - never null, function to convert the original tuple into the first fact of a new tuple

mappingB - never null, function to convert the original tuple into the second fact of a new tuple

mappingC - never null, function to convert the original tuple into the third fact of a new tuple

Returns:

never null

map

public <ResultA_,
ResultB_,
ResultC_,
ResultD_>
QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> map(Function<A,ResultA_> mappingA,
 Function<A,ResultB_> mappingB,
 Function<A,ResultC_> mappingC,
 Function<A,ResultD_> mappingD)

Description copied from interface: UniConstraintStream

As defined by UniConstraintStream.map(Function), only resulting in QuadConstraintStream.

Specified by:

map in interface UniConstraintStream<Solution_>

Type Parameters:

ResultA_ - the type of the first fact in the resulting QuadConstraintStream's tuple

ResultB_ - the type of the first fact in the resulting QuadConstraintStream's tuple

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

ResultD_ - the type of the third fact in the resulting QuadConstraintStream's tuple

Parameters:

mappingA - never null, function to convert the original tuple into the first fact of a new tuple

mappingB - never null, function to convert the original tuple into the second fact of a new tuple

mappingC - never null, function to convert the original tuple into the third fact of a new tuple

mappingD - never null, function to convert the original tuple into the fourth fact of a new tuple

Returns:

never null

flattenLast

public <ResultA_> UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>> mapping)

Description copied from interface: UniConstraintStream

Takes each tuple and applies a mapping on it, which turns the tuple into a Iterable. Returns a constraint stream consisting of contents of those iterables. This may produce a stream with duplicate tuples. See UniConstraintStream.distinct() for details.

In cases where the original tuple is already an Iterable, use Function.identity() as the argument.

Simple example: assuming a constraint stream of tuples of Persons [Ann(roles = [USER, ADMIN]]), Beth(roles = [USER]), Cathy(roles = [ADMIN, AUDITOR])], calling flattenLast(Person::getRoles) on such stream will produce a stream of [USER, ADMIN, USER, ADMIN, AUDITOR].

Specified by:

flattenLast in interface UniConstraintStream<Solution_>

Type Parameters:

ResultA_ - the type of facts in the resulting tuples. It is recommended that this type be deeply immutable. Not following this recommendation may lead to hard-to-debug hashing issues down the stream, especially if this value is ever used as a group key.

Parameters:

mapping - never null, function to convert the original tuple into Iterable. For performance, returning an implementation of Collection is preferred.

Returns:

never null

expand

public <ResultB_> BiConstraintStream<A,ResultB_> expand(Function<A,ResultB_> mapping)

Description copied from interface: UniConstraintStream

Adds a fact to the end of the tuple, increasing the cardinality of the stream. Useful for storing results of expensive computations on the original tuple.

Use with caution, as the benefits of caching computation may be outweighed by increased memory allocation rates coming from tuple creation. If more than one fact is to be added, prefer UniConstraintStream.expand(Function, Function) or UniConstraintStream.expand(Function, Function, Function).

Specified by:

expand in interface UniConstraintStream<Solution_>

Type Parameters:

ResultB_ - type of the final fact of the new tuple

Parameters:

mapping - function to produce the new fact from the original tuple

Returns:

never null

expand

public <ResultB_,
ResultC_>
TriConstraintStream<A,ResultB_,ResultC_> expand(Function<A,ResultB_> mappingB,
 Function<A,ResultC_> mappingC)

Description copied from interface: UniConstraintStream

Adds two facts to the end of the tuple, increasing the cardinality of the stream. Useful for storing results of expensive computations on the original tuple.

Use with caution, as the benefits of caching computation may be outweighed by increased memory allocation rates coming from tuple creation. If more than two facts are to be added, prefer UniConstraintStream.expand(Function, Function, Function).

Specified by:

expand in interface UniConstraintStream<Solution_>

Type Parameters:

ResultB_ - type of the second fact of the new tuple

ResultC_ - type of the third fact of the new tuple

Parameters:

mappingB - function to produce the new second fact from the original tuple

mappingC - function to produce the new third fact from the original tuple

Returns:

never null

expand

public <ResultB_,
ResultC_,
ResultD_>
QuadConstraintStream<A,ResultB_,ResultC_,ResultD_> expand(Function<A,ResultB_> mappingB,
 Function<A,ResultC_> mappingC,
 Function<A,ResultD_> mappingD)

Description copied from interface: UniConstraintStream

Adds three facts to the end of the tuple, increasing the cardinality of the stream. Useful for storing results of expensive computations on the original tuple.

Use with caution, as the benefits of caching computation may be outweighed by increased memory allocation rates coming from tuple creation.

Specified by:

expand in interface UniConstraintStream<Solution_>

Type Parameters:

ResultB_ - type of the second fact of the new tuple

ResultC_ - type of the third fact of the new tuple

ResultD_ - type of the final fact of the new tuple

Parameters:

mappingB - function to produce the new second fact from the original tuple

mappingC - function to produce the new third fact from the original tuple

mappingD - function to produce the new final fact from the original tuple

Returns:

never null

innerImpact

public <Score_ extends Score<Score_>>
UniConstraintBuilder<A,Score_> innerImpact(Score_ constraintWeight,
 ToIntFunction<A> matchWeigher,
 ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface InnerUniConstraintStream<Solution_>

innerImpact

public <Score_ extends Score<Score_>>
UniConstraintBuilder<A,Score_> innerImpact(Score_ constraintWeight,
 ToLongFunction<A> matchWeigher,
 ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface InnerUniConstraintStream<Solution_>

innerImpact

public <Score_ extends Score<Score_>>
UniConstraintBuilder<A,Score_> innerImpact(Score_ constraintWeight,
 Function<A,BigDecimal> matchWeigher,
 ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface InnerUniConstraintStream<Solution_>

getDefaultJustificationMapping

protected final BiFunction<A,Score<?>,DefaultConstraintJustification> getDefaultJustificationMapping()

Specified by:

getDefaultJustificationMapping in class AbstractConstraintStream<Solution_>

getDefaultIndictedObjectsMapping

protected final Function<A,Collection<?>> getDefaultIndictedObjectsMapping()

Specified by:

getDefaultIndictedObjectsMapping in class AbstractConstraintStream<Solution_>