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.bavet.common.BavetAbstractConstraintStream<Solution_>

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

All Implemented Interfaces:

ConstraintStream, UniConstraintStream<A>, BavetStream, 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.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> @NonNull BiConstraintStream<A,B>	concat(@NonNull BiConstraintStream<A,B> otherStream, @NonNull Function<A,B> paddingFunction)	Returns a new BiConstraintStream containing all the tuples of both this UniConstraintStream and the provided BiConstraintStream.
<B, C, D> @NonNull QuadConstraintStream<A,B,C,D>	concat(@NonNull QuadConstraintStream<A,B,C,D> otherStream, @NonNull Function<A,B> paddingFunctionB, @NonNull Function<A,C> paddingFunctionC, @NonNull Function<A,D> paddingFunctionD)	Returns a new QuadConstraintStream containing all the tuples of both this UniConstraintStream and the provided QuadConstraintStream.
<B, C> @NonNull TriConstraintStream<A,B,C>	concat(@NonNull TriConstraintStream<A,B,C> otherStream, @NonNull Function<A,B> paddingFunctionB, @NonNull Function<A,C> paddingFunctionC)	Returns a new TriConstraintStream containing all the tuples of both this UniConstraintStream and the provided TriConstraintStream.
@NonNull UniConstraintStream<A>	concat(@NonNull UniConstraintStream<A> otherStream)	Returns a new UniConstraintStream containing all the tuples of both this UniConstraintStream and the provided UniConstraintStream.
@NonNull UniConstraintStream<A>	distinct()	Transforms the stream in such a way that all the tuples going through it are distinct.
<ResultB_> @NonNull BiConstraintStream<A,ResultB_>	expand(@NonNull Function<A,ResultB_> mapping)	Adds a fact to the end of the tuple, increasing the cardinality of the stream.
<ResultB_, ResultC_> @NonNull TriConstraintStream<A,ResultB_,ResultC_>	expand(@NonNull Function<A,ResultB_> mappingB, @NonNull Function<A,ResultC_> mappingC)	Adds two facts to the end of the tuple, increasing the cardinality of the stream.
<ResultB_, ResultC_, ResultD_> @NonNull QuadConstraintStream<A,ResultB_,ResultC_,ResultD_>	expand(@NonNull Function<A,ResultB_> mappingB, @NonNull Function<A,ResultC_> mappingC, @NonNull Function<A,ResultD_> mappingD)	Adds three facts to the end of the tuple, increasing the cardinality of the stream.
@NonNull UniConstraintStream<A>	filter(@NonNull Predicate<A> predicate)	Exhaustively test each fact against the Predicate and match if Predicate.test(Object) returns true.
<ResultA_> @NonNull UniConstraintStream<ResultA_>	flattenLast(@NonNull 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_> @NonNull UniConstraintStream<Result_>	groupBy(@NonNull 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_> @NonNull BiConstraintStream<ResultA_,ResultB_>	groupBy(@NonNull UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA, @NonNull 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_> @NonNull TriConstraintStream<ResultA_,ResultB_,ResultC_>	groupBy(@NonNull UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA, @NonNull UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB, @NonNull 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_> @NonNull QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_>	groupBy(@NonNull UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA, @NonNull UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB, @NonNull UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC, @NonNull UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)	Convert the UniConstraintStream to a QuadConstraintStream, containing only a single tuple, the result of applying four UniConstraintCollectors.
<GroupKey_> @NonNull UniConstraintStream<GroupKey_>	groupBy(@NonNull 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_> @NonNull BiConstraintStream<GroupKey_,Result_>	groupBy(@NonNull Function<A,GroupKey_> groupKeyMapping, @NonNull UniConstraintCollector<A,ResultContainer_,Result_> collector)	Convert the UniConstraintStream to a BiConstraintStream, consisting of unique tuples with two facts.
<GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_> @NonNull TriConstraintStream<GroupKey_,ResultB_,ResultC_>	groupBy(@NonNull Function<A,GroupKey_> groupKeyMapping, @NonNull UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB, @NonNull 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_> @NonNull QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_>	groupBy(@NonNull Function<A,GroupKey_> groupKeyMapping, @NonNull UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB, @NonNull UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC, @NonNull UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)	Convert the UniConstraintStream to a QuadConstraintStream, consisting of unique tuples with four facts.
<GroupKeyA_, GroupKeyB_> @NonNull BiConstraintStream<GroupKeyA_,GroupKeyB_>	groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping, @NonNull Function<A,GroupKeyB_> groupKeyBMapping)	Convert the UniConstraintStream to a BiConstraintStream, consisting of unique tuples with two facts.
<GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> @NonNull TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_>	groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping, @NonNull Function<A,GroupKeyB_> groupKeyBMapping, @NonNull UniConstraintCollector<A,ResultContainer_,Result_> collector)	Combines the semantics of UniConstraintStream.groupBy(Function, Function) and UniConstraintStream.groupBy(UniConstraintCollector).
<GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_> @NonNull QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_>	groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping, @NonNull Function<A,GroupKeyB_> groupKeyBMapping, @NonNull UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC, @NonNull UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)	Combines the semantics of UniConstraintStream.groupBy(Function, Function) and UniConstraintStream.groupBy(UniConstraintCollector).
<GroupKeyA_, GroupKeyB_, GroupKeyC_> @NonNull TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_>	groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping, @NonNull Function<A,GroupKeyB_> groupKeyBMapping, @NonNull Function<A,GroupKeyC_> groupKeyCMapping)	Convert the UniConstraintStream to a TriConstraintStream, consisting of unique tuples with three facts.
<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_> @NonNull QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_>	groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping, @NonNull Function<A,GroupKeyB_> groupKeyBMapping, @NonNull Function<A,GroupKeyC_> groupKeyCMapping, @NonNull UniConstraintCollector<A,ResultContainerD_,ResultD_> collectorD)	Combines the semantics of UniConstraintStream.groupBy(Function, Function) and UniConstraintStream.groupBy(UniConstraintCollector).
<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_> @NonNull QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_>	groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping, @NonNull Function<A,GroupKeyB_> groupKeyBMapping, @NonNull Function<A,GroupKeyC_> groupKeyCMapping, @NonNull Function<A,GroupKeyD_> groupKeyDMapping)	Convert the UniConstraintStream to a QuadConstraintStream, consisting of unique tuples with four facts.
final <B> @NonNull UniConstraintStream<A>	ifExists(@NonNull UniConstraintStream<B> otherStream, @NonNull BiJoiner<A,B>... joiners)	As defined by UniConstraintStream.ifExists(UniConstraintStream, BiJoiner).
final <B> @NonNull UniConstraintStream<A>	ifNotExists(@NonNull UniConstraintStream<B> otherStream, @NonNull 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> @NonNull BiConstraintStream<A,B>	join(@NonNull UniConstraintStream<B> otherStream, @NonNull 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_> @NonNull UniConstraintStream<ResultA_>	map(@NonNull Function<A,ResultA_> mapping)	Transforms the stream in such a way that tuples are remapped using the given function.
<ResultA_, ResultB_> @NonNull BiConstraintStream<ResultA_,ResultB_>	map(@NonNull Function<A,ResultA_> mappingA, @NonNull Function<A,ResultB_> mappingB)	As defined by UniConstraintStream.map(Function), only resulting in BiConstraintStream.
<ResultA_, ResultB_, ResultC_> @NonNull TriConstraintStream<ResultA_,ResultB_,ResultC_>	map(@NonNull Function<A,ResultA_> mappingA, @NonNull Function<A,ResultB_> mappingB, @NonNull Function<A,ResultC_> mappingC)	As defined by UniConstraintStream.map(Function), only resulting in TriConstraintStream.
<ResultA_, ResultB_, ResultC_, ResultD_> @NonNull QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_>	map(@NonNull Function<A,ResultA_> mappingA, @NonNull Function<A,ResultB_> mappingB, @NonNull Function<A,ResultC_> mappingC, @NonNull Function<A,ResultD_> mappingD)	As defined by UniConstraintStream.map(Function), only resulting in QuadConstraintStream.

Methods inherited from class ai.timefold.solver.core.impl.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 @NonNull UniConstraintStream<A> filter(@NonNull 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_>

join

@SafeVarargs
public final <B> @NonNull BiConstraintStream<A,B> join(@NonNull UniConstraintStream<B> otherStream,
 @NonNull 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

Returns:

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> @NonNull UniConstraintStream<A> ifExists(@NonNull UniConstraintStream<B> otherStream,
 @NonNull 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

Returns:

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

ifNotExists

@SafeVarargs
public final <B> @NonNull UniConstraintStream<A> ifNotExists(@NonNull UniConstraintStream<B> otherStream,
 @NonNull 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_>
@NonNull UniConstraintStream<Result_> groupBy(@NonNull 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 - the collector to perform the grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

groupBy

public <ResultContainerA_,
ResultA_,
ResultContainerB_,
ResultB_>
@NonNull BiConstraintStream<ResultA_,ResultB_> groupBy(@NonNull UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA,
 @NonNull 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 - the collector to perform the first grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

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

groupBy

public <ResultContainerA_,
ResultA_,
ResultContainerB_,
ResultB_,
ResultContainerC_,
ResultC_>
@NonNull TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(@NonNull UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA,
 @NonNull UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB,
 @NonNull 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 - the collector to perform the first grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

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

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

groupBy

public <ResultContainerA_,
ResultA_,
ResultContainerB_,
ResultB_,
ResultContainerC_,
ResultC_,
ResultContainerD_,
ResultD_>
@NonNull QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(@NonNull UniConstraintCollector<A,ResultContainerA_,ResultA_> collectorA,
 @NonNull UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB,
 @NonNull UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC,
 @NonNull 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 - the collector to perform the first grouping operation with See ConstraintCollectors for common operations, such as count(), sum() and others.

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

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

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

groupBy

public <GroupKey_>
@NonNull UniConstraintStream<GroupKey_> groupBy(@NonNull 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 - mapping function to convert each element in the stream to a different element

groupBy

public <GroupKey_,
ResultContainerB_,
ResultB_,
ResultContainerC_,
ResultC_>
@NonNull TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(@NonNull Function<A,GroupKey_> groupKeyMapping,
 @NonNull UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB,
 @NonNull 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 - function to convert the fact in the original tuple to a different fact

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

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

groupBy

public <GroupKey_,
ResultContainerB_,
ResultB_,
ResultContainerC_,
ResultC_,
ResultContainerD_,
ResultD_>
@NonNull QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(@NonNull Function<A,GroupKey_> groupKeyMapping,
 @NonNull UniConstraintCollector<A,ResultContainerB_,ResultB_> collectorB,
 @NonNull UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC,
 @NonNull 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 - function to convert the fact in the original tuple to a different fact

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

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

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

groupBy

public <GroupKey_,
ResultContainer_,
Result_>
@NonNull BiConstraintStream<GroupKey_,Result_> groupBy(@NonNull Function<A,GroupKey_> groupKeyMapping,
 @NonNull 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 - function to convert the fact in the original tuple to a different fact

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

groupBy

public <GroupKeyA_,
GroupKeyB_>
@NonNull BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping,
 @NonNull 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 - function to convert the original tuple into a first fact

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

groupBy

public <GroupKeyA_,
GroupKeyB_,
ResultContainer_,
Result_>
@NonNull TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping,
 @NonNull Function<A,GroupKeyB_> groupKeyBMapping,
 @NonNull 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 - function to convert the original tuple into a first fact

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

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

groupBy

public <GroupKeyA_,
GroupKeyB_,
ResultContainerC_,
ResultC_,
ResultContainerD_,
ResultD_>
@NonNull QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping,
 @NonNull Function<A,GroupKeyB_> groupKeyBMapping,
 @NonNull UniConstraintCollector<A,ResultContainerC_,ResultC_> collectorC,
 @NonNull 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 - function to convert the original tuple into a first fact

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

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

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

groupBy

public <GroupKeyA_,
GroupKeyB_,
GroupKeyC_>
@NonNull TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping,
 @NonNull Function<A,GroupKeyB_> groupKeyBMapping,
 @NonNull 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 - function to convert the original tuple into a first fact

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

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

groupBy

public <GroupKeyA_,
GroupKeyB_,
GroupKeyC_,
ResultContainerD_,
ResultD_>
@NonNull QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping,
 @NonNull Function<A,GroupKeyB_> groupKeyBMapping,
 @NonNull Function<A,GroupKeyC_> groupKeyCMapping,
 @NonNull 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 - function to convert the original tuple into a first fact

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

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

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

groupBy

public <GroupKeyA_,
GroupKeyB_,
GroupKeyC_,
GroupKeyD_>
@NonNull QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(@NonNull Function<A,GroupKeyA_> groupKeyAMapping,
 @NonNull Function<A,GroupKeyB_> groupKeyBMapping,
 @NonNull Function<A,GroupKeyC_> groupKeyCMapping,
 @NonNull 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 - function to convert the original tuple into a second fact

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

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

distinct

public @NonNull 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_>

concat

public @NonNull UniConstraintStream<A> concat(@NonNull 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_>

concat

public <B> @NonNull BiConstraintStream<A,B> concat(@NonNull BiConstraintStream<A,B> otherStream,
 @NonNull 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_>

paddingFunction - function to find the padding for the second fact

concat

public <B,
C> @NonNull TriConstraintStream<A,B,C> concat(@NonNull TriConstraintStream<A,B,C> otherStream,
 @NonNull Function<A,B> paddingFunctionB,
 @NonNull 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_>

paddingFunctionB - function to find the padding for the second fact

paddingFunctionC - function to find the padding for the third fact

concat

public <B,
C,
D>
@NonNull QuadConstraintStream<A,B,C,D> concat(@NonNull QuadConstraintStream<A,B,C,D> otherStream,
 @NonNull Function<A,B> paddingFunctionB,
 @NonNull Function<A,C> paddingFunctionC,
 @NonNull 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_>

paddingFunctionB - function to find the padding for the second fact

paddingFunctionC - function to find the padding for the third fact

paddingFunctionD - function to find the padding for the fourth fact

map

public <ResultA_>
@NonNull UniConstraintStream<ResultA_> map(@NonNull 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 - function to convert the original tuple into the new tuple

map

public <ResultA_,
ResultB_>
@NonNull BiConstraintStream<ResultA_,ResultB_> map(@NonNull Function<A,ResultA_> mappingA,
 @NonNull 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 - function to convert the original tuple into the first fact of a new tuple

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

map

public <ResultA_,
ResultB_,
ResultC_>
@NonNull TriConstraintStream<ResultA_,ResultB_,ResultC_> map(@NonNull Function<A,ResultA_> mappingA,
 @NonNull Function<A,ResultB_> mappingB,
 @NonNull 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 - function to convert the original tuple into the first fact of a new tuple

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

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

map

public <ResultA_,
ResultB_,
ResultC_,
ResultD_>
@NonNull QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> map(@NonNull Function<A,ResultA_> mappingA,
 @NonNull Function<A,ResultB_> mappingB,
 @NonNull Function<A,ResultC_> mappingC,
 @NonNull 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 - function to convert the original tuple into the first fact of a new tuple

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

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

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

flattenLast

public <ResultA_>
@NonNull UniConstraintStream<ResultA_> flattenLast(@NonNull 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 - function to convert the original tuple into Iterable. For performance, returning an implementation of Collection is preferred.

expand

public <ResultB_>
@NonNull BiConstraintStream<A,ResultB_> expand(@NonNull 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

expand

public <ResultB_,
ResultC_>
@NonNull TriConstraintStream<A,ResultB_,ResultC_> expand(@NonNull Function<A,ResultB_> mappingB,
 @NonNull 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

expand

public <ResultB_,
ResultC_,
ResultD_>
@NonNull QuadConstraintStream<A,ResultB_,ResultC_,ResultD_> expand(@NonNull Function<A,ResultB_> mappingB,
 @NonNull Function<A,ResultC_> mappingC,
 @NonNull 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

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