Small improvements to indexing

triceo · triceo · commit 699cfb526359 · 2025-11-19T20:32:32.000+01:00
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractIfExistsNode.java b/core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractIfExistsNode.java
@@ -120,15 +120,14 @@ IndexedSet<ExistsCounterHandle<LeftTuple_>> updateRightHandleSet(UniTuple<Right_
         return rightHandleSet;
     }
 
-    void updateCounterFromLeft(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter) {
-        if (testFiltering(leftTuple, rightTuple)) {
+    void updateCounterFromLeft(ExistsCounter<LeftTuple_> counter, UniTuple<Right_> rightTuple) {
+        if (testFiltering(counter.leftTuple, rightTuple)) {
             counter.countRight++;
-            IndexedSet<ExistsCounterHandle<LeftTuple_>> rightHandleSet = rightTuple.getStore(inputStoreIndexRightHandleSet);
-            new ExistsCounterHandle<>(counter, rightHandleSet);
+            new ExistsCounterHandle<>(counter, rightTuple.getStore(inputStoreIndexRightHandleSet));
         }
     }
 
-    void updateCounterFromRight(UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter,
+    void updateCounterFromRight(ExistsCounter<LeftTuple_> counter, UniTuple<Right_> rightTuple,
             IndexedSet<ExistsCounterHandle<LeftTuple_>> rightHandleSet) {
         var leftTuple = counter.leftTuple;
         if (!leftTuple.state.isActive()) {
@@ -148,7 +147,7 @@ void updateCounterFromRight(UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple
             // However, no such issue could have been reproduced; when in doubt, leave it out.
             return;
         }
-        if (testFiltering(counter.leftTuple, rightTuple)) {
+        if (testFiltering(leftTuple, rightTuple)) {
             incrementCounterRight(counter);
             new ExistsCounterHandle<>(counter, rightHandleSet);
         }
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractIndexedIfExistsNode.java b/core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractIndexedIfExistsNode.java
@@ -68,7 +68,7 @@ private void updateCounterRight(LeftTuple_ leftTuple, Object indexKeys, ExistsCo
         if (!isFiltering) {
             counter.countRight = indexerRight.size(indexKeys);
         } else {
-            indexerRight.forEach(indexKeys, rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter));
+            indexerRight.forEach(indexKeys, rightTuple -> updateCounterFromLeft(counter, rightTuple));
         }
     }
 
@@ -91,7 +91,7 @@ public final void updateLeft(LeftTuple_ leftTuple) {
             } else {
                 // Call filtering for the leftTuple and rightTuple combinations again
                 counter.clearIncludingCount();
-                indexerRight.forEach(oldIndexKeys, rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter));
+                indexerRight.forEach(oldIndexKeys, rightTuple -> updateCounterFromLeft(counter, rightTuple));
                 updateCounterLeft(counter);
             }
         } else {
@@ -142,7 +142,7 @@ private void updateCounterLeft(UniTuple<Right_> rightTuple, Object indexKeys) {
             indexerLeft.forEach(indexKeys, this::incrementCounterRight);
         } else {
             var rightHandleSet = new IndexedSet<ExistsCounterHandle<LeftTuple_>>(ExistsCounterHandlePositionTracker.right());
-            indexerLeft.forEach(indexKeys, counter -> updateCounterFromRight(rightTuple, counter, rightHandleSet));
+            indexerLeft.forEach(indexKeys, counter -> updateCounterFromRight(counter, rightTuple, rightHandleSet));
             rightTuple.setStore(inputStoreIndexRightHandleSet, rightHandleSet);
         }
     }
@@ -161,7 +161,7 @@ public final void updateRight(UniTuple<Right_> rightTuple) {
             if (isFiltering) {
                 var rightHandleSet = updateRightHandleSet(rightTuple);
                 indexerLeft.forEach(oldIndexKeys,
-                        counter -> updateCounterFromRight(rightTuple, counter, rightHandleSet));
+                        counter -> updateCounterFromRight(counter, rightTuple, rightHandleSet));
             }
         } else {
             indexerRight.remove(oldIndexKeys, rightTuple);
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractUnindexedIfExistsNode.java b/core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractUnindexedIfExistsNode.java
@@ -49,7 +49,7 @@ public final void insertLeft(LeftTuple_ leftTuple) {
         if (!isFiltering) {
             counter.countRight = rightTupleSet.size();
         } else {
-            rightTupleSet.forEach(tuple -> updateCounterFromLeft(leftTuple, tuple, counter));
+            rightTupleSet.forEach(tuple -> updateCounterFromLeft(counter, tuple));
         }
         initCounterLeft(counter);
     }
@@ -68,7 +68,7 @@ public final void updateLeft(LeftTuple_ leftTuple) {
         } else {
             // Call filtering for the leftTuple and rightTuple combinations again
             counter.clearIncludingCount();
-            rightTupleSet.forEach(tuple -> updateCounterFromLeft(leftTuple, tuple, counter));
+            rightTupleSet.forEach(tuple -> updateCounterFromLeft(counter, tuple));
             updateCounterLeft(counter);
         }
     }
@@ -99,7 +99,7 @@ public final void insertRight(UniTuple<Right_> rightTuple) {
             leftCounterSet.forEach(this::incrementCounterRight);
         } else {
             var rightHandleSet = new IndexedSet<ExistsCounterHandle<LeftTuple_>>(ExistsCounterHandlePositionTracker.right());
-            leftCounterSet.forEach(tuple -> updateCounterFromRight(rightTuple, tuple, rightHandleSet));
+            leftCounterSet.forEach(counter -> updateCounterFromRight(counter, rightTuple, rightHandleSet));
             rightTuple.setStore(inputStoreIndexRightHandleSet, rightHandleSet);
         }
     }
@@ -113,7 +113,7 @@ public final void updateRight(UniTuple<Right_> rightTuple) {
         }
         if (isFiltering) {
             var rightHandleSet = updateRightHandleSet(rightTuple);
-            leftCounterSet.forEach(tuple -> updateCounterFromRight(rightTuple, tuple, rightHandleSet));
+            leftCounterSet.forEach(counter -> updateCounterFromRight(counter, rightTuple, rightHandleSet));
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -120,15 +120,14 @@ IndexedSet<ExistsCounterHandle<LeftTuple_>> updateRightHandleSet(UniTuple<Right_`
`120`	`120`	`return rightHandleSet;`
`121`	`121`	`}`
`122`	`122`
`123`		`- void updateCounterFromLeft(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter) {`
`124`		`- if (testFiltering(leftTuple, rightTuple)) {`
	`123`	`+ void updateCounterFromLeft(ExistsCounter<LeftTuple_> counter, UniTuple<Right_> rightTuple) {`
	`124`	`+ if (testFiltering(counter.leftTuple, rightTuple)) {`
`125`	`125`	`counter.countRight++;`
`126`		`- IndexedSet<ExistsCounterHandle<LeftTuple_>> rightHandleSet = rightTuple.getStore(inputStoreIndexRightHandleSet);`
`127`		`- new ExistsCounterHandle<>(counter, rightHandleSet);`
	`126`	`+ new ExistsCounterHandle<>(counter, rightTuple.getStore(inputStoreIndexRightHandleSet));`
`128`	`127`	`}`
`129`	`128`	`}`
`130`	`129`
`131`		`- void updateCounterFromRight(UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter,`
	`130`	`+ void updateCounterFromRight(ExistsCounter<LeftTuple_> counter, UniTuple<Right_> rightTuple,`
`132`	`131`	`IndexedSet<ExistsCounterHandle<LeftTuple_>> rightHandleSet) {`
`133`	`132`	`var leftTuple = counter.leftTuple;`
`134`	`133`	`if (!leftTuple.state.isActive()) {`
`@@ -148,7 +147,7 @@ void updateCounterFromRight(UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple`
`148`	`147`	`// However, no such issue could have been reproduced; when in doubt, leave it out.`
`149`	`148`	`return;`
`150`	`149`	`}`
`151`		`- if (testFiltering(counter.leftTuple, rightTuple)) {`
	`150`	`+ if (testFiltering(leftTuple, rightTuple)) {`
`152`	`151`	`incrementCounterRight(counter);`
`153`	`152`	`new ExistsCounterHandle<>(counter, rightHandleSet);`
`154`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ private void updateCounterRight(LeftTuple_ leftTuple, Object indexKeys, ExistsCo`
`68`	`68`	`if (!isFiltering) {`
`69`	`69`	`counter.countRight = indexerRight.size(indexKeys);`
`70`	`70`	`} else {`
`71`		`- indexerRight.forEach(indexKeys, rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter));`
	`71`	`+ indexerRight.forEach(indexKeys, rightTuple -> updateCounterFromLeft(counter, rightTuple));`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`@@ -91,7 +91,7 @@ public final void updateLeft(LeftTuple_ leftTuple) {`
`91`	`91`	`} else {`
`92`	`92`	`// Call filtering for the leftTuple and rightTuple combinations again`
`93`	`93`	`counter.clearIncludingCount();`
`94`		`- indexerRight.forEach(oldIndexKeys, rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter));`
	`94`	`+ indexerRight.forEach(oldIndexKeys, rightTuple -> updateCounterFromLeft(counter, rightTuple));`
`95`	`95`	`updateCounterLeft(counter);`
`96`	`96`	`}`
`97`	`97`	`} else {`
`@@ -142,7 +142,7 @@ private void updateCounterLeft(UniTuple<Right_> rightTuple, Object indexKeys) {`
`142`	`142`	`indexerLeft.forEach(indexKeys, this::incrementCounterRight);`
`143`	`143`	`} else {`
`144`	`144`	`var rightHandleSet = new IndexedSet<ExistsCounterHandle<LeftTuple_>>(ExistsCounterHandlePositionTracker.right());`
`145`		`- indexerLeft.forEach(indexKeys, counter -> updateCounterFromRight(rightTuple, counter, rightHandleSet));`
	`145`	`+ indexerLeft.forEach(indexKeys, counter -> updateCounterFromRight(counter, rightTuple, rightHandleSet));`
`146`	`146`	`rightTuple.setStore(inputStoreIndexRightHandleSet, rightHandleSet);`
`147`	`147`	`}`
`148`	`148`	`}`
`@@ -161,7 +161,7 @@ public final void updateRight(UniTuple<Right_> rightTuple) {`
`161`	`161`	`if (isFiltering) {`
`162`	`162`	`var rightHandleSet = updateRightHandleSet(rightTuple);`
`163`	`163`	`indexerLeft.forEach(oldIndexKeys,`
`164`		`- counter -> updateCounterFromRight(rightTuple, counter, rightHandleSet));`
	`164`	`+ counter -> updateCounterFromRight(counter, rightTuple, rightHandleSet));`
`165`	`165`	`}`
`166`	`166`	`} else {`
`167`	`167`	`indexerRight.remove(oldIndexKeys, rightTuple);`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public final void insertLeft(LeftTuple_ leftTuple) {`
`49`	`49`	`if (!isFiltering) {`
`50`	`50`	`counter.countRight = rightTupleSet.size();`
`51`	`51`	`} else {`
`52`		`- rightTupleSet.forEach(tuple -> updateCounterFromLeft(leftTuple, tuple, counter));`
	`52`	`+ rightTupleSet.forEach(tuple -> updateCounterFromLeft(counter, tuple));`
`53`	`53`	`}`
`54`	`54`	`initCounterLeft(counter);`
`55`	`55`	`}`
`@@ -68,7 +68,7 @@ public final void updateLeft(LeftTuple_ leftTuple) {`
`68`	`68`	`} else {`
`69`	`69`	`// Call filtering for the leftTuple and rightTuple combinations again`
`70`	`70`	`counter.clearIncludingCount();`
`71`		`- rightTupleSet.forEach(tuple -> updateCounterFromLeft(leftTuple, tuple, counter));`
	`71`	`+ rightTupleSet.forEach(tuple -> updateCounterFromLeft(counter, tuple));`
`72`	`72`	`updateCounterLeft(counter);`
`73`	`73`	`}`
`74`	`74`	`}`
`@@ -99,7 +99,7 @@ public final void insertRight(UniTuple<Right_> rightTuple) {`
`99`	`99`	`leftCounterSet.forEach(this::incrementCounterRight);`
`100`	`100`	`} else {`
`101`	`101`	`var rightHandleSet = new IndexedSet<ExistsCounterHandle<LeftTuple_>>(ExistsCounterHandlePositionTracker.right());`
`102`		`- leftCounterSet.forEach(tuple -> updateCounterFromRight(rightTuple, tuple, rightHandleSet));`
	`102`	`+ leftCounterSet.forEach(counter -> updateCounterFromRight(counter, rightTuple, rightHandleSet));`
`103`	`103`	`rightTuple.setStore(inputStoreIndexRightHandleSet, rightHandleSet);`
`104`	`104`	`}`
`105`	`105`	`}`
`@@ -113,7 +113,7 @@ public final void updateRight(UniTuple<Right_> rightTuple) {`
`113`	`113`	`}`
`114`	`114`	`if (isFiltering) {`
`115`	`115`	`var rightHandleSet = updateRightHandleSet(rightTuple);`
`116`		`- leftCounterSet.forEach(tuple -> updateCounterFromRight(rightTuple, tuple, rightHandleSet));`
	`116`	`+ leftCounterSet.forEach(counter -> updateCounterFromRight(counter, rightTuple, rightHandleSet));`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`