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

Class QuadLeftHandSide<A,B,C,D>

java.lang.Object
org.optaplanner.constraint.streams.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 final DroolsVariableFactory
    variableFactory
     

  • Method Summary

    Modifier and Type
    Method
    Description
    <E> QuadLeftHandSide<A,B,C,D>
    andExists(Class<E> dClass, org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>[] joiners, Predicate<E> nullityFilter)
     
    QuadLeftHandSide<A,B,C,D>
    andFilter(org.optaplanner.core.api.function.QuadPredicate<A,B,C,D> predicate)
     
    <NewD> QuadLeftHandSide<A,B,C,NewD>
    andFlattenLast(Function<D,Iterable<NewD>> mapping)
     
    <NewA> UniLeftHandSide<NewA>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMapping)
     
    <NewA, NewB>
    BiLeftHandSide<NewA,NewB>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewB> keyMappingB)
     
    <NewA, NewB, NewC>
    TriLeftHandSide<NewA,NewB,NewC>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewB> keyMappingB, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewC> keyMappingC)
     
    <NewA, NewB, NewC, NewD>
    QuadLeftHandSide<NewA,NewB,NewC,NewD>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewB> keyMappingB, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewC> keyMappingC, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewD> keyMappingD)
     
    <NewA, NewB, NewC, NewD>
    QuadLeftHandSide<NewA,NewB,NewC,NewD>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewB> keyMappingB, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewC> keyMappingC, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewD> collectorD)
     
    <NewA, NewB, NewC>
    TriLeftHandSide<NewA,NewB,NewC>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewB> keyMappingB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)
     
    <NewA, NewB, NewC, NewD>
    QuadLeftHandSide<NewA,NewB,NewC,NewD>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewB> keyMappingB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewC> collectorC, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewD> collectorD)
     
    <NewA, NewB>
    BiLeftHandSide<NewA,NewB>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewB> collectorB)
     
    <NewA, NewB, NewC>
    TriLeftHandSide<NewA,NewB,NewC>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)
     
    <NewA, NewB, NewC, NewD>
    QuadLeftHandSide<NewA,NewB,NewC,NewD>
    andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewC> collectorC, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewD> collectorD)
     
    <NewA> UniLeftHandSide<NewA>
    andGroupBy(org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewA> collector)
     
    <NewA, NewB>
    BiLeftHandSide<NewA,NewB>
    andGroupBy(org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewA> collectorA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewB> collectorB)
     
    <NewA, NewB, NewC>
    TriLeftHandSide<NewA,NewB,NewC>
    andGroupBy(org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewA> collectorA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)
     
    <NewA, NewB, NewC, NewD>
    QuadLeftHandSide<NewA,NewB,NewC,NewD>
    andGroupBy(org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewA> collectorA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewC> collectorC, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewD> collectorD)
     
    <NewA> UniLeftHandSide<NewA>
    andMap(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> mapping)
     
    <E> QuadLeftHandSide<A,B,C,D>
    andNotExists(Class<E> dClass, org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>[] joiners, Predicate<E> nullityFilter)
     
    <Solution_>
    RuleBuilder<Solution_>
    andTerminate()
     
    <Solution_>
    RuleBuilder<Solution_>
    andTerminate(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,BigDecimal> matchWeigher)
     
    <Solution_>
    RuleBuilder<Solution_>
    andTerminate(org.optaplanner.core.api.function.ToIntQuadFunction<A,B,C,D> matchWeigher)
     
    <Solution_>
    RuleBuilder<Solution_>
    andTerminate(org.optaplanner.core.api.function.ToLongQuadFunction<A,B,C,D> 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 Details

  • Method Details

    • andFilter

      public QuadLeftHandSide<A,B,C,D> andFilter(org.optaplanner.core.api.function.QuadPredicate<A,B,C,D> predicate)

    • andExists

      public <E> QuadLeftHandSide<A,B,C,D> andExists(Class<E> dClass, org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>[] joiners, Predicate<E> nullityFilter)

    • andNotExists

      public <E> QuadLeftHandSide<A,B,C,D> andNotExists(Class<E> dClass, org.optaplanner.core.api.score.stream.penta.PentaJoiner<A,B,C,D,E>[] joiners, Predicate<E> nullityFilter)

    • andGroupBy

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

    • andGroupBy

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

    • andGroupBy

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

    • andGroupBy

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

    • andGroupBy

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

    • andGroupBy

      public <NewA, NewB> BiLeftHandSide<NewA,NewB> andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewB> collectorB)

    • andGroupBy

      public <NewA, NewB, NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewB> collectorB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)

    • andGroupBy

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

    • andGroupBy

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

    • andGroupBy

      public <NewA, NewB, NewC> TriLeftHandSide<NewA,NewB,NewC> andGroupBy(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewA> keyMappingA, org.optaplanner.core.api.function.QuadFunction<A,B,C,D,NewB> keyMappingB, org.optaplanner.core.api.score.stream.quad.QuadConstraintCollector<A,B,C,D,?,NewC> collectorC)

    • andGroupBy

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

    • andGroupBy

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

    • andGroupBy

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

    • andGroupBy

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

    • andMap

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

    • andFlattenLast

      public <NewD> QuadLeftHandSide<A,B,C,NewD> andFlattenLast(Function<D,Iterable<NewD>> mapping)

    • andTerminate

      public <Solution_> RuleBuilder<Solution_> andTerminate()

    • andTerminate

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

    • andTerminate

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

    • andTerminate

      public <Solution_> RuleBuilder<Solution_> andTerminate(org.optaplanner.core.api.function.QuadFunction<A,B,C,D,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)