revert last commit

Author: triceo

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

@@ -483,8 +483,7 @@ public UniKeysExtractor<Right_> buildRightKeysExtractor() {
     }
 
     public <T> Indexer<T> buildIndexer(boolean isLeftBridge) {
-        Supplier<Indexer<T>> backendSupplier =
-                requiresRandomAccess ? RandomAccessLeafIndexer::new : LinkedListLeafIndexer::new;
+        Supplier<Indexer<T>> backendSupplier = RandomAccessLeafIndexer::new;
         if (!hasJoiners()) { // NoneJoiner results in a bare backend (NoneIndexer).
             return backendSupplier.get();
         }
@@ -517,8 +516,7 @@ private <T> Supplier<Indexer<T>> buildIndexerChain(boolean isLeftBridge, int fro
                 // Leaf-most level whose index key equals the whole composite key: no KeyUnpacker indirection.
                 if (joinerType == JoinerType.EQUAL) {
                     // Fuse the leaf-most equal indexer with its backend.
-                    downstreamIndexerSupplier = () -> new EqualIndexer<>(KeyUnpacker.single(),
-                            requiresRandomAccess ? RandomAccessLeafIndexer::new : LinkedListLeafIndexer::new);
+                    downstreamIndexerSupplier = () -> new EqualIndexer<>(KeyUnpacker.single(), RandomAccessLeafIndexer::new);
                 } else {
                     KeyUnpacker<?> keyUnpacker = KeyUnpacker.single();
                     downstreamIndexerSupplier = () -> buildIndexerPart(isLeftBridge, joinerType, keyUnpacker, backendSupplier);
@@ -561,11 +559,12 @@ public <L, R> FusedEqualIndex<L, R> buildFusedEqualIndex() {
                 equalPrefixLength == joinerCount ? KeyUnpacker.single() : KeyUnpacker.composite(0);
         if (equalPrefixLength == joinerCount) {
             // Pure equal: the per-side downstream is just the tuple list; the bucket is the equal-key group.
-            return new FusedEqualIndex<>(topEqualKeyUnpacker, false, LinkedListLeafIndexer::new, LinkedListLeafIndexer::new);
+            return new FusedEqualIndex<>(topEqualKeyUnpacker, false, RandomAccessLeafIndexer::new,
+                    RandomAccessLeafIndexer::new);
         } else {
             // Equal prefix + suffix: build the per-side suffix sub-chain (the right side flips comparisons).
-            var leftDownstreamSupplier = this.<L> buildIndexerChain(true, 1, LinkedListLeafIndexer::new);
-            var rightDownstreamSupplier = this.<R> buildIndexerChain(false, 1, LinkedListLeafIndexer::new);
+            var leftDownstreamSupplier = this.<L> buildIndexerChain(true, 1, RandomAccessLeafIndexer::new);
+            var rightDownstreamSupplier = this.<R> buildIndexerChain(false, 1, RandomAccessLeafIndexer::new);
             return new FusedEqualIndex<>(topEqualKeyUnpacker, true, leftDownstreamSupplier, rightDownstreamSupplier);
         }
     }

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

@@ -12,6 +12,6 @@
 @NullMarked
 public sealed interface LeafIndexer<T>
         extends Indexer<T>
-        permits RandomAccessLeafIndexer, LinkedListLeafIndexer {
+        permits RandomAccessLeafIndexer {
 
 }

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

@@ -127,10 +127,10 @@ void lazyAllocation_leftOnlyKey_rightNotAllocated() {
         var index = new FusedEqualIndex<String, String>(
                 KeyUnpacker.single(), // identity: pure-equal, single-component key
                 false, // hasSuffix
-                LinkedListLeafIndexer::new,
+                RandomAccessLeafIndexer::new,
                 () -> {
                     rightInitCount.incrementAndGet();
-                    return new LinkedListLeafIndexer<>();
+                    return new RandomAccessLeafIndexer<>();
                 });
 
         // right downstream must NOT be allocated on bucket creation