Package org.optaplanner.constraint.streams.drools.common

Class TriLeftHandSide<A,B,C>

java.lang.Object

org.optaplanner.constraint.streams.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

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

Method Summary

Modifier and Type	Method	Description
<D> TriLeftHandSide<A,B,C>	andExists(Class<D> dClass, org.optaplanner.core.api.score.stream.quad.QuadJoiner<A,B,C,D>[] joiners, Predicate<D> nullityFilter)
TriLeftHandSide<A,B,C>	andFilter(org.optaplanner.core.api.function.TriPredicate<A,B,C> predicate)
<NewC> TriLeftHandSide<A,B,NewC>	andFlattenLast(Function<C,Iterable<NewC>> mapping)
<NewA> UniLeftHandSide<NewA>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMapping)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB, org.optaplanner.core.api.function.TriFunction<A,B,C,NewC> keyMappingC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB, org.optaplanner.core.api.function.TriFunction<A,B,C,NewC> keyMappingC, org.optaplanner.core.api.function.TriFunction<A,B,C,NewD> keyMappingD)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB, org.optaplanner.core.api.function.TriFunction<A,B,C,NewC> keyMappingC, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewD> collectorD)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewD> collectorD)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewD> collectorD)
<NewA> UniLeftHandSide<NewA>	andGroupBy(org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewA> collector)
<NewA,NewB> BiLeftHandSide<NewA,NewB>	andGroupBy(org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewA> collectorA, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB)
<NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC>	andGroupBy(org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewA> collectorA, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC)
<NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD>	andGroupBy(org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewA> collectorA, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC, org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewD> collectorD)
<D> QuadLeftHandSide<A,B,C,D>	andJoin(UniLeftHandSide<D> right, org.optaplanner.core.api.score.stream.quad.QuadJoiner<A,B,C,D> joiner)
<NewA> UniLeftHandSide<NewA>	andMap(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> mapping)
<D> TriLeftHandSide<A,B,C>	andNotExists(Class<D> dClass, org.optaplanner.core.api.score.stream.quad.QuadJoiner<A,B,C,D>[] joiners, Predicate<D> nullityFilter)
<Solution_> RuleBuilder<Solution_>	andTerminate()
<Solution_> RuleBuilder<Solution_>	andTerminate(org.optaplanner.core.api.function.ToIntTriFunction<A,B,C> matchWeigher)
<Solution_> RuleBuilder<Solution_>	andTerminate(org.optaplanner.core.api.function.ToLongTriFunction<A,B,C> matchWeigher)
<Solution_> RuleBuilder<Solution_>	andTerminate(org.optaplanner.core.api.function.TriFunction<A,B,C,BigDecimal> matchWeigher)
protected static org.drools.model.view.ViewItem<?>	buildAccumulate(org.drools.model.view.ViewItem<?> innerAccumulatePattern, org.drools.model.functions.accumulate.AccumulateFunction... accFunctions)
protected static <A,B> org.optaplanner.constraint.streams.drools.common.IndirectPatternVariable<B,org.optaplanner.constraint.streams.drools.common.BiTuple<A,B>>	decompose(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.BiTuple<A,B>> primaryVariable, org.drools.model.view.ViewItem<?> prerequisitePattern, org.drools.model.Variable<A> boundVarA, org.drools.model.Variable<B> boundVarB)	Create an IndirectPatternVariable on BiTuple with pre-made bindings for its components variables.
protected static <A,B,C,D> org.optaplanner.constraint.streams.drools.common.IndirectPatternVariable<D,org.optaplanner.constraint.streams.drools.common.QuadTuple<A,B,C,D>>	decompose(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.QuadTuple<A,B,C,D>> primaryVariable, org.drools.model.view.ViewItem<?> prerequisitePattern, org.drools.model.Variable<A> boundVarA, org.drools.model.Variable<B> boundVarB, org.drools.model.Variable<C> boundVarC, org.drools.model.Variable<D> boundVarD)	Create an IndirectPatternVariable on QuadTuple with pre-made bindings for its components variables.
protected static <A,B,C> org.optaplanner.constraint.streams.drools.common.IndirectPatternVariable<C,org.optaplanner.constraint.streams.drools.common.TriTuple<A,B,C>>	decompose(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.TriTuple<A,B,C>> primaryVariable, org.drools.model.view.ViewItem<?> prerequisitePattern, org.drools.model.Variable<A> boundVarA, org.drools.model.Variable<B> boundVarB, org.drools.model.Variable<C> boundVarC)	Create an IndirectPatternVariable on TriTuple with pre-made bindings for its components variables.
protected static <A,B,C> org.optaplanner.constraint.streams.drools.common.DirectPatternVariable<C>	decomposeWithAccumulate(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.BiTuple<A,B>> primaryVariable, org.drools.model.view.ViewItem<?> prerequisitePattern, org.drools.model.Variable<A> boundVarA, org.drools.model.Variable<B> boundVarB, org.drools.model.Variable<C> accumulateOutput)	Create a DirectPatternVariable on BiTuple with pre-made bindings for its components variables and one accumulate output variable.
protected static <A,B,C,D> org.optaplanner.constraint.streams.drools.common.DirectPatternVariable<D>	decomposeWithAccumulate(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.TriTuple<A,B,C>> primaryVariable, org.drools.model.view.ViewItem<?> prerequisitePattern, org.drools.model.Variable<A> boundVarA, org.drools.model.Variable<B> boundVarB, org.drools.model.Variable<C> boundVarC, org.drools.model.Variable<D> accumulateOutput)	Create a DirectPatternVariable on TriTuple with pre-made bindings for its components variables and one accumulate output variable.
protected static org.drools.model.Index.ConstraintType	getConstraintType(org.optaplanner.core.impl.score.stream.JoinerType type)
protected static org.drools.model.view.ViewItem<?>	joinViewItemsWithLogicalAnd(PatternVariable<?,?,?>... patternVariables)
protected static List<org.drools.model.view.ViewItem<?>>	mergeViewItems(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

Method Detail

andFilter

public TriLeftHandSide<A,B,C> andFilter(org.optaplanner.core.api.function.TriPredicate<A,B,C> predicate)

andExists

public <D> TriLeftHandSide<A,B,C> andExists(Class<D> dClass,
                                                        org.optaplanner.core.api.score.stream.quad.QuadJoiner<A,B,C,D>[] joiners,
                                                        Predicate<D> nullityFilter)

andNotExists

public <D> TriLeftHandSide<A,B,C> andNotExists(Class<D> dClass,
                                                           org.optaplanner.core.api.score.stream.quad.QuadJoiner<A,B,C,D>[] joiners,
                                                           Predicate<D> nullityFilter)

andJoin

public <D> QuadLeftHandSide<A,B,C,D> andJoin(UniLeftHandSide<D> right,
                                                               org.optaplanner.core.api.score.stream.quad.QuadJoiner<A,B,C,D> joiner)

andGroupBy

public <NewA> UniLeftHandSide<NewA> andGroupBy(org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewA> collector)

andGroupBy

public <NewA,NewB> BiLeftHandSide<NewA,NewB> andGroupBy(org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewA> collectorA,
                                                                    org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB)

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewA> collectorA,
                                                                                           org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB,
                                                                                           org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC)

andGroupBy

public <NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD> andGroupBy(org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewA> collectorA,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewD> collectorD)

andGroupBy

public <NewA> UniLeftHandSide<NewA> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMapping)

andGroupBy

public <NewA,NewB> BiLeftHandSide<NewA,NewB> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                    org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB)

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                                           org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB,
                                                                                           org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC)

andGroupBy

public <NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewB> collectorB,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewD> collectorD)

andGroupBy

public <NewA,NewB> BiLeftHandSide<NewA,NewB> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                    org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB)

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                                           org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB,
                                                                                           org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC)

andGroupBy

public <NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                                                                  org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewC> collectorC,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewD> collectorD)

andGroupBy

public <NewA,NewB,NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                                           org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB,
                                                                                           org.optaplanner.core.api.function.TriFunction<A,B,C,NewC> keyMappingC)

andGroupBy

public <NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                                                                  org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB,
                                                                                                                  org.optaplanner.core.api.function.TriFunction<A,B,C,NewC> keyMappingC,
                                                                                                                  org.optaplanner.core.api.score.stream.tri.TriConstraintCollector<A,B,C,?,NewD> collectorD)

andGroupBy

public <NewA,NewB,NewC,NewD> QuadLeftHandSide<NewA,NewB,NewC,NewD> andGroupBy(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> keyMappingA,
                                                                                                                  org.optaplanner.core.api.function.TriFunction<A,B,C,NewB> keyMappingB,
                                                                                                                  org.optaplanner.core.api.function.TriFunction<A,B,C,NewC> keyMappingC,
                                                                                                                  org.optaplanner.core.api.function.TriFunction<A,B,C,NewD> keyMappingD)

andMap

public <NewA> UniLeftHandSide<NewA> andMap(org.optaplanner.core.api.function.TriFunction<A,B,C,NewA> mapping)

andFlattenLast

public <NewC> TriLeftHandSide<A,B,NewC> andFlattenLast(Function<C,Iterable<NewC>> mapping)

andTerminate

public <Solution_> RuleBuilder<Solution_> andTerminate()

andTerminate

public <Solution_> RuleBuilder<Solution_> andTerminate(org.optaplanner.core.api.function.ToIntTriFunction<A,B,C> matchWeigher)

andTerminate

public <Solution_> RuleBuilder<Solution_> andTerminate(org.optaplanner.core.api.function.ToLongTriFunction<A,B,C> matchWeigher)

andTerminate

public <Solution_> RuleBuilder<Solution_> andTerminate(org.optaplanner.core.api.function.TriFunction<A,B,C,BigDecimal> matchWeigher)

getConstraintType

protected static org.drools.model.Index.ConstraintType getConstraintType(org.optaplanner.core.impl.score.stream.JoinerType type)

joinViewItemsWithLogicalAnd

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

mergeViewItems

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

decompose

protected static <A,B> org.optaplanner.constraint.streams.drools.common.IndirectPatternVariable<B,org.optaplanner.constraint.streams.drools.common.BiTuple<A,B>> decompose(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.BiTuple<A,B>> primaryVariable,
                                                                                                                                                                                             org.drools.model.view.ViewItem<?> prerequisitePattern,
                                                                                                                                                                                             org.drools.model.Variable<A> boundVarA,
                                                                                                                                                                                             org.drools.model.Variable<B> boundVarB)

Create an IndirectPatternVariable on BiTuple with pre-made bindings for its components variables.

Type Parameters:

A - generic type of the first bound variable

B - generic type of the second bound variable

Parameters:

primaryVariable - never null

prerequisitePattern - never null, pattern required to construct the variable

boundVarA - never null, BiTuple.a

boundVarB - never null, BiTuple.b

Returns:

never null

decomposeWithAccumulate

protected static <A,B,C> org.optaplanner.constraint.streams.drools.common.DirectPatternVariable<C> decomposeWithAccumulate(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.BiTuple<A,B>> primaryVariable,
                                                                                                                                       org.drools.model.view.ViewItem<?> prerequisitePattern,
                                                                                                                                       org.drools.model.Variable<A> boundVarA,
                                                                                                                                       org.drools.model.Variable<B> boundVarB,
                                                                                                                                       org.drools.model.Variable<C> accumulateOutput)

Create a DirectPatternVariable on BiTuple with pre-made bindings for its components variables and one accumulate output variable.

Type Parameters:

A - generic type of the first bound variable

B - generic type of the second bound variable

C - generic type of the accumulate output variable

Parameters:

primaryVariable - never null

prerequisitePattern - never null, pattern required to construct the variable

boundVarA - never null, TriTuple.a

boundVarB - never null, TriTuple.b

accumulateOutput - never null, output of the accumulate function

Returns:

never null

decompose

protected static <A,B,C> org.optaplanner.constraint.streams.drools.common.IndirectPatternVariable<C,org.optaplanner.constraint.streams.drools.common.TriTuple<A,B,C>> decompose(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.TriTuple<A,B,C>> primaryVariable,
                                                                                                                                                                                                              org.drools.model.view.ViewItem<?> prerequisitePattern,
                                                                                                                                                                                                              org.drools.model.Variable<A> boundVarA,
                                                                                                                                                                                                              org.drools.model.Variable<B> boundVarB,
                                                                                                                                                                                                              org.drools.model.Variable<C> boundVarC)

Create an IndirectPatternVariable on TriTuple with pre-made bindings for its components variables.

Type Parameters:

A - generic type of the first bound variable

B - generic type of the second bound variable

C - generic type of the third bound variable

Parameters:

primaryVariable - never null

prerequisitePattern - never null, pattern required to construct the variable

boundVarA - never null, TriTuple.a

boundVarB - never null, TriTuple.b

boundVarC - never null, TriTuple.c

Returns:

never null

decompose

protected static <A,B,C,D> org.optaplanner.constraint.streams.drools.common.IndirectPatternVariable<D,org.optaplanner.constraint.streams.drools.common.QuadTuple<A,B,C,D>> decompose(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.QuadTuple<A,B,C,D>> primaryVariable,
                                                                                                                                                                                                                               org.drools.model.view.ViewItem<?> prerequisitePattern,
                                                                                                                                                                                                                               org.drools.model.Variable<A> boundVarA,
                                                                                                                                                                                                                               org.drools.model.Variable<B> boundVarB,
                                                                                                                                                                                                                               org.drools.model.Variable<C> boundVarC,
                                                                                                                                                                                                                               org.drools.model.Variable<D> boundVarD)

Create an IndirectPatternVariable on QuadTuple with pre-made bindings for its components variables.

Type Parameters:

A - generic type of the first bound variable

B - generic type of the second bound variable

C - generic type of the third bound variable

D - generic type of the fourth bound variable

Parameters:

primaryVariable - never null

prerequisitePattern - never null, pattern required to construct the variable

boundVarA - never null, QuadTuple.a

boundVarB - never null, QuadTuple.b

boundVarC - never null, QuadTuple.c

boundVarD - never null, QuadTuple.d

Returns:

never null

decomposeWithAccumulate

protected static <A,B,C,D> org.optaplanner.constraint.streams.drools.common.DirectPatternVariable<D> decomposeWithAccumulate(org.drools.model.Variable<org.optaplanner.constraint.streams.drools.common.TriTuple<A,B,C>> primaryVariable,
                                                                                                                                               org.drools.model.view.ViewItem<?> prerequisitePattern,
                                                                                                                                               org.drools.model.Variable<A> boundVarA,
                                                                                                                                               org.drools.model.Variable<B> boundVarB,
                                                                                                                                               org.drools.model.Variable<C> boundVarC,
                                                                                                                                               org.drools.model.Variable<D> accumulateOutput)

Create a DirectPatternVariable on TriTuple with pre-made bindings for its components variables and one accumulate output variable.

Type Parameters:

A - generic type of the first bound variable

B - generic type of the second bound variable

C - generic type of the third bound variable

D - generic type of the accumulate output variable

Parameters:

primaryVariable - never null

prerequisitePattern - never null, pattern required to construct the variable

boundVarA - never null, TriTuple.a

boundVarB - never null, TriTuple.b

boundVarC - never null, TriTuple.c

accumulateOutput - never null, output of the accumulate function

Returns:

never null

buildAccumulate

protected static org.drools.model.view.ViewItem<?> buildAccumulate(org.drools.model.view.ViewItem<?> innerAccumulatePattern,
                                                                   org.drools.model.functions.accumulate.AccumulateFunction... accFunctions)