chore: merge fixes

Author: Christopher-Chianelli

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractIfExistsNode.java

@@ -105,53 +105,54 @@ protected void killCounterLeft(ExistsCounter<LeftTuple_> counter) {
         }
     }
 
-    protected void incrementCounterRightWithoutIndictment(ExistsCounter<LeftTuple_> counter) {
+    protected void incrementCounterRight(ExistsCounter<LeftTuple_> counter) {
         if (counter.countRight == 0) {
             if (shouldExist) {
                 doInsertCounter(counter);
             } else {
                 doRetractCounter(counter);
             }
         } // Else do not even propagate an update
-          // NOTE: By not propagating here, the left tuple's indicted objects can be stale
-          //       if an element is removed.
         counter.countRight++;
     }
 
     protected void incrementCounterRightUpdatingIndictment(ExistsCounter<LeftTuple_> counter, UniTuple<Right_> rightTuple) {
+        IndictmentSource.addSupport(getId(), counter.getTuple(), rightTuple);
         if (counter.countRight == 0) {
             if (shouldExist) {
                 doInsertCounter(counter);
             } else {
                 doRetractCounter(counter);
             }
-        } else {
-            // count != 0, so only propagate if we are in an `ifExists`
-            if (shouldExist) {
-                doUpdateCounter(counter);
-            }
-        } // Else do not even propagate an update
-          // NOTE: By not propagating here, the left tuple's indicted objects can be stale
-          //       if an element is removed.
-        IndictmentSource.addSupport(getId(), counter.leftTuple, rightTuple);
+        } else if (shouldExist) {
+            doUpdateCounter(counter);
+        }
         counter.countRight++;
     }
 
     protected void decrementCounterRight(ExistsCounter<LeftTuple_> counter) {
         counter.countRight--;
-        IndictmentSource.removeSupport(getId(), counter.leftTuple, rightTuple);
         if (counter.countRight == 0) {
             if (shouldExist) {
                 doRetractCounter(counter);
             } else {
                 doInsertCounter(counter);
             }
-        } else {
-            // count != 0, so only propagate if we are in an `ifExists`
+        } // Else do not even propagate an update
+    }
+
+    protected void decrementCounterRightUpdatingIndictment(ExistsCounter<LeftTuple_> counter, UniTuple<Right_> rightTuple) {
+        IndictmentSource.removeSupport(getId(), counter.getTuple(), rightTuple);
+        counter.countRight--;
+        if (counter.countRight == 0) {
             if (shouldExist) {
-                doUpdateCounter(counter);
+                doRetractCounter(counter);
+            } else {
+                doInsertCounter(counter);
             }
-        } // Else do not even propagate an update
+        } else if (shouldExist) {
+            doUpdateCounter(counter);
+        }
     }
 
     // Clears the left tracker list rooted at leftTuple's inputStoreIndexLeftTrackerList slot,
@@ -192,18 +193,18 @@ private void removeRight(FilteringTracker<LeftTuple_> tracker) {
     // Walk safety: removeFromLeft only touches left-side links, so rightNext is stable across the call.
     protected void clearRightTrackerList(UniTuple<Right_> rightTuple) {
         FilteringTracker<LeftTuple_> tracker = rightTuple.removeStore(inputStoreIndexRightTrackerList);
-        if (rightTuple.getIndictmentSource() != IndictmentSource.DISABLED) {
+        if (rightTuple.getIndictmentSource() == IndictmentSource.DISABLED) {
             while (tracker != null) {
                 var next = tracker.rightNext;
-                decrementCounterRightUpdatingIndictment(tracker.counter, rightTuple);
-                removeFromLeft(tracker);
+                decrementCounterRight(tracker.counter);
+                removeLeft(tracker);
                 tracker = next;
             }
         } else {
             while (tracker != null) {
                 var next = tracker.rightNext;
-                decrementCounterRightWithoutIndictment(tracker.counter);
-                removeFromLeft(tracker);
+                decrementCounterRightUpdatingIndictment(tracker.counter, rightTuple);
+                removeLeft(tracker);
                 tracker = next;
             }
         }
@@ -233,13 +234,17 @@ protected void updateCounterLeft(ExistsCounter<LeftTuple_> counter, UniTuple<Rig
             // which happens when the right input's node sits in a higher layer than the left input's,
             // so the left's inserts and updates are delivered before the right's retracts are.
             // Skipping is safe, as the pending retract will not have a tracker to clear for this pair.
+            IndictmentSource.removeSupport(getId(), counter.getTuple(), rightTuple);
             return;
         }
         if (testFiltering(counter.leftTuple, rightTuple)) {
             counter.countRight++;
+            IndictmentSource.addSupport(getId(), counter.getTuple(), rightTuple);
             var tracker = new FilteringTracker<>(counter, rightTuple);
             linkLeft(tracker);
             linkRight(tracker);
+        } else {
+            IndictmentSource.removeSupport(getId(), counter.getTuple(), rightTuple);
         }
     }
 
@@ -284,13 +289,17 @@ protected void updateCounterRight(ExistsCounter<LeftTuple_> counter, UniTuple<Ri
             // The left tuple can be inactive here because its node sits in a higher layer than the right's:
             // the right's inserts and updates are delivered before the left's retracts are.
             // The mirror case is possible too, see updateCounterLeft(...).
+            IndictmentSource.removeSupport(getId(), counter.getTuple(), rightTuple);
             return;
         }
         if (testFiltering(leftTuple, rightTuple)) {
-            incrementCounterRightUpdatingIndictment(counter, rightTuple);
+            incrementCounterRight(counter);
+            IndictmentSource.addSupport(getId(), counter.getTuple(), rightTuple);
             var tracker = new FilteringTracker<>(counter, rightTuple);
             linkLeft(tracker);
             linkRight(tracker);
+        } else {
+            IndictmentSource.removeSupport(getId(), counter.getTuple(), rightTuple);
         }
     }
 
@@ -303,6 +312,21 @@ private void doInsertCounter(ExistsCounter<LeftTuple_> counter) {
         }
     }
 
+    private void doUpdateCounter(ExistsCounter<LeftTuple_> counter) {
+        switch (counter.state) {
+            case CREATING, UPDATING -> {
+                // Do nothing
+            }
+            case OK -> {
+                propagationQueue.update(counter);
+            }
+            case DYING, DEAD, ABORTING -> {
+                throw new IllegalStateException("Impossible state: The counter (%s) has an impossible retract state (%s)."
+                        .formatted(counter, counter.state));
+            }
+        }
+    }
+
     private void doRetractCounter(ExistsCounter<LeftTuple_> counter) {
         switch (counter.state) {
             case CREATING -> // Kill it before it propagates.
@@ -315,15 +339,6 @@ private void doRetractCounter(ExistsCounter<LeftTuple_> counter) {
         }
     }
 
-    private void doUpdateCounter(ExistsCounter<LeftTuple_> counter) {
-        switch (counter.state) {
-            case DYING, OK, UPDATING, CREATING -> propagationQueue.update(counter);
-            case DEAD, ABORTING -> propagationQueue.insert(counter);
-            default -> throw new IllegalStateException("Impossible state: the counter (%s) has an impossible insert state (%s)."
-                    .formatted(counter, counter.state));
-        }
-    }
-
     @Override
     protected boolean canProduceTuples() {
         // The left input must produce tuples no matter what,
@@ -369,4 +384,4 @@ protected static final class FilteringTracker<LeftTuple_ extends Tuple> {
 
     }
 
-}
+}

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractIndexedIfExistsNode.java

@@ -101,7 +101,7 @@ private void updateCounterRight(LeftTuple_ leftTuple, Object compositeKey, Exist
         if (!isFiltering) {
             counter.countRight = rightSize(leftTuple, compositeKey);
             if (leftTuple.getIndictmentSource() != IndictmentSource.DISABLED) {
-                IndictmentSource.clearSupport(getId(), leftTuple);
+                leftTuple.getIndictmentSource().getSupportForNodeId(getId()).clear();
                 forEachRightFromLeft(leftTuple, compositeKey, rightTuple -> {
                     IndictmentSource.addSupport(getId(), leftTuple, rightTuple);
                 });
@@ -140,12 +140,6 @@ public final void updateLeft(LeftTuple_ leftTuple) {
             // The indexers contain counters in the DEAD state, to track the rightCount.
             if (!isFiltering) {
                 updateUnchangedCounterLeft(counter);
-                if (leftTuple.getIndictmentSource() != IndictmentSource.DISABLED) {
-                    IndictmentSource.clearSupport(getId(), leftTuple);
-                    forEachRightFromLeft(leftTuple, newCompositeKey, rightTuple -> {
-                        IndictmentSource.addSupport(getId(), leftTuple, rightTuple);
-                    });
-                }
             } else {
                 // Call filtering for the leftTuple and rightTuple combinations again
                 clearLeftTrackerList(leftTuple);
@@ -216,10 +210,8 @@ public final void insertRight(UniTuple<Right_> rightTuple) {
 
     private void updateCounterLeft(UniTuple<Right_> rightTuple, Object compositeKey) {
         if (!isFiltering) {
-            // To prevent creating a dynamic lambda on the hot path,
-            // only call the 2-args version when indictments are enabled
             if (rightTuple.getIndictmentSource() == IndictmentSource.DISABLED) {
-                forEachLeftCounter(rightTuple, compositeKey, this::incrementCounterRightWithoutIndictment);
+                forEachLeftCounter(rightTuple, compositeKey, this::incrementCounterRight);
             } else {
                 forEachLeftCounter(rightTuple, compositeKey,
                         counter -> incrementCounterRightUpdatingIndictment(counter, rightTuple));
@@ -262,14 +254,7 @@ public final void updateRight(UniTuple<Right_> rightTuple) {
                 indexerRight.remove(oldCompositeKey, entry);
             }
             if (!isFiltering) {
-                // To prevent creating a dynamic lambda on the hot path,
-                // only call the 2-args version when indictments are enabled
-                if (rightTuple.getIndictmentSource() == IndictmentSource.DISABLED) {
-                    forEachLeftCounter(rightTuple, oldCompositeKey, this::decrementCounterRightWithoutIndictment);
-                } else {
-                    forEachLeftCounter(rightTuple, oldCompositeKey,
-                            counter -> decrementCounterRightUpdatingIndictment(counter, rightTuple));
-                }
+                forEachLeftCounter(rightTuple, oldCompositeKey, this::decrementCounterRight);
             } else {
                 clearRightTrackerList(rightTuple);
             }
@@ -292,26 +277,19 @@ public final void retractRight(UniTuple<Right_> rightTuple) {
             bucket.removeRight(compositeKey, entry);
             fusedEqualIndex.removeBucketIfEmpty(compositeKey, bucket);
             if (!isFiltering) {
-                // To prevent creating a dynamic lambda on the hot path,
-                // only call the 2-args version when indictments are enabled
                 if (rightTuple.getIndictmentSource() == IndictmentSource.DISABLED) {
-                    bucket.forEachLeft(compositeKey, this::decrementCounterRightWithoutIndictment);
+                    bucket.forEachLeft(compositeKey, this::decrementCounterRight);
                 } else {
-                    bucket.forEachLeft(compositeKey, counter -> decrementCounterRightUpdatingIndictment(counter, rightTuple));
+                    bucket.forEachLeft(compositeKey,
+                            leftTuple -> decrementCounterRightUpdatingIndictment(leftTuple, rightTuple));
                 }
             } else {
                 clearRightTrackerList(rightTuple);
             }
         } else {
             indexerRight.remove(compositeKey, entry);
             if (!isFiltering) {
-                // To prevent creating a dynamic lambda on the hot path,
-                // only call the 2-args version when indictments are enabled
-                if (rightTuple.getIndictmentSource() == IndictmentSource.DISABLED) {
-                    indexerLeft.forEach(compositeKey, this::decrementCounterRightWithoutIndictment);
-                } else {
-                    indexerLeft.forEach(compositeKey, counter -> decrementCounterRightUpdatingIndictment(counter, rightTuple));
-                }
+                indexerLeft.forEach(compositeKey, this::decrementCounterRight);
             } else {
                 clearRightTrackerList(rightTuple);
             }
@@ -381,4 +359,4 @@ private void forEachLeftCounter(UniTuple<Right_> rightTuple, Object compositeKey
         }
     }
 
-}
+}

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractUnindexedIfExistsNode.java

@@ -104,10 +104,8 @@ public final void insertRight(UniTuple<Right_> rightTuple) {
         }
         rightTuple.setStore(inputStoreIndexRightEntry, rightTupleList.add(rightTuple));
         if (!isFiltering) {
-            // To prevent creating a dynamic lambda on the hot path,
-            // only call the 2-args version when indictments are enabled
             if (rightTuple.getIndictmentSource() == IndictmentSource.DISABLED) {
-                counterList.forEach(this::incrementCounterRightWithoutIndictment);
+                counterList.forEach(this::incrementCounterRight);
             } else {
                 counterList.forEach(counter -> incrementCounterRightUpdatingIndictment(counter, rightTuple));
             }
@@ -145,10 +143,8 @@ public final void retractRight(UniTuple<Right_> rightTuple) {
         }
         rightEntry.remove();
         if (!isFiltering) {
-            // To prevent creating a dynamic lambda on the hot path,
-            // only call the 2-args version when indictments are enabled
             if (rightTuple.getIndictmentSource() == IndictmentSource.DISABLED) {
-                counterList.forEach(this::decrementCounterRightWithoutIndictment);
+                counterList.forEach(this::decrementCounterRight);
             } else {
                 counterList.forEach(counter -> decrementCounterRightUpdatingIndictment(counter, rightTuple));
             }
@@ -157,4 +153,4 @@ public final void retractRight(UniTuple<Right_> rightTuple) {
         }
     }
 
-}
+}