Package ai.timefold.solver.constraint.streams.bavet.common

Class AbstractIfExistsNode<LeftTuple_ extends AbstractTuple,Right_>

java.lang.Object

ai.timefold.solver.constraint.streams.bavet.common.AbstractNode

ai.timefold.solver.constraint.streams.bavet.common.AbstractIfExistsNode<LeftTuple_,Right_>

Type Parameters:

LeftTuple_ -

Right_ -

All Implemented Interfaces:

LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>>

Direct Known Subclasses:

AbstractIndexedIfExistsNode, AbstractUnindexedIfExistsNode

public abstract class AbstractIfExistsNode<LeftTuple_ extends AbstractTuple,Right_>
extends AbstractNode
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>>

This class has two direct children: AbstractIndexedIfExistsNode and AbstractUnindexedIfExistsNode. The logic in either is identical, except that the latter removes all indexing work. Therefore any time that one of the classes changes, the other should be inspected if it could benefit from applying the change there too.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
protected static class	AbstractIfExistsNode.FilteringTracker<LeftTuple_ extends AbstractTuple>

Field Summary

Fields

Modifier and Type	Field	Description
protected int	inputStoreIndexLeftTrackerList
protected int	inputStoreIndexRightTrackerList
protected boolean	isFiltering
protected boolean	shouldExist

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	AbstractIfExistsNode(boolean shouldExist, int inputStoreIndexLeftTrackerList, int inputStoreIndexRightTrackerList, TupleLifecycle<LeftTuple_> nextNodesTupleLifecycle, boolean isFiltering)

Method Summary

Modifier and Type	Method	Description
protected void	decrementCounterRight(ExistsCounter<LeftTuple_> counter)
Propagator	getPropagator()	Instead of calling the propagation directly from here, we export the propagation queue and allow BavetConstraintSession to call it.
protected void	incrementCounterRight(ExistsCounter<LeftTuple_> counter)
protected void	initCounterLeft(ExistsCounter<LeftTuple_> counter)
protected void	killCounterLeft(ExistsCounter<LeftTuple_> counter)
protected abstract boolean	testFiltering(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple)
protected void	updateCounterFromLeft(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter, ElementAwareList<AbstractIfExistsNode.FilteringTracker<LeftTuple_>> leftTrackerList)
protected void	updateCounterFromRight(UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter, ElementAwareList<AbstractIfExistsNode.FilteringTracker<LeftTuple_>> rightTrackerList)
protected void	updateCounterLeft(ExistsCounter<LeftTuple_> counter)
protected ElementAwareList<AbstractIfExistsNode.FilteringTracker<LeftTuple_>>	updateRightTrackerList(UniTuple<Right_> rightTuple)
protected void	updateUnchangedCounterLeft(ExistsCounter<LeftTuple_> counter)

Methods inherited from class ai.timefold.solver.constraint.streams.bavet.common.AbstractNode

getLayerIndex, setId, setLayerIndex, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface ai.timefold.solver.constraint.streams.bavet.common.tuple.LeftTupleLifecycle

insertLeft, retractLeft, updateLeft

Methods inherited from interface ai.timefold.solver.constraint.streams.bavet.common.tuple.RightTupleLifecycle

insertRight, retractRight, updateRight

Field Detail

shouldExist

protected final boolean shouldExist

inputStoreIndexLeftTrackerList

protected final int inputStoreIndexLeftTrackerList

inputStoreIndexRightTrackerList

protected final int inputStoreIndexRightTrackerList

isFiltering

protected final boolean isFiltering

Constructor Detail

AbstractIfExistsNode

protected AbstractIfExistsNode(boolean shouldExist,
                               int inputStoreIndexLeftTrackerList,
                               int inputStoreIndexRightTrackerList,
                               TupleLifecycle<LeftTuple_> nextNodesTupleLifecycle,
                               boolean isFiltering)

Method Detail

testFiltering

protected abstract boolean testFiltering(LeftTuple_ leftTuple,
                                         UniTuple<Right_> rightTuple)

initCounterLeft

protected void initCounterLeft(ExistsCounter<LeftTuple_> counter)

updateUnchangedCounterLeft

protected final void updateUnchangedCounterLeft(ExistsCounter<LeftTuple_> counter)

updateCounterLeft

protected void updateCounterLeft(ExistsCounter<LeftTuple_> counter)

killCounterLeft

protected void killCounterLeft(ExistsCounter<LeftTuple_> counter)

incrementCounterRight

protected void incrementCounterRight(ExistsCounter<LeftTuple_> counter)

decrementCounterRight

protected void decrementCounterRight(ExistsCounter<LeftTuple_> counter)

updateRightTrackerList

protected ElementAwareList<AbstractIfExistsNode.FilteringTracker<LeftTuple_>> updateRightTrackerList(UniTuple<Right_> rightTuple)

updateCounterFromLeft

protected void updateCounterFromLeft(LeftTuple_ leftTuple,
                                     UniTuple<Right_> rightTuple,
                                     ExistsCounter<LeftTuple_> counter,
                                     ElementAwareList<AbstractIfExistsNode.FilteringTracker<LeftTuple_>> leftTrackerList)

updateCounterFromRight

protected void updateCounterFromRight(UniTuple<Right_> rightTuple,
                                      ExistsCounter<LeftTuple_> counter,
                                      ElementAwareList<AbstractIfExistsNode.FilteringTracker<LeftTuple_>> rightTrackerList)

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