Package org.optaplanner.core.impl.score.stream.drools.common

Class TriLeftHandSide<A,B,C>

java.lang.Object

org.optaplanner.core.impl.score.stream.drools.common.TriLeftHandSide<A,B,C>

Type Parameters:

A - generic type of the first resulting variable

B - generic type of the second resulting variable

C - generic type of the third resulting variable

All Implemented Interfaces:

Supplier<List<org.drools.model.view.ViewItem<?>>>

public final class TriLeftHandSide<A,B,C>
extends Object

Represents the left hand side of a Drools rule, the result of which are three variables. For more, see UniLeftHandSide and BiLeftHandSide.

Field Summary

Fields

Modifier and Type	Field	Description
protected DroolsVariableFactory	variableFactory

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	TriLeftHandSide(org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<A> patternVariableA, org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<B> patternVariableB, org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<C> patternVariableC, DroolsVariableFactory variableFactory)
protected	TriLeftHandSide(TriLeftHandSide<A,B,C> leftHandSide, org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<C> patternVariable)

Method Summary

Modifier and Type	Method	Description
<D> TriLeftHandSide<A,B,C>	andExists(Class<D> dClass, QuadJoiner<A,B,C,D>[] joiners)
TriLeftHandSide<A,B,C>	andFilter(TriPredicate<A,B,C> predicate)
<NewA> UniLeftHandSide<NewA>	andGroupBy(TriFunction<A,B,C,NewA> keyMapping)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(TriFunction<A,B,C,NewA> keyMappingA, TriFunction<A,B,C,NewB> keyMappingB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(TriFunction<A,B,C,NewA> keyMappingA, TriFunction<A,B,C,NewB> keyMappingB, TriConstraintCollector<A,B,C,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(TriFunction<A,B,C,NewA> keyMappingA, TriFunction<A,B,C,NewB> keyMappingB, TriConstraintCollector<A,B,C,?,NewC> collectorC, TriConstraintCollector<A,B,C,?,NewD> collectorD)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(TriFunction<A,B,C,NewA> keyMappingA, TriConstraintCollector<A,B,C,?,NewB> collectorB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(TriFunction<A,B,C,NewA> keyMappingA, TriConstraintCollector<A,B,C,?,NewB> collectorB, TriConstraintCollector<A,B,C,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(TriFunction<A,B,C,NewA> keyMappingA, TriConstraintCollector<A,B,C,?,NewB> collectorB, TriConstraintCollector<A,B,C,?,NewC> collectorC, TriConstraintCollector<A,B,C,?,NewD> collectorD)
<NewA> UniLeftHandSide<NewA>	andGroupBy(TriConstraintCollector<A,B,C,?,NewA> collector)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(TriConstraintCollector<A,B,C,?,NewA> collectorA, TriConstraintCollector<A,B,C,?,NewB> collectorB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(TriConstraintCollector<A,B,C,?,NewA> collectorA, TriConstraintCollector<A,B,C,?,NewB> collectorB, TriConstraintCollector<A,B,C,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(TriConstraintCollector<A,B,C,?,NewA> collectorA, TriConstraintCollector<A,B,C,?,NewB> collectorB, TriConstraintCollector<A,B,C,?,NewC> collectorC, TriConstraintCollector<A,B,C,?,NewD> collectorD)
<D> QuadLeftHandSide<A,B,C,D>	andJoin(UniLeftHandSide<D> right, QuadJoiner<A,B,C,D> joiner)
<D> TriLeftHandSide<A,B,C>	andNotExists(Class<D> dClass, QuadJoiner<A,B,C,D>[] joiners)
org.optaplanner.core.impl.score.stream.drools.common.AbstractTriConstraintConsequence<A,B,C>	andTerminate()
org.optaplanner.core.impl.score.stream.drools.common.AbstractTriConstraintConsequence<A,B,C>	andTerminate(ToIntTriFunction<A,B,C> matchWeighter)
org.optaplanner.core.impl.score.stream.drools.common.AbstractTriConstraintConsequence<A,B,C>	andTerminate(ToLongTriFunction<A,B,C> matchWeighter)
org.optaplanner.core.impl.score.stream.drools.common.AbstractTriConstraintConsequence<A,B,C>	andTerminate(TriFunction<A,B,C,BigDecimal> matchWeighter)
List<org.drools.model.view.ViewItem<?>>	get()
protected static org.drools.model.Index.ConstraintType	getConstraintType(JoinerType type)
protected org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<A>	getPatternVariableA()
protected org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<B>	getPatternVariableB()
protected org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<C>	getPatternVariableC()
org.drools.model.Variable[]	getVariables()
protected static org.drools.model.view.ViewItem<?>	joinViewItemsWithLogicalAnd(org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<?>... patternVariables)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

variableFactory

protected final DroolsVariableFactory variableFactory

Constructor Detail

TriLeftHandSide

protected TriLeftHandSide(org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<A> patternVariableA,
                          org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<B> patternVariableB,
                          org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<C> patternVariableC,
                          DroolsVariableFactory variableFactory)

TriLeftHandSide

protected TriLeftHandSide(TriLeftHandSide<A,B,C> leftHandSide,
                          org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<C> patternVariable)

Method Detail

getPatternVariableA

protected org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<A> getPatternVariableA()

getPatternVariableB

protected org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<B> getPatternVariableB()

getPatternVariableC

protected org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<C> getPatternVariableC()

andFilter

public TriLeftHandSide<A,B,C> andFilter(TriPredicate<A,B,C> predicate)

andExists

public <D> TriLeftHandSide<A,B,C> andExists(Class<D> dClass,
                                                        QuadJoiner<A,B,C,D>[] joiners)

andNotExists

public <D> TriLeftHandSide<A,B,C> andNotExists(Class<D> dClass,
                                                           QuadJoiner<A,B,C,D>[] joiners)

andJoin

public <D> QuadLeftHandSide<A,B,C,D> andJoin(UniLeftHandSide<D> right,
                                                               QuadJoiner<A,B,C,D> joiner)

andGroupBy

public <NewA> UniLeftHandSide<NewA> andGroupBy(TriFunction<A,B,C,NewA> keyMapping)

andGroupBy

public <NewA> UniLeftHandSide<NewA> andGroupBy(TriConstraintCollector<A,B,C,?,NewA> collector)

andGroupBy

public <NewA,NewB> BiLeftHandSide<NewA,NewB> andGroupBy(TriConstraintCollector<A,B,C,?,NewA> collectorA,
                                                                    TriConstraintCollector<A,B,C,?,NewB> collectorB)

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(TriConstraintCollector<A,B,C,?,NewA> collectorA,
                                                                                           TriConstraintCollector<A,B,C,?,NewB> collectorB,
                                                                                           TriConstraintCollector<A,B,C,?,NewC> collectorC)

andGroupBy

public <NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD> andGroupBy(TriConstraintCollector<A,B,C,?,NewA> collectorA,
                                                                                                                  TriConstraintCollector<A,B,C,?,NewB> collectorB,
                                                                                                                  TriConstraintCollector<A,B,C,?,NewC> collectorC,
                                                                                                                  TriConstraintCollector<A,B,C,?,NewD> collectorD)

andGroupBy

public <NewA,NewB> BiLeftHandSide<NewA,NewB> andGroupBy(TriFunction<A,B,C,NewA> keyMappingA,
                                                                    TriConstraintCollector<A,B,C,?,NewB> collectorB)

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(TriFunction<A,B,C,NewA> keyMappingA,
                                                                                           TriConstraintCollector<A,B,C,?,NewB> collectorB,
                                                                                           TriConstraintCollector<A,B,C,?,NewC> collectorC)

andGroupBy

public <NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD> andGroupBy(TriFunction<A,B,C,NewA> keyMappingA,
                                                                                                                  TriConstraintCollector<A,B,C,?,NewB> collectorB,
                                                                                                                  TriConstraintCollector<A,B,C,?,NewC> collectorC,
                                                                                                                  TriConstraintCollector<A,B,C,?,NewD> collectorD)

andGroupBy

public <NewA,NewB> BiLeftHandSide<NewA,NewB> andGroupBy(TriFunction<A,B,C,NewA> keyMappingA,
                                                                    TriFunction<A,B,C,NewB> keyMappingB)

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(TriFunction<A,B,C,NewA> keyMappingA,
                                                                                           TriFunction<A,B,C,NewB> keyMappingB,
                                                                                           TriConstraintCollector<A,B,C,?,NewC> collectorC)

andGroupBy

public <NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD> andGroupBy(TriFunction<A,B,C,NewA> keyMappingA,
                                                                                                                  TriFunction<A,B,C,NewB> keyMappingB,
                                                                                                                  TriConstraintCollector<A,B,C,?,NewC> collectorC,
                                                                                                                  TriConstraintCollector<A,B,C,?,NewD> collectorD)

andTerminate

public org.optaplanner.core.impl.score.stream.drools.common.AbstractTriConstraintConsequence<A,B,C> andTerminate()

andTerminate

public org.optaplanner.core.impl.score.stream.drools.common.AbstractTriConstraintConsequence<A,B,C> andTerminate(ToIntTriFunction<A,B,C> matchWeighter)

andTerminate

public org.optaplanner.core.impl.score.stream.drools.common.AbstractTriConstraintConsequence<A,B,C> andTerminate(ToLongTriFunction<A,B,C> matchWeighter)

andTerminate

public org.optaplanner.core.impl.score.stream.drools.common.AbstractTriConstraintConsequence<A,B,C> andTerminate(TriFunction<A,B,C,BigDecimal> matchWeighter)

get

public List<org.drools.model.view.ViewItem<?>> get()

getVariables

public org.drools.model.Variable[] getVariables()

getConstraintType

protected static org.drools.model.Index.ConstraintType getConstraintType(JoinerType type)

joinViewItemsWithLogicalAnd

protected static org.drools.model.view.ViewItem<?> joinViewItemsWithLogicalAnd(org.optaplanner.core.impl.score.stream.drools.common.PatternVariable<?>... patternVariables)