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

Class QuadLeftHandSide<A,B,C,D>

java.lang.Object

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

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

D - generic type of the fourth resulting variable

public final class QuadLeftHandSide<A,B,C,D>
extends Object

Represents the left hand side of a Drools rule, the result of which are four 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	QuadLeftHandSide(PatternVariable<A,?,?> patternVariableA, PatternVariable<B,?,?> patternVariableB, PatternVariable<C,?,?> patternVariableC, PatternVariable<D,?,?> patternVariableD, DroolsVariableFactory variableFactory)
protected	QuadLeftHandSide(QuadLeftHandSide<A,B,C,D> leftHandSide, PatternVariable<D,?,?> patternVariable)
protected	QuadLeftHandSide(org.optaplanner.core.impl.score.stream.drools.common.QuadRuleContext<A,B,C,D> ruleContext, PatternVariable<A,?,?> patternVariableA, PatternVariable<B,?,?> patternVariableB, PatternVariable<C,?,?> patternVariableC, PatternVariable<D,?,?> patternVariableD, DroolsVariableFactory variableFactory)

Method Summary

Modifier and Type	Method	Description
<E> QuadLeftHandSide<A,B,C,D>	andExists(Class<E> dClass, PentaJoiner<A,B,C,D,E>[] joiners)
QuadLeftHandSide<A,B,C,D>	andFilter(QuadPredicate<A,B,C,D> predicate)
<NewA> UniLeftHandSide<NewA>	andGroupBy(QuadFunction<A,B,C,D,NewA> keyMapping)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA, QuadFunction<A,B,C,D,NewB> keyMappingB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA, QuadFunction<A,B,C,D,NewB> keyMappingB, QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA, QuadFunction<A,B,C,D,NewB> keyMappingB, QuadConstraintCollector<A,B,C,D,?,NewC> collectorC, QuadConstraintCollector<A,B,C,D,?,NewD> collectorD)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA, QuadConstraintCollector<A,B,C,D,?,NewB> collectorB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA, QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA, QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, QuadConstraintCollector<A,B,C,D,?,NewC> collectorC, QuadConstraintCollector<A,B,C,D,?,NewD> collectorD)
<NewA> UniLeftHandSide<NewA>	andGroupBy(QuadConstraintCollector<A,B,C,D,?,NewA> collector)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(QuadConstraintCollector<A,B,C,D,?,NewA> collectorA, QuadConstraintCollector<A,B,C,D,?,NewB> collectorB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(QuadConstraintCollector<A,B,C,D,?,NewA> collectorA, QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(QuadConstraintCollector<A,B,C,D,?,NewA> collectorA, QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, QuadConstraintCollector<A,B,C,D,?,NewC> collectorC, QuadConstraintCollector<A,B,C,D,?,NewD> collectorD)
<E> QuadLeftHandSide<A,B,C,D>	andNotExists(Class<E> dClass, PentaJoiner<A,B,C,D,E>[] joiners)
<Solution_> RuleBuilder<Solution_>	andTerminate()
<Solution_> RuleBuilder<Solution_>	andTerminate(QuadFunction<A,B,C,D,BigDecimal> matchWeighter)
<Solution_> RuleBuilder<Solution_>	andTerminate(ToIntQuadFunction<A,B,C,D> matchWeighter)
<Solution_> RuleBuilder<Solution_>	andTerminate(ToLongQuadFunction<A,B,C,D> matchWeighter)
protected static org.drools.model.Index.ConstraintType	getConstraintType(JoinerType type)
protected static org.drools.model.view.ViewItem<?>	joinViewItemsWithLogicalAnd(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

QuadLeftHandSide

protected QuadLeftHandSide(PatternVariable<A,?,?> patternVariableA,
                           PatternVariable<B,?,?> patternVariableB,
                           PatternVariable<C,?,?> patternVariableC,
                           PatternVariable<D,?,?> patternVariableD,
                           DroolsVariableFactory variableFactory)

QuadLeftHandSide

protected QuadLeftHandSide(org.optaplanner.core.impl.score.stream.drools.common.QuadRuleContext<A,B,C,D> ruleContext,
                           PatternVariable<A,?,?> patternVariableA,
                           PatternVariable<B,?,?> patternVariableB,
                           PatternVariable<C,?,?> patternVariableC,
                           PatternVariable<D,?,?> patternVariableD,
                           DroolsVariableFactory variableFactory)

QuadLeftHandSide

protected QuadLeftHandSide(QuadLeftHandSide<A,B,C,D> leftHandSide,
                           PatternVariable<D,?,?> patternVariable)

Method Detail

andFilter

public QuadLeftHandSide<A,B,C,D> andFilter(QuadPredicate<A,B,C,D> predicate)

andExists

public <E> QuadLeftHandSide<A,B,C,D> andExists(Class<E> dClass,
                                                                 PentaJoiner<A,B,C,D,E>[] joiners)

andNotExists

public <E> QuadLeftHandSide<A,B,C,D> andNotExists(Class<E> dClass,
                                                                    PentaJoiner<A,B,C,D,E>[] joiners)

andGroupBy

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

andGroupBy

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

andGroupBy

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

andGroupBy

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

andGroupBy

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

andGroupBy

public <NewA,NewB> BiLeftHandSide<NewA,NewB> andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA,
                                                                    QuadConstraintCollector<A,B,C,D,?,NewB> collectorB)

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA,
                                                                                           QuadConstraintCollector<A,B,C,D,?,NewB> collectorB,
                                                                                           QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)

andGroupBy

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

andGroupBy

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

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(QuadFunction<A,B,C,D,NewA> keyMappingA,
                                                                                           QuadFunction<A,B,C,D,NewB> keyMappingB,
                                                                                           QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)

andGroupBy

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

andTerminate

public <Solution_> RuleBuilder<Solution_> andTerminate()

andTerminate

public <Solution_> RuleBuilder<Solution_> andTerminate(ToIntQuadFunction<A,B,C,D> matchWeighter)

andTerminate

public <Solution_> RuleBuilder<Solution_> andTerminate(ToLongQuadFunction<A,B,C,D> matchWeighter)

andTerminate

public <Solution_> RuleBuilder<Solution_> andTerminate(QuadFunction<A,B,C,D,BigDecimal> matchWeighter)

getConstraintType

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

joinViewItemsWithLogicalAnd

protected static org.drools.model.view.ViewItem<?> joinViewItemsWithLogicalAnd(PatternVariable<?,?,?>... patternVariables)