Package org.optaplanner.constraint.streams.bavet.bi

Class BavetAbstractBiConstraintStream<Solution_,A,B>

java.lang.Object

org.optaplanner.constraint.streams.common.AbstractConstraintStream<Solution_>

org.optaplanner.constraint.streams.bavet.common.BavetAbstractConstraintStream<Solution_>

org.optaplanner.constraint.streams.bavet.bi.BavetAbstractBiConstraintStream<Solution_,A,B>

All Implemented Interfaces:

org.optaplanner.constraint.streams.common.bi.InnerBiConstraintStream<A,B>, org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B>, org.optaplanner.core.api.score.stream.ConstraintStream

Direct Known Subclasses:

BavetFilterBiConstraintStream, BavetFlattenLastBiConstraintStream, BavetFlattenLastBridgeBiConstraintStream, BavetGroupBiConstraintStream, BavetIfExistsBiConstraintStream, BavetJoinBiConstraintStream, BavetJoinBridgeBiConstraintStream, BavetMapBridgeBiConstraintStream, BavetScoringBiConstraintStream

public abstract class BavetAbstractBiConstraintStream<Solution_,A,B>
extends BavetAbstractConstraintStream<Solution_>
implements org.optaplanner.constraint.streams.common.bi.InnerBiConstraintStream<A,B>

Field Summary

Fields

Modifier and Type	Field	Description
protected List<BavetAbstractBiConstraintStream<Solution_,A,B>>	childStreamList

Fields inherited from class org.optaplanner.constraint.streams.bavet.common.BavetAbstractConstraintStream

constraintFactory

Constructor Summary

Constructors

Constructor	Description
BavetAbstractBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory, org.optaplanner.constraint.streams.common.RetrievalSemantics retrievalSemantics)

Method Summary

Modifier and Type	Method	Description
BavetAbstractBiConstraintStream<Solution_,A,B>	filter(BiPredicate<A,B> predicate)
<ResultB_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,ResultB_>	flattenLast(Function<B,Iterable<ResultB_>> mapping)
List<BavetAbstractBiConstraintStream<Solution_,A,B>>	getChildStreamList()
<GroupKey_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<GroupKey_>	groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping)
<GroupKey_,ResultContainer_,Result_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<GroupKey_,Result_>	groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainer_,Result_> collector)
<GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKey_,ResultB_,ResultC_>	groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC)
<GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_>	groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)
<GroupKeyA_,GroupKeyB_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<GroupKeyA_,GroupKeyB_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping)
<GroupKeyA_,GroupKeyB_,GroupKeyC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, BiFunction<A,B,GroupKeyC_> groupKeyCMapping)
<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> org.optaplanner.core.api.score.stream.quad.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)
<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, BiFunction<A,B,GroupKeyC_> groupKeyCMapping, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)
<GroupKeyA_,GroupKeyB_,ResultContainer_,Result_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainer_,Result_> collector)
<GroupKeyA_,GroupKeyB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_>	groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping, BiFunction<A,B,GroupKeyB_> groupKeyBMapping, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)
<ResultContainer_,Result_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<Result_>	groupBy(org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainer_,Result_> collector)
<ResultContainerA_,ResultA_,ResultContainerB_,ResultB_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<ResultA_,ResultB_>	groupBy(org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB)
<ResultContainerA_,ResultA_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<ResultA_,ResultB_,ResultC_>	groupBy(org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC)
<ResultContainerA_,ResultA_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_>	groupBy(org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC, org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)
<C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B>	ifExists(Class<C> otherClass, org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)
<C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B>	ifExists(org.optaplanner.core.api.score.stream.uni.UniConstraintStream<C> otherStream, org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)
<C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B>	ifExistsIncludingNullVars(Class<C> otherClass, org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)
<C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B>	ifNotExists(Class<C> otherClass, org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)
<C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B>	ifNotExists(org.optaplanner.core.api.score.stream.uni.UniConstraintStream<C> otherStream, org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)
<C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B>	ifNotExistsIncludingNullVars(Class<C> otherClass, org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)
org.optaplanner.core.api.score.stream.bi.BiConstraintBuilder<A,B>	innerImpact(org.optaplanner.core.api.score.Score<?> constraintWeight, BiFunction<A,B,BigDecimal> matchWeigher, org.optaplanner.constraint.streams.common.ScoreImpactType scoreImpactType)
org.optaplanner.core.api.score.stream.bi.BiConstraintBuilder<A,B>	innerImpact(org.optaplanner.core.api.score.Score<?> constraintWeight, ToIntBiFunction<A,B> matchWeigher, org.optaplanner.constraint.streams.common.ScoreImpactType scoreImpactType)
org.optaplanner.core.api.score.stream.bi.BiConstraintBuilder<A,B>	innerImpact(org.optaplanner.core.api.score.Score<?> constraintWeight, ToLongBiFunction<A,B> matchWeigher, org.optaplanner.constraint.streams.common.ScoreImpactType scoreImpactType)
<C> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<A,B,C>	join(org.optaplanner.core.api.score.stream.uni.UniConstraintStream<C> otherStream, org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)
<ResultA_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<ResultA_>	map(BiFunction<A,B,ResultA_> mapping)
<Stream_ extends BavetAbstractBiConstraintStream<Solution_,A,B>> Stream_	shareAndAddChild(Stream_ stream)

Methods inherited from class org.optaplanner.constraint.streams.bavet.common.BavetAbstractConstraintStream

assertBavetUniConstraintStream, buildConstraint, buildNode, collectActiveConstraintStreams, getConstraintFactory, getTupleSource

Methods inherited from class org.optaplanner.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 org.optaplanner.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 org.optaplanner.core.api.score.stream.ConstraintStream

getConstraintFactory

Methods inherited from interface org.optaplanner.constraint.streams.common.bi.InnerBiConstraintStream

distinct, 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

Field Detail

childStreamList

protected final List<BavetAbstractBiConstraintStream<Solution_,A,B>> childStreamList

Constructor Detail

BavetAbstractBiConstraintStream

public BavetAbstractBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
                                       org.optaplanner.constraint.streams.common.RetrievalSemantics retrievalSemantics)

Method Detail

getChildStreamList

public List<BavetAbstractBiConstraintStream<Solution_,A,B>> getChildStreamList()

shareAndAddChild

public <Stream_ extends BavetAbstractBiConstraintStream<Solution_,A,B>> Stream_ shareAndAddChild(Stream_ stream)

filter

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

Specified by:

filter in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

join

@SafeVarargs
public final <C> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<A,B,C> join(org.optaplanner.core.api.score.stream.uni.UniConstraintStream<C> otherStream,
                                                                                                       org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)

Specified by:

join in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

ifExists

@SafeVarargs
public final <C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B> ifExists(Class<C> otherClass,
                                                                                                 org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)

Specified by:

ifExists in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

ifExistsIncludingNullVars

@SafeVarargs
public final <C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B> ifExistsIncludingNullVars(Class<C> otherClass,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)

Specified by:

ifExistsIncludingNullVars in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

ifExists

@SafeVarargs
public final <C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B> ifExists(org.optaplanner.core.api.score.stream.uni.UniConstraintStream<C> otherStream,
                                                                                                 org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)

ifNotExists

@SafeVarargs
public final <C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B> ifNotExists(Class<C> otherClass,
                                                                                                    org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)

Specified by:

ifNotExists in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

ifNotExistsIncludingNullVars

@SafeVarargs
public final <C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B> ifNotExistsIncludingNullVars(Class<C> otherClass,
                                                                                                                     org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)

Specified by:

ifNotExistsIncludingNullVars in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

ifNotExists

@SafeVarargs
public final <C> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,B> ifNotExists(org.optaplanner.core.api.score.stream.uni.UniConstraintStream<C> otherStream,
                                                                                                    org.optaplanner.core.api.score.stream.tri.TriJoiner<A,B,C>... joiners)

groupBy

public <ResultContainer_,Result_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<Result_> groupBy(org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainer_,Result_> collector)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <ResultContainerA_,ResultA_,ResultContainerB_,ResultB_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<ResultA_,ResultB_> groupBy(org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA,
                                                                                                                                                                              org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <ResultContainerA_,ResultA_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA,
                                                                                                                                                                                                                                      org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                                                                                      org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <ResultContainerA_,ResultA_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerA_,ResultA_> collectorA,
                                                                                                                                                                                                                                                                                              org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                                                                                                                                              org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC,
                                                                                                                                                                                                                                                                                              org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKey_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<GroupKey_> groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping,
                                                                                                                                                                                                                org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                                                                org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping,
                                                                                                                                                                                                                                                                        org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                                                                                                                        org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC,
                                                                                                                                                                                                                                                                        org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKey_,ResultContainer_,Result_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<GroupKey_,Result_> groupBy(BiFunction<A,B,GroupKey_> groupKeyMapping,
                                                                                                                                                     org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainer_,Result_> collector)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping,
                                                                                                                                      BiFunction<A,B,GroupKeyB_> groupKeyBMapping)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_,ResultContainer_,Result_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                           BiFunction<A,B,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                           org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainer_,Result_> collector)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                                                                                      BiFunction<A,B,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                                                                                      org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerC_,ResultC_> collectorC,
                                                                                                                                                                                                                                                      org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_,GroupKeyC_> org.optaplanner.core.api.score.stream.tri.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 org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(BiFunction<A,B,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                                                                  BiFunction<A,B,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                                                                  BiFunction<A,B,GroupKeyC_> groupKeyCMapping,
                                                                                                                                                                                                                                  org.optaplanner.core.api.score.stream.bi.BiConstraintCollector<A,B,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

groupBy

public <GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> org.optaplanner.core.api.score.stream.quad.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 org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

map

public <ResultA_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<ResultA_> map(BiFunction<A,B,ResultA_> mapping)

Specified by:

map in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

flattenLast

public <ResultB_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<A,ResultB_> flattenLast(Function<B,Iterable<ResultB_>> mapping)

Specified by:

flattenLast in interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream<Solution_,A>

innerImpact

public org.optaplanner.core.api.score.stream.bi.BiConstraintBuilder<A,B> innerImpact(org.optaplanner.core.api.score.Score<?> constraintWeight,
                                                                                           ToIntBiFunction<A,B> matchWeigher,
                                                                                           org.optaplanner.constraint.streams.common.ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface org.optaplanner.constraint.streams.common.bi.InnerBiConstraintStream<Solution_,A>

innerImpact

public org.optaplanner.core.api.score.stream.bi.BiConstraintBuilder<A,B> innerImpact(org.optaplanner.core.api.score.Score<?> constraintWeight,
                                                                                           ToLongBiFunction<A,B> matchWeigher,
                                                                                           org.optaplanner.constraint.streams.common.ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface org.optaplanner.constraint.streams.common.bi.InnerBiConstraintStream<Solution_,A>

innerImpact

public org.optaplanner.core.api.score.stream.bi.BiConstraintBuilder<A,B> innerImpact(org.optaplanner.core.api.score.Score<?> constraintWeight,
                                                                                           BiFunction<A,B,BigDecimal> matchWeigher,
                                                                                           org.optaplanner.constraint.streams.common.ScoreImpactType scoreImpactType)

Specified by:

innerImpact in interface org.optaplanner.constraint.streams.common.bi.InnerBiConstraintStream<Solution_,A>