Third wave of incrementality

# Conflicts:
#	core/src/main/java/ai/timefold/solver/core/impl/score/stream/collector/ListUndoableActionable.java

Author: triceo

core/src/main/java/ai/timefold/solver/core/impl/score/stream/collector/CustomCollectionUndoableActionable.java

@@ -6,28 +6,41 @@
 import java.util.function.IntFunction;
 
 public final class CustomCollectionUndoableActionable<Mapped_, Result_ extends Collection<Mapped_>>
-        implements UndoableActionable<Mapped_, Result_> {
-    private final IntFunction<Result_> collectionFunction;
-    private final List<Mapped_> resultList = new ArrayList<>();
+        implements UndoableActionable<Mapped_> {
+    public static final class State<Mapped_, Collection_ extends Collection<Mapped_>> {
+        private final IntFunction<Collection_> collectionFunction;
+        final List<Mapped_> list = new ArrayList<>();
 
-    public CustomCollectionUndoableActionable(IntFunction<Result_> collectionFunction) {
-        this.collectionFunction = collectionFunction;
+        public State(IntFunction<Collection_> collectionFunction) {
+            this.collectionFunction = collectionFunction;
+        }
+
+        public Collection_ result() {
+            Collection_ out = collectionFunction.apply(list.size());
+            if (list.isEmpty()) {
+                // Avoid exception if out is an immutable collection
+                return out;
+            }
+            out.addAll(list);
+            return out;
+        }
+    }
+
+    private final State<Mapped_, Result_> state;
+    private Mapped_ cachedValue;
+
+    public CustomCollectionUndoableActionable(State<Mapped_, Result_> state) {
+        this.state = state;
     }
 
     @Override
-    public Runnable insert(Mapped_ result) {
-        resultList.add(result);
-        return () -> resultList.remove(result);
+    public void insert(Mapped_ result) {
+        cachedValue = result;
+        state.list.add(result);
     }
 
     @Override
-    public Result_ result() {
-        Result_ out = collectionFunction.apply(resultList.size());
-        if (resultList.isEmpty()) {
-            // Avoid exception if out is an immutable collection
-            return out;
-        }
-        out.addAll(resultList);
-        return out;
+    public void retract() {
+        state.list.remove(cachedValue);
     }
 }

core/src/main/java/ai/timefold/solver/core/impl/score/stream/collector/ListUndoableActionable.java

@@ -1,25 +1,42 @@
 package ai.timefold.solver.core.impl.score.stream.collector;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
-import ai.timefold.solver.core.impl.util.ElementAwareArrayList;
+public final class ListUndoableActionable<Mapped_> implements UndoableActionable<Mapped_> {
+    public static final class State<Mapped_> {
+        final List<Mapped_> resultList = new ArrayList<>();
 
-public final class ListUndoableActionable<Mapped_> implements UndoableActionable<Mapped_, List<Mapped_>> {
+        public List<Mapped_> result() {
+            return resultList;
+        }
+    }
+
+    private final State<Mapped_> state;
+    private Mapped_ cachedValue;
+
+    public ListUndoableActionable(State<Mapped_> state) {
+        this.state = state;
+    }
 
-    /**
-     * As long as additions and removals are performed using entry-based methods,
-     * removals have O(1) performance.
-     */
-    private final ElementAwareArrayList<Mapped_> resultList = new ElementAwareArrayList<>();
+    @Override
+    public void insert(Mapped_ mapped) {
+        cachedValue = mapped;
+        state.resultList.add(mapped);
+    }
 
     @Override
-    public Runnable insert(Mapped_ result) {
-        var entry = resultList.addEntry(result);
-        return entry::remove;
+    public void update(Mapped_ mapped) {
+        if (Objects.equals(cachedValue, mapped)) {
+            return;
+        }
+        state.resultList.set(state.resultList.indexOf(cachedValue), mapped);
+        cachedValue = mapped;
     }
 
     @Override
-    public List<Mapped_> result() {
-        return resultList;
+    public void retract() {
+        state.resultList.remove(cachedValue);
     }
 }

core/src/main/java/ai/timefold/solver/core/impl/score/stream/collector/MapUndoableActionable.java

@@ -1,6 +1,7 @@
 package ai.timefold.solver.core.impl.score.stream.collector;
 
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.function.BinaryOperator;
 import java.util.function.IntFunction;
@@ -9,33 +10,54 @@
 import ai.timefold.solver.core.impl.util.Pair;
 
 public final class MapUndoableActionable<Key_, Value_, ResultValue_, Result_ extends Map<Key_, ResultValue_>>
-        implements UndoableActionable<Pair<Key_, Value_>, Result_> {
-    ToMapResultContainer<Key_, Value_, ResultValue_, Result_> container;
+        implements UndoableActionable<Pair<Key_, Value_>> {
+    public static final class State<Key_, Value_, ResultValue_, Result_ extends Map<Key_, ResultValue_>> {
+        final ToMapResultContainer<Key_, Value_, ResultValue_, Result_> container;
 
-    private MapUndoableActionable(ToMapResultContainer<Key_, Value_, ResultValue_, Result_> container) {
-        this.container = container;
+        State(ToMapResultContainer<Key_, Value_, ResultValue_, Result_> container) {
+            this.container = container;
+        }
+
+        public Result_ result() {
+            return container.getResult();
+        }
     }
 
     public static <Key_, Value_, Set_ extends Set<Value_>, Result_ extends Map<Key_, Set_>>
-            MapUndoableActionable<Key_, Value_, Set_, Result_> multiMap(
-                    Supplier<Result_> resultSupplier, IntFunction<Set_> setFunction) {
-        return new MapUndoableActionable<>(new ToMultiMapResultContainer<>(resultSupplier, setFunction));
+            State<Key_, Value_, Set_, Result_> multiMapState(Supplier<Result_> resultSupplier, IntFunction<Set_> setFunction) {
+        return new State<>(new ToMultiMapResultContainer<>(resultSupplier, setFunction));
+    }
+
+    public static <Key_, Value_, Result_ extends Map<Key_, Value_>>
+            State<Key_, Value_, Value_, Result_>
+            mergeMapState(Supplier<Result_> resultSupplier, BinaryOperator<Value_> mergeFunction) {
+        return new State<>(new ToSimpleMapResultContainer<>(resultSupplier, mergeFunction));
     }
 
-    public static <Key_, Value_, Result_ extends Map<Key_, Value_>> MapUndoableActionable<Key_, Value_, Value_, Result_>
-            mergeMap(
-                    Supplier<Result_> resultSupplier, BinaryOperator<Value_> mergeFunction) {
-        return new MapUndoableActionable<>(new ToSimpleMapResultContainer<>(resultSupplier, mergeFunction));
+    private final State<Key_, Value_, ResultValue_, Result_> state;
+    private Pair<Key_, Value_> cachedEntry;
+
+    public MapUndoableActionable(State<Key_, Value_, ResultValue_, Result_> state) {
+        this.state = state;
+    }
+
+    @Override
+    public void insert(Pair<Key_, Value_> entry) {
+        this.cachedEntry = entry;
+        state.container.add(entry.key(), entry.value());
     }
 
     @Override
-    public Runnable insert(Pair<Key_, Value_> entry) {
-        container.add(entry.key(), entry.value());
-        return () -> container.remove(entry.key(), entry.value());
+    public void update(Pair<Key_, Value_> entry) {
+        if (Objects.equals(cachedEntry, entry)) {
+            return;
+        }
+        retract();
+        insert(entry);
     }
 
     @Override
-    public Result_ result() {
-        return container.getResult();
+    public void retract() {
+        state.container.remove(cachedEntry.key(), cachedEntry.value());
     }
 }

core/src/main/java/ai/timefold/solver/core/impl/score/stream/collector/MinMaxUndoableActionable.java

@@ -4,80 +4,105 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.NavigableMap;
+import java.util.Objects;
 import java.util.TreeMap;
 import java.util.function.Function;
 
 import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
 import ai.timefold.solver.core.impl.util.MutableInt;
 
-public final class MinMaxUndoableActionable<Result_, Property_> implements UndoableActionable<Result_, Result_> {
-    private final boolean isMin;
-    private final NavigableMap<Property_, Map<Result_, MutableInt>> propertyToItemCountMap;
-    private final Function<? super Result_, ? extends Property_> propertyFunction;
-
-    private MinMaxUndoableActionable(boolean isMin,
-            NavigableMap<Property_, Map<Result_, MutableInt>> propertyToItemCountMap,
-            Function<? super Result_, ? extends Property_> propertyFunction) {
-        this.isMin = isMin;
-        this.propertyToItemCountMap = propertyToItemCountMap;
-        this.propertyFunction = propertyFunction;
+public final class MinMaxUndoableActionable<Result_, Property_> implements UndoableActionable<Result_> {
+    public static final class State<Result_, Property_> {
+        final boolean isMin;
+        final NavigableMap<Property_, Map<Result_, MutableInt>> propertyToItemCountMap;
+        final Function<? super Result_, ? extends Property_> propertyFunction;
+
+        State(boolean isMin, NavigableMap<Property_, Map<Result_, MutableInt>> propertyToItemCountMap,
+                Function<? super Result_, ? extends Property_> propertyFunction) {
+            this.isMin = isMin;
+            this.propertyToItemCountMap = propertyToItemCountMap;
+            this.propertyFunction = propertyFunction;
+        }
+
+        public Result_ result() {
+            if (propertyToItemCountMap.isEmpty()) {
+                return null;
+            }
+            return isMin ? getFirstKey(propertyToItemCountMap.firstEntry().getValue())
+                    : getFirstKey(propertyToItemCountMap.lastEntry().getValue());
+        }
+
+        private static <Key_> Key_ getFirstKey(Map<Key_, ?> map) {
+            return map.keySet().iterator().next();
+        }
     }
 
-    public static <Result extends Comparable<? super Result>> MinMaxUndoableActionable<Result, Result> minCalculator() {
-        return new MinMaxUndoableActionable<>(true, new TreeMap<>(), ConstantLambdaUtils.identity());
+    public static <Result extends Comparable<? super Result>> State<Result, Result> minState() {
+        return new State<>(true, new TreeMap<>(), ConstantLambdaUtils.identity());
     }
 
-    public static <Result extends Comparable<? super Result>> MinMaxUndoableActionable<Result, Result> maxCalculator() {
-        return new MinMaxUndoableActionable<>(false, new TreeMap<>(), ConstantLambdaUtils.identity());
+    public static <Result extends Comparable<? super Result>> State<Result, Result> maxState() {
+        return new State<>(false, new TreeMap<>(), ConstantLambdaUtils.identity());
     }
 
-    public static <Result> MinMaxUndoableActionable<Result, Result> minCalculator(Comparator<? super Result> comparator) {
-        return new MinMaxUndoableActionable<>(true, new TreeMap<>(comparator), ConstantLambdaUtils.identity());
+    public static <Result> State<Result, Result> minState(Comparator<? super Result> comparator) {
+        return new State<>(true, new TreeMap<>(comparator), ConstantLambdaUtils.identity());
     }
 
-    public static <Result> MinMaxUndoableActionable<Result, Result> maxCalculator(Comparator<? super Result> comparator) {
-        return new MinMaxUndoableActionable<>(false, new TreeMap<>(comparator), ConstantLambdaUtils.identity());
+    public static <Result> State<Result, Result> maxState(Comparator<? super Result> comparator) {
+        return new State<>(false, new TreeMap<>(comparator), ConstantLambdaUtils.identity());
     }
 
-    public static <Result, Property extends Comparable<? super Property>> MinMaxUndoableActionable<Result, Property>
-            minCalculator(
-                    Function<? super Result, ? extends Property> propertyMapper) {
-        return new MinMaxUndoableActionable<>(true, new TreeMap<>(), propertyMapper);
+    public static <Result, Property extends Comparable<? super Property>> State<Result, Property> minState(
+            Function<? super Result, ? extends Property> propertyMapper) {
+        return new State<>(true, new TreeMap<>(), propertyMapper);
     }
 
-    public static <Result, Property extends Comparable<? super Property>> MinMaxUndoableActionable<Result, Property>
-            maxCalculator(
-                    Function<? super Result, ? extends Property> propertyMapper) {
-        return new MinMaxUndoableActionable<>(false, new TreeMap<>(), propertyMapper);
+    public static <Result, Property extends Comparable<? super Property>> State<Result, Property> maxState(
+            Function<? super Result, ? extends Property> propertyMapper) {
+        return new State<>(false, new TreeMap<>(), propertyMapper);
+    }
+
+    private final State<Result_, Property_> state;
+    private Result_ cachedItem;
+    private Property_ cachedKey;
+    private Map<Result_, MutableInt> cachedInnerMap;
+    private MutableInt cachedCount;
+
+    public MinMaxUndoableActionable(State<Result_, Property_> state) {
+        this.state = state;
     }
 
     @Override
-    public Runnable insert(Result_ item) {
-        Property_ key = propertyFunction.apply(item);
-        Map<Result_, MutableInt> itemCountMap = propertyToItemCountMap.computeIfAbsent(key, ignored -> new LinkedHashMap<>());
-        MutableInt count = itemCountMap.computeIfAbsent(item, ignored -> new MutableInt());
-        count.increment();
-
-        return () -> {
-            if (count.decrement() == 0) {
-                itemCountMap.remove(item);
-                if (itemCountMap.isEmpty()) {
-                    propertyToItemCountMap.remove(key);
-                }
-            }
-        };
+    public void insert(Result_ item) {
+        cachedItem = item;
+        cachedKey = state.propertyFunction.apply(item);
+        cachedInnerMap = state.propertyToItemCountMap.computeIfAbsent(cachedKey, ignored -> new LinkedHashMap<>());
+        cachedCount = cachedInnerMap.computeIfAbsent(item, ignored -> new MutableInt());
+        cachedCount.increment();
     }
 
     @Override
-    public Result_ result() {
-        if (propertyToItemCountMap.isEmpty()) {
-            return null;
+    public void update(Result_ item) {
+        var newKey = state.propertyFunction.apply(item);
+        if (Objects.equals(cachedKey, newKey)) {
+            return;
         }
-        return isMin ? getFirstKey(propertyToItemCountMap.firstEntry().getValue())
-                : getFirstKey(propertyToItemCountMap.lastEntry().getValue());
+        retract();
+        cachedItem = item;
+        cachedKey = newKey;
+        cachedInnerMap = state.propertyToItemCountMap.computeIfAbsent(newKey, ignored -> new LinkedHashMap<>());
+        cachedCount = cachedInnerMap.computeIfAbsent(item, ignored -> new MutableInt());
+        cachedCount.increment();
     }
 
-    private static <Key_> Key_ getFirstKey(Map<Key_, ?> map) {
-        return map.keySet().iterator().next();
+    @Override
+    public void retract() {
+        if (cachedCount.decrement() == 0) {
+            cachedInnerMap.remove(cachedItem);
+            if (cachedInnerMap.isEmpty()) {
+                state.propertyToItemCountMap.remove(cachedKey);
+            }
+        }
     }
 }