Smaller optimizations

Author: triceo

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

@@ -7,6 +7,8 @@
 import ai.timefold.solver.core.impl.score.stream.collector.connected_ranges.ConnectedRangeTracker;
 import ai.timefold.solver.core.impl.score.stream.collector.connected_ranges.Range;
 
+import org.jspecify.annotations.Nullable;
+
 public abstract class AbstractConnectedRangesSlot<Interval_, Point_ extends Comparable<Point_>, Difference_ extends Comparable<Difference_>> {
 
     public static final class State<Interval_, Point_ extends Comparable<Point_>, Difference_ extends Comparable<Difference_>> {
@@ -24,22 +26,20 @@ public ConnectedRangeChain<Interval_, Point_, Difference_> result() {
     }
 
     private final State<Interval_, Point_, Difference_> state;
-    private Range<Interval_, Point_> cachedRange;
+    private @Nullable Range<Interval_, Point_> cachedRange;
 
     public AbstractConnectedRangesSlot(State<Interval_, Point_, Difference_> state) {
         this.state = state;
     }
 
     protected void addMapped(Interval_ result) {
-        final var saved = state.context.getRange(result);
-        cachedRange = saved;
-        state.context.add(saved);
+        cachedRange = state.context.getRange(result);
+        state.context.add(cachedRange);
     }
 
     protected void updateMapped(Interval_ input) {
-        state.context.remove(cachedRange);
-        cachedRange = state.context.getRange(input);
-        state.context.add(cachedRange);
+        removeMapped();
+        addMapped(input);
     }
 
     protected void removeMapped() {

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

@@ -3,10 +3,16 @@
 public abstract class AbstractCountSlot {
 
     public static final class State {
-        long count = 0;
+        private long count = 0;
+        private long cachedCount = 0;
+        private Long boxed = 0L;
 
         public Long result() {
-            return count;
+            if (cachedCount != count) { // Minimize boxing overhead.
+                boxed = count;
+                cachedCount = count;
+            }
+            return boxed;
         }
     }
 

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

@@ -3,8 +3,8 @@
 public abstract class AbstractLongAverageSlot {
 
     public static final class State {
-        long count = 0;
-        long sum = 0;
+        private long count = 0;
+        private long sum = 0;
 
         public Double result() {
             if (count == 0) {

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

@@ -11,11 +11,21 @@
 public abstract class AbstractLongDistinctSlot<Input_> {
 
     public static final class State<Input_> {
+
         private final Map<Input_, MutableInt> countMap = new HashMap<>();
+        private long cachedSize = 0;
+        private @Nullable Long boxed = 0L;
 
         public Long result() {
-            return (long) countMap.size();
+            var newSize = countMap.size();
+            if (cachedSize != newSize) {
+                // The collector's result is generic, we need to avoid boxing overhead as much as possible.
+                cachedSize = newSize;
+                boxed = (long) newSize;
+            }
+            return boxed;
         }
+
     }
 
     private final State<Input_> state;

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

@@ -3,10 +3,16 @@
 public abstract class AbstractLongSumSlot {
 
     public static final class State {
-        long sum = 0;
+        private long sum = 0;
+        private long cachedSum = 0;
+        private Long boxed = 0L;
 
         public Long result() {
-            return sum;
+            if (cachedSum != sum) { // Minimize boxing overhead.
+                boxed = sum;
+                cachedSum = sum;
+            }
+            return boxed;
         }
     }
 

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

@@ -11,13 +11,15 @@
 import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
 import ai.timefold.solver.core.impl.util.MutableInt;
 
+import org.jspecify.annotations.Nullable;
+
 public abstract class AbstractMinMaxSlot<Result_, Property_> {
     public static final class State<Result_, Property_> {
-        final boolean isMin;
-        final NavigableMap<Property_, Map<Result_, MutableInt>> propertyToItemCountMap;
-        final Function<? super Result_, ? extends Property_> propertyFunction;
+        private final boolean isMin;
+        private final NavigableMap<Property_, Map<Result_, MutableInt>> propertyToItemCountMap;
+        private final Function<? super Result_, ? extends Property_> propertyFunction;
 
-        State(boolean isMin, NavigableMap<Property_, Map<Result_, MutableInt>> propertyToItemCountMap,
+        private State(boolean isMin, NavigableMap<Property_, Map<Result_, MutableInt>> propertyToItemCountMap,
                 Function<? super Result_, ? extends Property_> propertyFunction) {
             this.isMin = isMin;
             this.propertyToItemCountMap = propertyToItemCountMap;
@@ -64,10 +66,10 @@ public static <Result, Property extends Comparable<? super Property>> State<Resu
     }
 
     private final State<Result_, Property_> state;
-    private Result_ cachedItem;
-    private Property_ cachedKey;
-    private Map<Result_, MutableInt> cachedInnerMap;
-    private MutableInt cachedCount;
+    private @Nullable Result_ cachedItem;
+    private @Nullable Property_ cachedKey;
+    private @Nullable Map<Result_, MutableInt> cachedInnerMap;
+    private @Nullable MutableInt cachedCount;
 
     public AbstractMinMaxSlot(State<Result_, Property_> state) {
         this.state = state;

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

@@ -8,11 +8,13 @@
 import java.util.function.BinaryOperator;
 import java.util.function.Supplier;
 
+import org.jspecify.annotations.Nullable;
+
 public abstract class AbstractReferenceAverageSlot<Input_, Output_> {
 
     public static final class State<Input_, Output_> {
-        int count = 0;
-        Input_ sum;
+        private int count = 0;
+        private Input_ sum;
         final BinaryOperator<Input_> adder;
         final BinaryOperator<Input_> subtractor;
         final BiFunction<Input_, Integer, Output_> divider;
@@ -34,7 +36,7 @@ public Output_ result() {
     }
 
     private final State<Input_, Output_> state;
-    private Input_ cachedValue;
+    private @Nullable Input_ cachedValue;
 
     private final static Supplier<State<BigDecimal, BigDecimal>> BIG_DECIMAL =
             () -> new State<>(BigDecimal.ZERO, BigDecimal::add, BigDecimal::subtract,

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

@@ -2,12 +2,14 @@
 
 import java.util.function.BinaryOperator;
 
+import org.jspecify.annotations.Nullable;
+
 public abstract class AbstractReferenceSumSlot<Result_> {
 
     public static final class State<Result_> {
-        Result_ current;
-        final BinaryOperator<Result_> adder;
-        final BinaryOperator<Result_> subtractor;
+        private Result_ current;
+        private final BinaryOperator<Result_> adder;
+        private final BinaryOperator<Result_> subtractor;
 
         public State(Result_ zero, BinaryOperator<Result_> adder, BinaryOperator<Result_> subtractor) {
             this.current = zero;
@@ -21,7 +23,7 @@ public Result_ result() {
     }
 
     private final State<Result_> state;
-    private Result_ cachedValue;
+    private @Nullable Result_ cachedValue;
 
     public AbstractReferenceSumSlot(State<Result_> state) {
         this.state = state;

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

@@ -7,6 +7,8 @@
 import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
 import ai.timefold.solver.core.impl.score.stream.collector.consecutive.ConsecutiveSetTree;
 
+import org.jspecify.annotations.Nullable;
+
 public abstract class AbstractSequenceSlot<Result_> {
 
     public static final class State<Result_> {
@@ -25,7 +27,7 @@ public SequenceChain<Result_, Integer> result() {
     }
 
     private final State<Result_> state;
-    private Result_ cachedValue;
+    private @Nullable Result_ cachedValue;
 
     public AbstractSequenceSlot(State<Result_> state) {
         this.state = state;

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

@@ -8,9 +8,11 @@
 
 import ai.timefold.solver.core.impl.util.MutableInt;
 
+import org.jspecify.annotations.Nullable;
+
 public abstract class AbstractSortedSetSlot<Mapped_> {
     public static final class State<Mapped_> {
-        final NavigableMap<Mapped_, MutableInt> itemToCount;
+        private final NavigableMap<Mapped_, MutableInt> itemToCount;
 
         public State(Comparator<? super Mapped_> comparator) {
             this.itemToCount = new TreeMap<>(comparator);
@@ -22,8 +24,8 @@ public NavigableSet<Mapped_> result() {
     }
 
     private final State<Mapped_> state;
-    private Mapped_ cachedValue;
-    private MutableInt cachedCount;
+    private @Nullable Mapped_ cachedValue;
+    private @Nullable MutableInt cachedCount;
 
     public AbstractSortedSetSlot(State<Mapped_> state) {
         this.state = state;