Package ai.timefold.solver.constraint.streams.bavet.bi

Class BavetAbstractBiConstraintStream<Solution_,A,B>

java.lang.Object

ai.timefold.solver.constraint.streams.common.AbstractConstraintStream<Solution_>

ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream<Solution_>

ai.timefold.solver.constraint.streams.bavet.bi.BavetAbstractBiConstraintStream<Solution_,A,B>

All Implemented Interfaces:

InnerBiConstraintStream<A,B>, BiConstraintStream<A,B>, ConstraintStream

Direct Known Subclasses:

BavetAftBridgeBiConstraintStream, BavetForeBridgeBiConstraintStream, BavetJoinBiConstraintStream

public abstract class BavetAbstractBiConstraintStream<Solution_,A,B>
extends BavetAbstractConstraintStream<Solution_>
implements InnerBiConstraintStream<A,B>

Field Summary

Fields inherited from class ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream

childStreamList, constraintFactory, parent

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	Description
BiConstraintStream<A,B>	distinct()
BavetAbstractBiConstraintStream<Solution_,A,B>	filter(BiPredicate<A,B> predicate)
<ResultB_> BiConstraintStream<A,ResultB_>	flattenLast(Function<B,Iterable<ResultB_>> mapping)
protected BiFunction<A,B,Collection<?>>	getDefaultIndictedObjectsMapping()
protected TriFunction<A,B,Score<?>,DefaultConstraintJustification>	getDefaultJustificationMapping()
<ResultContainer_,Result_> UniConstraintStream<Result_>	groupBy(BiConstraintCollector<A,B,ResultContainer_,Result_> collector)
<ResultContainerA_,ResultA_,ResultContainerB_,ResultB_> BiConstraintStream<ResultA_,ResultB_>	groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA, BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB)
<ResultContainerA_,ResultA_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> TriConstraintStream<ResultA_,ResultB_,ResultC_>	groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA, BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB, BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC)
<ResultContainerA_,ResultA_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_>	groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA, BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB, BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC, BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)
<GroupKey_> UniConstraintStream<GroupKey_>	groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping)
<GroupKey_,ResultContainer_,Result_> BiConstraintStream<GroupKey_,Result_>	groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping, BiConstraintCollector<A,B,ResultContainer_,Result_> collector)
<GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> TriConstraintStream<GroupKey_,ResultB_,ResultC_>	groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping, BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB, BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC)
<GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_>	groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping, BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB, BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC, BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)
<GroupKeyA_,GroupKeyB_> BiConstraintStream<GroupKeyA_,GroupKeyB_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping)
<GroupKeyA_,GroupKeyB_,ResultContainer_,Result_> TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, BiConstraintCollector<A,B,ResultContainer_,Result_> collector)
<GroupKeyA_,GroupKeyB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC, BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)
<GroupKeyA_,GroupKeyB_,GroupKeyC_> TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, BiFunction<A,B,GroupKeyC_> groupKeyCMapping)
<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultContainerD_,ResultD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, BiFunction<A,B,GroupKeyC_> groupKeyCMapping, BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)
<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, BiFunction<A,B,GroupKeyC_> groupKeyCMapping, BiFunction<A,B,GroupKeyD_> groupKeyDMapping)
<C> BiConstraintStream<A,B>	ifExists(UniConstraintStream<C> otherStream, TriJoiner<A,B,C>... joiners)
<C> BiConstraintStream<A,B>	ifExists(Class<C> otherClass, TriJoiner<A,B,C>... joiners)
<C> BiConstraintStream<A,B>	ifExistsIncludingNullVars(Class<C> otherClass, TriJoiner<A,B,C>... joiners)
<C> BiConstraintStream<A,B>	ifNotExists(UniConstraintStream<C> otherStream, TriJoiner<A,B,C>... joiners)
<C> BiConstraintStream<A,B>	ifNotExists(Class<C> otherClass, TriJoiner<A,B,C>... joiners)
<C> BiConstraintStream<A,B>	ifNotExistsIncludingNullVars(Class<C> otherClass, TriJoiner<A,B,C>... joiners)
<Score_ extends Score<Score_>> BiConstraintBuilder<A,B,Score_>	innerImpact(Score_ constraintWeight, BiFunction<A,B,BigDecimal> matchWeigher, ScoreImpactType scoreImpactType)
<Score_ extends Score<Score_>> BiConstraintBuilder<A,B,Score_>	innerImpact(Score_ constraintWeight, ToIntBiFunction<A,B> matchWeigher, ScoreImpactType scoreImpactType)
<Score_ extends Score<Score_>> BiConstraintBuilder<A,B,Score_>	innerImpact(Score_ constraintWeight, ToLongBiFunction<A,B> matchWeigher, ScoreImpactType scoreImpactType)
<C> TriConstraintStream<A,B,C>	join(UniConstraintStream<C> otherStream, TriJoiner<A,B,C>... joiners)
<ResultA_> UniConstraintStream<ResultA_>	map(BiFunction<A,B,ResultA_> mapping)

Methods inherited from class ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream

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

Methods inherited from class ai.timefold.solver.constraint.streams.common.AbstractConstraintStream

buildConstraintWeightExtractor, buildConstraintWeightExtractor, 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.bi.BiConstraintStream

ifExists, ifExists, ifExists, ifExists, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifNotExists, ifNotExists, ifNotExists, ifNotExists, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, 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, penalizeConfigurable, penalizeConfigurable, penalizeConfigurable, penalizeConfigurableBigDecimal, penalizeConfigurableBigDecimal, penalizeConfigurableLong, penalizeConfigurableLong, penalizeLong, penalizeLong, reward, reward, reward, rewardBigDecimal, rewardBigDecimal, rewardConfigurable, rewardConfigurable, rewardConfigurable, rewardConfigurableBigDecimal, rewardConfigurableBigDecimal, rewardConfigurableLong, rewardConfigurableLong, rewardLong, rewardLong

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

getConstraintFactory

Methods inherited from interface ai.timefold.solver.constraint.streams.common.bi.InnerBiConstraintStream

getRetrievalSemantics, guaranteesDistinct, 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

Constructor Detail

BavetAbstractBiConstraintStream

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

BavetAbstractBiConstraintStream

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

Method Detail

filter

public BavetAbstractBiConstraintStream<Solution_,A,B> filter(BiPredicate<A,B> predicate)

Specified by:

filter in interface BiConstraintStream<Solution_,A>

join

@SafeVarargs
public final <C> TriConstraintStream<A,B,C> join(UniConstraintStream<C> otherStream,
                                                             TriJoiner<A,B,C>... joiners)

Specified by:

join in interface BiConstraintStream<Solution_,A>

ifExists

@SafeVarargs
public final <C> BiConstraintStream<A,B> ifExists(Class<C> otherClass,
                                                        TriJoiner<A,B,C>... joiners)

Specified by:

ifExists in interface BiConstraintStream<Solution_,A>

ifExistsIncludingNullVars

@SafeVarargs
public final <C> BiConstraintStream<A,B> ifExistsIncludingNullVars(Class<C> otherClass,
                                                                         TriJoiner<A,B,C>... joiners)

Specified by:

ifExistsIncludingNullVars in interface BiConstraintStream<Solution_,A>

ifExists

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

ifNotExists

@SafeVarargs
public final <C> BiConstraintStream<A,B> ifNotExists(Class<C> otherClass,
                                                           TriJoiner<A,B,C>... joiners)

Specified by:

ifNotExists in interface BiConstraintStream<Solution_,A>

ifNotExistsIncludingNullVars

@SafeVarargs
public final <C> BiConstraintStream<A,B> ifNotExistsIncludingNullVars(Class<C> otherClass,
                                                                            TriJoiner<A,B,C>... joiners)

Specified by:

ifNotExistsIncludingNullVars in interface BiConstraintStream<Solution_,A>

ifNotExists

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

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping)

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

public <GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping,
                                                                                                                                                                      BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                      BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC)

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

public <GroupKey_,ResultContainer_,Result_> BiConstraintStream<GroupKey_,Result_> groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping,
                                                                                                            BiConstraintCollector<A,B,ResultContainer_,Result_> collector)

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_,ResultContainer_,Result_> TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                 BiFunction<A,B,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                 BiConstraintCollector<A,B,ResultContainer_,Result_> collector)

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                                           BiFunction<A,B,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                                           BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC,
                                                                                                                                                                                                           BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultContainerD_,ResultD_> QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                       BiFunction<A,B,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                       BiFunction<A,B,GroupKeyC_> groupKeyCMapping,
                                                                                                                                                                                       BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<Solution_,A>

distinct

public BiConstraintStream<A,B> distinct()

Specified by:

distinct in interface BiConstraintStream<Solution_,A>

Specified by:

distinct in interface InnerBiConstraintStream<Solution_,A>

map

public <ResultA_> UniConstraintStream<ResultA_> map(BiFunction<A,B,ResultA_> mapping)

Specified by:

map in interface BiConstraintStream<Solution_,A>

flattenLast

public <ResultB_> BiConstraintStream<A,ResultB_> flattenLast(Function<B,Iterable<ResultB_>> mapping)

Specified by:

flattenLast in interface BiConstraintStream<Solution_,A>

innerImpact

public <Score_ extends Score<Score_>> BiConstraintBuilder<A,B,Score_> innerImpact(Score_ constraintWeight,
                                                                                              ToIntBiFunction<A,B> matchWeigher,
                                                                                              ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface InnerBiConstraintStream<Solution_,A>

innerImpact

public <Score_ extends Score<Score_>> BiConstraintBuilder<A,B,Score_> innerImpact(Score_ constraintWeight,
                                                                                              ToLongBiFunction<A,B> matchWeigher,
                                                                                              ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface InnerBiConstraintStream<Solution_,A>

innerImpact

public <Score_ extends Score<Score_>> BiConstraintBuilder<A,B,Score_> innerImpact(Score_ constraintWeight,
                                                                                              BiFunction<A,B,BigDecimal> matchWeigher,
                                                                                              ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface InnerBiConstraintStream<Solution_,A>

getDefaultJustificationMapping

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

Specified by:

getDefaultJustificationMapping in class AbstractConstraintStream<Solution_>

getDefaultIndictedObjectsMapping

protected final BiFunction<A,B,Collection<?>> getDefaultIndictedObjectsMapping()

Specified by:

getDefaultIndictedObjectsMapping in class AbstractConstraintStream<Solution_>