org.optaplanner.core.impl.score.stream.drools.bi

Class DroolsAbstractBiConstraintStream<Solution_,A,B>

java.lang.Object

org.optaplanner.core.impl.score.stream.common.AbstractConstraintStream<Solution_>

org.optaplanner.core.impl.score.stream.drools.common.DroolsAbstractConstraintStream<Solution_>

org.optaplanner.core.impl.score.stream.drools.bi.DroolsAbstractBiConstraintStream<Solution_,A,B>

All Implemented Interfaces:

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

Direct Known Subclasses:

DroolsFilterBiConstraintStream, DroolsJoinBiConstraintStream, DroolsScoringBiConstraintStream

public abstract class DroolsAbstractBiConstraintStream<Solution_,A,B>
extends DroolsAbstractConstraintStream<Solution_>
implements InnerBiConstraintStream<A,B>

Field Summary

Fields

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

Fields inherited from class org.optaplanner.core.impl.score.stream.drools.common.DroolsAbstractConstraintStream

constraintFactory

Constructor Summary

Constructors

Constructor and Description
DroolsAbstractBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory, DroolsAbstractBiConstraintStream<Solution_,A,B> parent)

Method Summary

Modifier and Type	Method and Description
void	createRuleItemBuilders(List<<any>> ruleItemBuilderList, <any> scoreHolderGlobal)
BiConstraintStream<A,B>	filter(BiPredicate<A,B> predicate) Exhaustively test each tuple of facts against the BiPredicate and match if BiPredicate.test(Object, Object) returns true.
List<DroolsFromUniConstraintStream<Solution_,Object>>	getFromStreamList()
DroolsAbstractUniConstraintStream<Solution_,A>	getLeftParentStream()
abstract <any>	getLeftPattern()
abstract <any>	getLeftVariableDeclaration()
DroolsAbstractUniConstraintStream<Solution_,B>	getRightParentStream()
abstract <any>	getRightPattern()
abstract <any>	getRightVariableDeclaration()
<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)
<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)
Constraint	impactScore(String constraintPackage, String constraintName, Score<?> constraintWeight, boolean positive)
Constraint	impactScore(String constraintPackage, String constraintName, Score<?> constraintWeight, ToIntBiFunction<A,B> matchWeigher, boolean positive)
Constraint	impactScoreBigDecimal(String constraintPackage, String constraintName, Score<?> constraintWeight, BiFunction<A,B,BigDecimal> matchWeigher, boolean positive)
Constraint	impactScoreConfigurable(String constraintPackage, String constraintName, boolean positive)
Constraint	impactScoreConfigurable(String constraintPackage, String constraintName, ToIntBiFunction<A,B> matchWeigher, boolean positive)
Constraint	impactScoreConfigurableBigDecimal(String constraintPackage, String constraintName, BiFunction<A,B,BigDecimal> matchWeigher, boolean positive)
Constraint	impactScoreConfigurableLong(String constraintPackage, String constraintName, ToLongBiFunction<A,B> matchWeigher, boolean positive)
Constraint	impactScoreLong(String constraintPackage, String constraintName, Score<?> constraintWeight, ToLongBiFunction<A,B> matchWeigher, boolean positive)
<C> TriConstraintStream<A,B,C>	join(Class<C> otherClass) Create a new TriConstraintStream for every combination of [A, B] and C.
<C> TriConstraintStream<A,B,C>	join(Class<C> otherClass, TriJoiner<A,B,C>... joiners) As defined by BiConstraintStream.join(Class, TriJoiner).
<C> TriConstraintStream<A,B,C>	join(Class<C> otherClass, TriJoiner<A,B,C> joiner) Create a new TriConstraintStream for every combination of [A, B] and C for which the BiJoiner is true (for the properties it extracts from both facts).
<C> TriConstraintStream<A,B,C>	join(Class<C> otherClass, TriJoiner<A,B,C> joiner1, TriJoiner<A,B,C> joiner2) As defined by BiConstraintStream.join(Class, TriJoiner).
<C> TriConstraintStream<A,B,C>	join(Class<C> otherClass, TriJoiner<A,B,C> joiner1, TriJoiner<A,B,C> joiner2, TriJoiner<A,B,C> joiner3) As defined by BiConstraintStream.join(Class, TriJoiner).
<C> TriConstraintStream<A,B,C>	join(Class<C> otherClass, TriJoiner<A,B,C> joiner1, TriJoiner<A,B,C> joiner2, TriJoiner<A,B,C> joiner3, TriJoiner<A,B,C> joiner4) As defined by BiConstraintStream.join(Class, TriJoiner).
<C> TriConstraintStream<A,B,C>	join(UniConstraintStream<C> otherStream) Create a new TriConstraintStream for every combination of [A, B] and C.
<C> TriConstraintStream<A,B,C>	join(UniConstraintStream<C> otherStream, TriJoiner<A,B,C> joiner) Create a new TriConstraintStream for every combination of [A, B] and C for which the BiJoiner is true (for the properties it extracts from both facts).

Methods inherited from class org.optaplanner.core.impl.score.stream.drools.common.DroolsAbstractConstraintStream

buildConstraint, buildConstraintConfigurable, getConstraintFactory

Methods inherited from class org.optaplanner.core.impl.score.stream.common.AbstractConstraintStream

buildConstraintWeightExtractor, buildConstraintWeightExtractor, penalize, penalizeConfigurable, reward, rewardConfigurable, validateConstraintId

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.impl.score.stream.bi.InnerBiConstraintStream

penalize, penalizeBigDecimal, penalizeConfigurable, penalizeConfigurableBigDecimal, penalizeConfigurableLong, penalizeLong, reward, rewardBigDecimal, rewardConfigurable, rewardConfigurableBigDecimal, rewardConfigurableLong, rewardLong

Methods inherited from interface org.optaplanner.core.api.score.stream.bi.BiConstraintStream

penalize, penalizeBigDecimal, penalizeConfigurable, penalizeConfigurableBigDecimal, penalizeConfigurableLong, penalizeLong, reward, rewardBigDecimal, rewardConfigurable, rewardConfigurableBigDecimal, rewardConfigurableLong, rewardLong

Methods inherited from interface org.optaplanner.core.api.score.stream.ConstraintStream

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

Field Detail

parent

protected final DroolsAbstractBiConstraintStream<Solution_,A,B> parent

childStreamList

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

Constructor Detail

DroolsAbstractBiConstraintStream

public DroolsAbstractBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
                                        DroolsAbstractBiConstraintStream<Solution_,A,B> parent)

Method Detail

getLeftParentStream

public DroolsAbstractUniConstraintStream<Solution_,A> getLeftParentStream()

getRightParentStream

public DroolsAbstractUniConstraintStream<Solution_,B> getRightParentStream()

filter

public BiConstraintStream<A,B> filter(BiPredicate<A,B> predicate)

Description copied from interface: BiConstraintStream

Exhaustively test each tuple of facts against the BiPredicate and match if BiPredicate.test(Object, Object) returns true.

Important: This is slower and less scalable than UniConstraintStream#join(UniConstraintStream, BiJoiner[]) with a proper BiJoiner predicate (such as Joiners.equal(Function, Function), because the latter applies hashing and/or indexing, so it doesn't create every combination just to filter it out.

Specified by:

filter in interface BiConstraintStream<A,B>

Parameters:

predicate - never null

Returns:

never null

join

public <C> TriConstraintStream<A,B,C> join(UniConstraintStream<C> otherStream)

Description copied from interface: BiConstraintStream

Create a new TriConstraintStream for every combination of [A, B] and C.

Important: TriConstraintStream.filter(TriPredicate) Filtering} this is slower and less scalable than a BiConstraintStream.join(UniConstraintStream, TriJoiner), because it doesn't apply hashing and/or indexing on the properties, so it creates and checks every combination of [A, B] and C.

Specified by:

join in interface BiConstraintStream<A,B>

Type Parameters:

C - the type of the third matched fact

Parameters:

otherStream - never null

Returns:

a stream that matches every combination of [A, B] and C

join

public <C> TriConstraintStream<A,B,C> join(UniConstraintStream<C> otherStream,
                                           TriJoiner<A,B,C> joiner)

Description copied from interface: BiConstraintStream

Create a new TriConstraintStream for every combination of [A, B] and C for which the BiJoiner is true (for the properties it extracts from both facts).

Important: This is faster and more scalable than a join followed by a filter, because it applies hashing and/or indexing on the properties, so it doesn't create nor checks every combination of [A, B] and C.

Specified by:

join in interface BiConstraintStream<A,B>

Type Parameters:

C - the type of the third matched fact

Parameters:

otherStream - never null

joiner - never null

Returns:

a stream that matches every combination of [A, B] and C for which the BiJoiner is true

join

public <C> TriConstraintStream<A,B,C> join(Class<C> otherClass)

Description copied from interface: BiConstraintStream

Create a new TriConstraintStream for every combination of [A, B] and C.

Important: TriConstraintStream.filter(TriPredicate) Filtering} this is slower and less scalable than a BiConstraintStream.join(Class, TriJoiner), because it doesn't apply hashing and/or indexing on the properties, so it creates and checks every combination of [A, B] and C.

This method is syntactic sugar for BiConstraintStream.join(UniConstraintStream).

Specified by:

join in interface BiConstraintStream<A,B>

Type Parameters:

C - the type of the third matched fact

Parameters:

otherClass - never null

Returns:

a stream that matches every combination of [A, B] and C

join

public <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                           TriJoiner<A,B,C> joiner)

Description copied from interface: BiConstraintStream

Create a new TriConstraintStream for every combination of [A, B] and C for which the BiJoiner is true (for the properties it extracts from both facts).

Important: This is faster and more scalable than a join followed by a filter, because it applies hashing and/or indexing on the properties, so it doesn't create nor checks every combination of [A, B] and C.

This method is syntactic sugar for BiConstraintStream.join(UniConstraintStream, TriJoiner).

This method has overloaded methods with multiple TriJoiner parameters.

Specified by:

join in interface BiConstraintStream<A,B>

Type Parameters:

C - the type of the third matched fact

Parameters:

otherClass - never null

joiner - never null

Returns:

a stream that matches every combination of [A, B] and C for which the BiJoiner is true

join

public <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                           TriJoiner<A,B,C> joiner1,
                                           TriJoiner<A,B,C> joiner2)

Description copied from interface: BiConstraintStream

As defined by BiConstraintStream.join(Class, TriJoiner).

Specified by:

join in interface BiConstraintStream<A,B>

Type Parameters:

C - the type of the third matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

Returns:

a stream that matches every combination of [A, B] and C for which all the joiners are true

join

public <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                           TriJoiner<A,B,C> joiner1,
                                           TriJoiner<A,B,C> joiner2,
                                           TriJoiner<A,B,C> joiner3)

Description copied from interface: BiConstraintStream

As defined by BiConstraintStream.join(Class, TriJoiner).

Specified by:

join in interface BiConstraintStream<A,B>

Type Parameters:

C - the type of the third matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

joiner3 - never null

Returns:

a stream that matches every combination of [A, B] and C for which all the joiners are true

join

public <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                           TriJoiner<A,B,C> joiner1,
                                           TriJoiner<A,B,C> joiner2,
                                           TriJoiner<A,B,C> joiner3,
                                           TriJoiner<A,B,C> joiner4)

Description copied from interface: BiConstraintStream

As defined by BiConstraintStream.join(Class, TriJoiner).

Specified by:

join in interface BiConstraintStream<A,B>

Type Parameters:

C - the type of the third matched fact

Parameters:

otherClass - never null

joiner1 - never null

joiner2 - never null

joiner3 - never null

joiner4 - never null

Returns:

a stream that matches every combination of [A, B] and C for which all the joiners are true

join

public <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                           TriJoiner<A,B,C>... joiners)

Description copied from interface: BiConstraintStream

As defined by BiConstraintStream.join(Class, TriJoiner).

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 BiConstraintStream<A,B>

Type Parameters:

C - the type of the third matched fact

Parameters:

otherClass - never null

joiners - never null

Returns:

a stream that matches every combination of [A, B] and C for which all the joiners are true

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<A,B>

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<A,B>

groupBy

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

Specified by:

groupBy in interface BiConstraintStream<A,B>

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<A,B>

impactScore

public final Constraint impactScore(String constraintPackage,
                                    String constraintName,
                                    Score<?> constraintWeight,
                                    boolean positive)

Specified by:

impactScore in class AbstractConstraintStream<Solution_>

impactScore

public final Constraint impactScore(String constraintPackage,
                                    String constraintName,
                                    Score<?> constraintWeight,
                                    ToIntBiFunction<A,B> matchWeigher,
                                    boolean positive)

Specified by:

impactScore in interface InnerBiConstraintStream<A,B>

impactScoreLong

public final Constraint impactScoreLong(String constraintPackage,
                                        String constraintName,
                                        Score<?> constraintWeight,
                                        ToLongBiFunction<A,B> matchWeigher,
                                        boolean positive)

Specified by:

impactScoreLong in interface InnerBiConstraintStream<A,B>

impactScoreBigDecimal

public final Constraint impactScoreBigDecimal(String constraintPackage,
                                              String constraintName,
                                              Score<?> constraintWeight,
                                              BiFunction<A,B,BigDecimal> matchWeigher,
                                              boolean positive)

Specified by:

impactScoreBigDecimal in interface InnerBiConstraintStream<A,B>

impactScoreConfigurable

public final Constraint impactScoreConfigurable(String constraintPackage,
                                                String constraintName,
                                                boolean positive)

Specified by:

impactScoreConfigurable in class AbstractConstraintStream<Solution_>

impactScoreConfigurable

public final Constraint impactScoreConfigurable(String constraintPackage,
                                                String constraintName,
                                                ToIntBiFunction<A,B> matchWeigher,
                                                boolean positive)

Specified by:

impactScoreConfigurable in interface InnerBiConstraintStream<A,B>

impactScoreConfigurableLong

public final Constraint impactScoreConfigurableLong(String constraintPackage,
                                                    String constraintName,
                                                    ToLongBiFunction<A,B> matchWeigher,
                                                    boolean positive)

Specified by:

impactScoreConfigurableLong in interface InnerBiConstraintStream<A,B>

impactScoreConfigurableBigDecimal

public final Constraint impactScoreConfigurableBigDecimal(String constraintPackage,
                                                          String constraintName,
                                                          BiFunction<A,B,BigDecimal> matchWeigher,
                                                          boolean positive)

Specified by:

impactScoreConfigurableBigDecimal in interface InnerBiConstraintStream<A,B>

createRuleItemBuilders

public void createRuleItemBuilders(List<<any>> ruleItemBuilderList,
                                   <any> scoreHolderGlobal)

Specified by:

createRuleItemBuilders in class DroolsAbstractConstraintStream<Solution_>

getFromStreamList

public List<DroolsFromUniConstraintStream<Solution_,Object>> getFromStreamList()

Specified by:

getFromStreamList in class DroolsAbstractConstraintStream<Solution_>

getLeftVariableDeclaration

public abstract <any> getLeftVariableDeclaration()

getLeftPattern

public abstract <any> getLeftPattern()

getRightVariableDeclaration

public abstract <any> getRightVariableDeclaration()

getRightPattern

public abstract <any> getRightPattern()