Revert "keep just one leaf"

This reverts commit 4ad849b.

Author: triceo

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

@@ -483,7 +483,8 @@ public UniKeysExtractor<Right_> buildRightKeysExtractor() {
     }
 
     public <T> Indexer<T> buildIndexer(boolean isLeftBridge) {
-        Supplier<Indexer<T>> backendSupplier = RandomAccessLeafIndexer::new;
+        Supplier<Indexer<T>> backendSupplier =
+                requiresRandomAccess ? RandomAccessLeafIndexer::new : LinkedListLeafIndexer::new;
         if (!hasJoiners()) { // NoneJoiner results in a bare backend (NoneIndexer).
             return backendSupplier.get();
         }
@@ -516,7 +517,8 @@ 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(), RandomAccessLeafIndexer::new);
+                    downstreamIndexerSupplier = () -> new EqualIndexer<>(KeyUnpacker.single(),
+                            requiresRandomAccess ? RandomAccessLeafIndexer::new : LinkedListLeafIndexer::new);
                 } else {
                     KeyUnpacker<?> keyUnpacker = KeyUnpacker.single();
                     downstreamIndexerSupplier = () -> buildIndexerPart(isLeftBridge, joinerType, keyUnpacker, backendSupplier);
@@ -559,12 +561,11 @@ 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, RandomAccessLeafIndexer::new,
-                    RandomAccessLeafIndexer::new);
+            return new FusedEqualIndex<>(topEqualKeyUnpacker, false, LinkedListLeafIndexer::new, LinkedListLeafIndexer::new);
         } else {
             // Equal prefix + suffix: build the per-side suffix sub-chain (the right side flips comparisons).
-            var leftDownstreamSupplier = this.<L> buildIndexerChain(true, 1, RandomAccessLeafIndexer::new);
-            var rightDownstreamSupplier = this.<R> buildIndexerChain(false, 1, RandomAccessLeafIndexer::new);
+            var leftDownstreamSupplier = this.<L> buildIndexerChain(true, 1, LinkedListLeafIndexer::new);
+            var rightDownstreamSupplier = this.<R> buildIndexerChain(false, 1, LinkedListLeafIndexer::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 {
+        permits RandomAccessLeafIndexer, LinkedListLeafIndexer {
 
 }

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

@@ -0,0 +1,68 @@
+package ai.timefold.solver.core.impl.bavet.common.index;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.random.RandomGenerator;
+
+import ai.timefold.solver.core.impl.util.ElementAwareLinkedList;
+import ai.timefold.solver.core.impl.util.ListEntry;
+
+import org.jspecify.annotations.NullMarked;
+
+/**
+ * Super-fast, but doesn't support random access.
+ *
+ * @param <T>
+ */
+@NullMarked
+public final class LinkedListLeafIndexer<T> implements LeafIndexer<T> {
+
+    private final ElementAwareLinkedList<T> tupleList = new ElementAwareLinkedList<>();
+
+    @Override
+    public ListEntry<T> put(Object compositeKey, T tuple) {
+        return tupleList.add(tuple);
+    }
+
+    @Override
+    public void remove(Object compositeKey, ListEntry<T> entry) {
+        tupleList.remove((ElementAwareLinkedList.Entry<T>) entry);
+    }
+
+    @Override
+    public int size(Object compositeKey) {
+        return tupleList.size();
+    }
+
+    @Override
+    public void forEach(Object compositeKey, Consumer<T> tupleConsumer) {
+        tupleList.forEach(tupleConsumer);
+    }
+
+    @Override
+    public Iterator<T> iterator(Object queryCompositeKey) {
+        return tupleList.iterator();
+    }
+
+    @Override
+    public Iterator<T> randomIterator(Object queryCompositeKey, RandomGenerator workingRandom) { // Neighborhoods will not get here.
+        throw new UnsupportedOperationException("Impossible state: This backend does not support random access.");
+    }
+
+    @Override
+    public Iterator<T> randomIterator(Object queryCompositeKey, RandomGenerator workingRandom, Predicate<T> filter) { // Neighborhoods will not get here.
+        throw new UnsupportedOperationException("Impossible state: This backend does not support random access.");
+    }
+
+    @Override
+    public boolean isRemovable() {
+        return tupleList.size() == 0;
+    }
+
+    @Override
+    public String toString() {
+        return "size = " + tupleList.size();
+    }
+
+}

core/src/test/java/ai/timefold/solver/core/impl/bavet/common/index/FusedEqualIndexTest.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
-                RandomAccessLeafIndexer::new,
+                LinkedListLeafIndexer::new,
                 () -> {
                     rightInitCount.incrementAndGet();
-                    return new RandomAccessLeafIndexer<>();
+                    return new LinkedListLeafIndexer<>();
                 });
 
         // right downstream must NOT be allocated on bucket creation