Package org.optaplanner.constraint.streams.drools.quad

Class DroolsAbstractQuadConstraintStream<Solution_,A,B,C,D>

java.lang.Object

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

org.optaplanner.constraint.streams.drools.common.DroolsAbstractConstraintStream<Solution_>

org.optaplanner.constraint.streams.drools.quad.DroolsAbstractQuadConstraintStream<Solution_,A,B,C,D>

All Implemented Interfaces:

InnerQuadConstraintStream<A,B,C,D>, org.optaplanner.core.api.score.stream.ConstraintStream, org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D>

Direct Known Subclasses:

DroolsExistsQuadConstraintStream, DroolsFilterQuadConstraintStream, DroolsFlatteningQuadConstraintStream, DroolsGroupingQuadConstraintStream, DroolsJoinQuadConstraintStream

public abstract class DroolsAbstractQuadConstraintStream<Solution_,A,B,C,D>
extends DroolsAbstractConstraintStream<Solution_>
implements InnerQuadConstraintStream<A,B,C,D>

Field Summary

Fields inherited from class org.optaplanner.constraint.streams.drools.common.DroolsAbstractConstraintStream

constraintFactory

Constructor Summary

Constructors

Constructor	Description
DroolsAbstractQuadConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory, RetrievalSemantics retrievalSemantics)

Method Summary

Modifier and Type	Method	Description
org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D>	filter(org.optaplanner.core.api.function.QuadPredicate<A,B,C,D> predicate)
<ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,ResultD_>	flattenLast(Function<D,Iterable<ResultD_>> mapping)
abstract QuadLeftHandSide<A,B,C,D>	getLeftHandSide()
<GroupKey_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<GroupKey_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping)
<GroupKey_,ResultContainer_,Result_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<GroupKey_,Result_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)
<GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKey_,ResultB_,ResultC_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC)
<GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)
<GroupKeyA_,GroupKeyB_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<GroupKeyA_,GroupKeyB_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping)
<GroupKeyA_,GroupKeyB_,GroupKeyC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyC_> groupKeyCMapping)
<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyC_> groupKeyCMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyD_> groupKeyDMapping)
<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyC_> groupKeyCMapping, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)
<GroupKeyA_,GroupKeyB_,ResultContainer_,Result_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)
<GroupKeyA_,GroupKeyB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_>	groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)
<ResultContainer_,Result_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<Result_>	groupBy(org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)
<ResultContainerA_,ResultA_,ResultContainerB_,ResultB_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<ResultA_,ResultB_>	groupBy(org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_> collectorA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,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.quad.QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_> collectorA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,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.quad.QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_> collectorA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)
<E> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D>	ifExists(Class<E> otherClass, org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>... joiners)
<E> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D>	ifExistsIncludingNullVars(Class<E> otherClass, org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>... joiners)
<E> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D>	ifNotExists(Class<E> otherClass, org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>... joiners)
<E> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D>	ifNotExistsIncludingNullVars(Class<E> otherClass, org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>... joiners)
protected org.optaplanner.core.api.score.stream.Constraint	impactScore(String constraintPackage, String constraintName, org.optaplanner.core.api.score.Score<?> constraintWeight, ScoreImpactType impactType)
org.optaplanner.core.api.score.stream.Constraint	impactScore(String constraintPackage, String constraintName, org.optaplanner.core.api.score.Score<?> constraintWeight, org.optaplanner.core.api.function.ToIntQuadFunction<A,B,C,D> matchWeigher, ScoreImpactType impactType)
org.optaplanner.core.api.score.stream.Constraint	impactScoreBigDecimal(String constraintPackage, String constraintName, org.optaplanner.core.api.score.Score<?> constraintWeight, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,BigDecimal> matchWeigher, ScoreImpactType impactType)
protected org.optaplanner.core.api.score.stream.Constraint	impactScoreConfigurable(String constraintPackage, String constraintName, ScoreImpactType impactType)
org.optaplanner.core.api.score.stream.Constraint	impactScoreConfigurable(String constraintPackage, String constraintName, org.optaplanner.core.api.function.ToIntQuadFunction<A,B,C,D> matchWeigher, ScoreImpactType impactType)
org.optaplanner.core.api.score.stream.Constraint	impactScoreConfigurableBigDecimal(String constraintPackage, String constraintName, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,BigDecimal> matchWeigher, ScoreImpactType impactType)
org.optaplanner.core.api.score.stream.Constraint	impactScoreConfigurableLong(String constraintPackage, String constraintName, org.optaplanner.core.api.function.ToLongQuadFunction<A,B,C,D> matchWeigher, ScoreImpactType impactType)
org.optaplanner.core.api.score.stream.Constraint	impactScoreLong(String constraintPackage, String constraintName, org.optaplanner.core.api.score.Score<?> constraintWeight, org.optaplanner.core.api.function.ToLongQuadFunction<A,B,C,D> matchWeigher, ScoreImpactType impactType)
<ResultA_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<ResultA_>	map(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,ResultA_> mapping)

Methods inherited from class org.optaplanner.constraint.streams.drools.common.DroolsAbstractConstraintStream

addChildStream, buildConstraint, buildConstraintConfigurable, getChildStreams, getConstraintFactory

Methods inherited from class org.optaplanner.constraint.streams.common.AbstractConstraintStream

buildConstraintWeightExtractor, buildConstraintWeightExtractor, getRetrievalSemantics, impact, penalize, penalizeConfigurable, reward, rewardConfigurable

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.ConstraintStream

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

Methods inherited from interface org.optaplanner.constraint.streams.quad.InnerQuadConstraintStream

distinct, guaranteesDistinct, impact, impactBigDecimal, impactConfigurable, impactConfigurableBigDecimal, impactConfigurableLong, impactLong, penalize, penalizeBigDecimal, penalizeConfigurable, penalizeConfigurableBigDecimal, penalizeConfigurableLong, penalizeLong, reward, rewardBigDecimal, rewardConfigurable, rewardConfigurableBigDecimal, rewardConfigurableLong, rewardLong

Methods inherited from interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream

ifExists, ifExists, ifExists, ifExists, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifExistsIncludingNullVars, ifNotExists, ifNotExists, ifNotExists, ifNotExists, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, ifNotExistsIncludingNullVars, impact, impactBigDecimal, impactConfigurable, impactConfigurableBigDecimal, impactConfigurableLong, impactLong, penalize, penalizeBigDecimal, penalizeConfigurable, penalizeConfigurableBigDecimal, penalizeConfigurableLong, penalizeLong, reward, rewardBigDecimal, rewardConfigurable, rewardConfigurableBigDecimal, rewardConfigurableLong, rewardLong

Constructor Detail

DroolsAbstractQuadConstraintStream

public DroolsAbstractQuadConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
                                          RetrievalSemantics retrievalSemantics)

Method Detail

filter

public org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D> filter(org.optaplanner.core.api.function.QuadPredicate<A,B,C,D> predicate)

Specified by:

filter in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

ifExists

@SafeVarargs
public final <E> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D> ifExists(Class<E> otherClass,
                                                                                                                     org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>... joiners)

Specified by:

ifExists in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

ifExistsIncludingNullVars

@SafeVarargs
public final <E> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E> otherClass,
                                                                                                                                      org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>... joiners)

Specified by:

ifExistsIncludingNullVars in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

ifNotExists

@SafeVarargs
public final <E> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D> ifNotExists(Class<E> otherClass,
                                                                                                                        org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>... joiners)

Specified by:

ifNotExists in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

ifNotExistsIncludingNullVars

@SafeVarargs
public final <E> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E> otherClass,
                                                                                                                                         org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>... joiners)

Specified by:

ifNotExistsIncludingNullVars in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <ResultContainer_,Result_> org.optaplanner.core.api.score.stream.uni.UniConstraintStream<Result_> groupBy(org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

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

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

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.quad.QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_> collectorA,
                                                                                                                                                                                                                                      org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                                                                                      org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

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.quad.QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_> collectorA,
                                                                                                                                                                                                                                                                                              org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                                                                                                                                              org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC,
                                                                                                                                                                                                                                                                                              org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

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

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <GroupKey_,ResultContainer_,Result_> org.optaplanner.core.api.score.stream.bi.BiConstraintStream<GroupKey_,Result_> groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping,
                                                                                                                                                     org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping,
                                                                                                                                                                                                                org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                                                                org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <GroupKey_,ResultContainerB_,ResultB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKey_> groupKeyMapping,
                                                                                                                                                                                                                                                                        org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_> collectorB,
                                                                                                                                                                                                                                                                        org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC,
                                                                                                                                                                                                                                                                        org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

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

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <GroupKeyA_,GroupKeyB_,ResultContainer_,Result_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                           org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                           org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_> collector)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <GroupKeyA_,GroupKeyB_,ResultContainerC_,ResultC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                                                                                      org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                                                                                      org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_> collectorC,
                                                                                                                                                                                                                                                      org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <GroupKeyA_,GroupKeyB_,GroupKeyC_> org.optaplanner.core.api.score.stream.tri.TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                          org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                          org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyC_> groupKeyCMapping)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultContainerD_,ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                                                                  org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                                                                  org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyC_> groupKeyCMapping,
                                                                                                                                                                                                                                  org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_> collectorD)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

groupBy

public <GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyA_> groupKeyAMapping,
                                                                                                                                                                                                              org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyB_> groupKeyBMapping,
                                                                                                                                                                                                              org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyC_> groupKeyCMapping,
                                                                                                                                                                                                              org.optaplanner.core.api.function.QuadFunction<A,B,C,D,GroupKeyD_> groupKeyDMapping)

Specified by:

groupBy in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

map

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

Specified by:

map in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

flattenLast

public <ResultD_> org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>> mapping)

Specified by:

flattenLast in interface org.optaplanner.core.api.score.stream.quad.QuadConstraintStream<Solution_,A,B,C>

impactScore

protected org.optaplanner.core.api.score.stream.Constraint impactScore(String constraintPackage,
                                                                       String constraintName,
                                                                       org.optaplanner.core.api.score.Score<?> constraintWeight,
                                                                       ScoreImpactType impactType)

Specified by:

impactScore in class AbstractConstraintStream<Solution_>

impactScore

public org.optaplanner.core.api.score.stream.Constraint impactScore(String constraintPackage,
                                                                    String constraintName,
                                                                    org.optaplanner.core.api.score.Score<?> constraintWeight,
                                                                    org.optaplanner.core.api.function.ToIntQuadFunction<A,B,C,D> matchWeigher,
                                                                    ScoreImpactType impactType)

Specified by:

impactScore in interface InnerQuadConstraintStream<Solution_,A,B,C>

impactScoreLong

public org.optaplanner.core.api.score.stream.Constraint impactScoreLong(String constraintPackage,
                                                                        String constraintName,
                                                                        org.optaplanner.core.api.score.Score<?> constraintWeight,
                                                                        org.optaplanner.core.api.function.ToLongQuadFunction<A,B,C,D> matchWeigher,
                                                                        ScoreImpactType impactType)

Specified by:

impactScoreLong in interface InnerQuadConstraintStream<Solution_,A,B,C>

impactScoreBigDecimal

public org.optaplanner.core.api.score.stream.Constraint impactScoreBigDecimal(String constraintPackage,
                                                                              String constraintName,
                                                                              org.optaplanner.core.api.score.Score<?> constraintWeight,
                                                                              org.optaplanner.core.api.function.QuadFunction<A,B,C,D,BigDecimal> matchWeigher,
                                                                              ScoreImpactType impactType)

Specified by:

impactScoreBigDecimal in interface InnerQuadConstraintStream<Solution_,A,B,C>

impactScoreConfigurable

protected org.optaplanner.core.api.score.stream.Constraint impactScoreConfigurable(String constraintPackage,
                                                                                   String constraintName,
                                                                                   ScoreImpactType impactType)

Specified by:

impactScoreConfigurable in class AbstractConstraintStream<Solution_>

impactScoreConfigurable

public org.optaplanner.core.api.score.stream.Constraint impactScoreConfigurable(String constraintPackage,
                                                                                String constraintName,
                                                                                org.optaplanner.core.api.function.ToIntQuadFunction<A,B,C,D> matchWeigher,
                                                                                ScoreImpactType impactType)

Specified by:

impactScoreConfigurable in interface InnerQuadConstraintStream<Solution_,A,B,C>

impactScoreConfigurableLong

public org.optaplanner.core.api.score.stream.Constraint impactScoreConfigurableLong(String constraintPackage,
                                                                                    String constraintName,
                                                                                    org.optaplanner.core.api.function.ToLongQuadFunction<A,B,C,D> matchWeigher,
                                                                                    ScoreImpactType impactType)

Specified by:

impactScoreConfigurableLong in interface InnerQuadConstraintStream<Solution_,A,B,C>

impactScoreConfigurableBigDecimal

public org.optaplanner.core.api.score.stream.Constraint impactScoreConfigurableBigDecimal(String constraintPackage,
                                                                                          String constraintName,
                                                                                          org.optaplanner.core.api.function.QuadFunction<A,B,C,D,BigDecimal> matchWeigher,
                                                                                          ScoreImpactType impactType)

Specified by:

impactScoreConfigurableBigDecimal in interface InnerQuadConstraintStream<Solution_,A,B,C>

getLeftHandSide

public abstract QuadLeftHandSide<A,B,C,D> getLeftHandSide()