AbstractForEachUniNode (Timefold Solver constraints: Constraint streams (Bavet) 0.8.42 API)

java.lang.Object
- ai.timefold.solver.constraint.streams.bavet.common.AbstractNode
- - ai.timefold.solver.constraint.streams.bavet.uni.AbstractForEachUniNode<A>

Type Parameters:

A -

Direct Known Subclasses:

ForEachExcludingNullVarsUniNode, ForEachIncludingNullVarsUniNode
```
public abstract class AbstractForEachUniNode<A>
extends AbstractNode
```
Filtering nodes are expensive. Considering that most streams start with a nullity check on genuine planning variables, it makes sense to create a specialized version of the node for this case (ForEachExcludingNullVarsUniNode), as opposed to forcing an extra filter node on the generic case (ForEachIncludingNullVarsUniNode).

Field Summary

Fields
Modifier and Type Field Description

protected Map<A,UniTuple<A>> tupleMap

Constructor Summary

Constructors
Constructor	Description
`AbstractForEachUniNode(Class<A> forEachClass, TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`Class<A>`	`getForEachClass()`
`Propagator`	`getPropagator()`	Instead of calling the propagation directly from here, we export the propagation queue and allow `BavetConstraintSession` to call it.
`protected void`	`innerUpdate(A a, UniTuple<A> tuple)`
`void`	`insert(A a)`
`void`	`retract(A a)`
`String`	`toString()`
`abstract void`	`update(A a)`

Methods inherited from class ai.timefold.solver.constraint.streams.bavet.common.AbstractNode
getLayerIndex, setId, setLayerIndex

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - tupleMap
```
protected final Map<A,UniTuple<A>> tupleMap
```
- Constructor Detail
  - AbstractForEachUniNode
```
public AbstractForEachUniNode(Class<A> forEachClass,
                              TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
                              int outputStoreSize)
```
- Method Detail
  - insert
```
public void insert(A a)
```
  - update
```
public abstract void update(A a)
```
  - innerUpdate
```
protected final void innerUpdate(A a,
                                 UniTuple<A> tuple)
```
  - retract
```
public void retract(A a)
```
  - getPropagator
```
public Propagator getPropagator()
```
    Description copied from class: AbstractNode
    
    Instead of calling the propagation directly from here, we export the propagation queue and allow BavetConstraintSession to call it. This is done with the idea that Propagator only has two implementations (unlike AbstractNode with myriad implementations) and therefore JVM call site optimizations will kick in to make the method dispatch faster.
    
    Specified by:
    
    getPropagator in class AbstractNode
    
    Returns:
    
    never null; the PropagationQueue in use by this node
  - getForEachClass
```
public final Class<A> getForEachClass()
```
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class AbstractNode