chore: simplify the selection sorting contract

zepfred · zepfred · commit 934bf948381e · 2025-10-28T10:56:13.000-03:00
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/common/decorator/ComparatorFactorySelectionSorter.java b/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/common/decorator/ComparatorFactorySelectionSorter.java
@@ -7,7 +7,6 @@
 
 import ai.timefold.solver.core.api.domain.common.ComparatorFactory;
 import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
-import ai.timefold.solver.core.api.score.director.ScoreDirector;
 import ai.timefold.solver.core.config.heuristic.selector.common.decorator.SelectionSorterOrder;
 
 /**
@@ -35,9 +34,8 @@ private Comparator<T> getAppliedComparator(Comparator<T> comparator) {
     }
 
     @Override
-    public void sort(ScoreDirector<Solution_> scoreDirector, List<T> selectionList) {
-        var appliedComparator =
-                getAppliedComparator(selectionComparatorFactory.createComparator(scoreDirector.getWorkingSolution()));
+    public void sort(Solution_ solution, List<T> selectionList) {
+        var appliedComparator = getAppliedComparator(selectionComparatorFactory.createComparator(solution));
         selectionList.sort(appliedComparator);
     }
 
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/common/decorator/ComparatorSelectionSorter.java b/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/common/decorator/ComparatorSelectionSorter.java
@@ -6,7 +6,6 @@
 import java.util.Objects;
 
 import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
-import ai.timefold.solver.core.api.score.director.ScoreDirector;
 import ai.timefold.solver.core.config.heuristic.selector.common.decorator.SelectionSorterOrder;
 
 /**
@@ -34,7 +33,7 @@ public ComparatorSelectionSorter(Comparator<T> comparator, SelectionSorterOrder
     }
 
     @Override
-    public void sort(ScoreDirector<Solution_> scoreDirector, List<T> selectionList) {
+    public void sort(Solution_ solution, List<T> selectionList) {
         selectionList.sort(appliedComparator);
     }
 
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/common/decorator/SelectionSorter.java b/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/common/decorator/SelectionSorter.java
@@ -4,10 +4,11 @@
 
 import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
 import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
-import ai.timefold.solver.core.api.score.director.ScoreDirector;
 import ai.timefold.solver.core.impl.heuristic.move.Move;
 import ai.timefold.solver.core.impl.heuristic.selector.Selector;
 
+import org.jspecify.annotations.NullMarked;
+
 /**
  * Decides the order of a {@link List} of selection
  * (which is a {@link PlanningEntity}, a planningValue, a {@link Move} or a {@link Selector}).
@@ -19,15 +20,15 @@
  * @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
  * @param <T> the selection type
  */
+@NullMarked
 @FunctionalInterface
 public interface SelectionSorter<Solution_, T> {
 
     /**
-     * @param scoreDirector never null, the {@link ScoreDirector}
-     *        which has the {@link ScoreDirector#getWorkingSolution()} to which the selections belong or apply to
+     * @param solution never null, the current solution
      * @param selectionList never null, a {@link List}
      *        of {@link PlanningEntity}, planningValue, {@link Move} or {@link Selector}
      */
-    void sort(ScoreDirector<Solution_> scoreDirector, List<T> selectionList);
+    void sort(Solution_ solution, List<T> selectionList);
 
 }
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/entity/decorator/SortingEntitySelector.java b/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/entity/decorator/SortingEntitySelector.java
@@ -60,7 +60,7 @@ public void constructCache(SolverScope<Solution_> solverScope) {
             return;
         }
         super.constructCache(solverScope);
-        sorter.sort(solverScope.getScoreDirector(), cachedEntityList);
+        sorter.sort(solverScope.getScoreDirector().getWorkingSolution(), cachedEntityList);
         logger.trace("    Sorted cachedEntityList: size ({}), entitySelector ({}).",
                 cachedEntityList.size(), this);
     }
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/move/decorator/SortingMoveSelector.java b/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/move/decorator/SortingMoveSelector.java
@@ -25,7 +25,7 @@ public SortingMoveSelector(MoveSelector<Solution_> childMoveSelector, SelectionC
     @Override
     public void constructCache(SolverScope<Solution_> solverScope) {
         super.constructCache(solverScope);
-        sorter.sort(solverScope.getScoreDirector(), cachedMoveList);
+        sorter.sort(solverScope.getScoreDirector().getWorkingSolution(), cachedMoveList);
         logger.trace("    Sorted cachedMoveList: size ({}), moveSelector ({}).",
                 cachedMoveList.size(), this);
     }
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/value/decorator/FromEntitySortingValueSelector.java b/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/value/decorator/FromEntitySortingValueSelector.java
@@ -98,7 +98,7 @@ public Iterator<Object> iterator(Object entity) {
         childValueSelector.iterator(entity).forEachRemaining(cachedValueList::add);
         logger.trace("    Created cachedValueList: size ({}), valueSelector ({}).",
                 cachedValueList.size(), this);
-        sorter.sort(scoreDirector, cachedValueList);
+        sorter.sort(scoreDirector.getWorkingSolution(), cachedValueList);
         logger.trace("    Sorted cachedValueList: size ({}), valueSelector ({}).",
                 cachedValueList.size(), this);
         return cachedValueList.iterator();
diff --git a/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/value/decorator/SortingValueSelector.java b/core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/value/decorator/SortingValueSelector.java
@@ -27,7 +27,7 @@ public SortingValueSelector(IterableValueSelector<Solution_> childValueSelector,
     @Override
     public void constructCache(SolverScope<Solution_> solverScope) {
         super.constructCache(solverScope);
-        sorter.sort(solverScope.getScoreDirector(), cachedValueList);
+        sorter.sort(solverScope.getScoreDirector().getWorkingSolution(), cachedValueList);
         logger.trace("    Sorted cachedValueList: size ({}), valueSelector ({}).",
                 cachedValueList.size(), this);
     }
diff --git a/core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/common/decorator/ComparatorFactorySelectionSorterTest.java b/core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/common/decorator/ComparatorFactorySelectionSorterTest.java
@@ -1,14 +1,12 @@
 package ai.timefold.solver.core.impl.heuristic.selector.common.decorator;
 
 import static ai.timefold.solver.core.testutil.PlannerAssert.assertCodesOfIterator;
-import static org.mockito.Mockito.mock;
 
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 
 import ai.timefold.solver.core.api.domain.common.ComparatorFactory;
-import ai.timefold.solver.core.api.score.director.ScoreDirector;
 import ai.timefold.solver.core.config.heuristic.selector.common.decorator.SelectionSorterOrder;
 import ai.timefold.solver.core.testdomain.TestdataEntity;
 import ai.timefold.solver.core.testdomain.TestdataSolution;
@@ -24,13 +22,12 @@ void sortAscending() {
         ComparatorFactorySelectionSorter<TestdataSolution, TestdataEntity> selectionSorter =
                 new ComparatorFactorySelectionSorter<>(
                         comparatorFactory, SelectionSorterOrder.ASCENDING);
-        ScoreDirector<TestdataSolution> scoreDirector = mock(ScoreDirector.class);
         List<TestdataEntity> selectionList = new ArrayList<>();
         selectionList.add(new TestdataEntity("C"));
         selectionList.add(new TestdataEntity("A"));
         selectionList.add(new TestdataEntity("D"));
         selectionList.add(new TestdataEntity("B"));
-        selectionSorter.sort(scoreDirector, selectionList);
+        selectionSorter.sort(new TestdataSolution(), selectionList);
         assertCodesOfIterator(selectionList.iterator(), "A", "B", "C", "D");
     }
 
@@ -41,13 +38,12 @@ void sortDescending() {
         ComparatorFactorySelectionSorter<TestdataSolution, TestdataEntity> selectionSorter =
                 new ComparatorFactorySelectionSorter<>(
                         comparatorFactory, SelectionSorterOrder.DESCENDING);
-        ScoreDirector<TestdataSolution> scoreDirector = mock(ScoreDirector.class);
         List<TestdataEntity> selectionList = new ArrayList<>();
         selectionList.add(new TestdataEntity("C"));
         selectionList.add(new TestdataEntity("A"));
         selectionList.add(new TestdataEntity("D"));
         selectionList.add(new TestdataEntity("B"));
-        selectionSorter.sort(scoreDirector, selectionList);
+        selectionSorter.sort(new TestdataSolution(), selectionList);
         assertCodesOfIterator(selectionList.iterator(), "D", "C", "B", "A");
     }
 
diff --git a/core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/entity/decorator/SortingEntitySelectorTest.java b/core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/entity/decorator/SortingEntitySelectorTest.java
@@ -4,6 +4,7 @@
 import static ai.timefold.solver.core.testutil.PlannerAssert.verifyPhaseLifecycle;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -17,6 +18,7 @@
 import ai.timefold.solver.core.impl.heuristic.selector.entity.EntitySelector;
 import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
 import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
+import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
 import ai.timefold.solver.core.impl.solver.scope.SolverScope;
 import ai.timefold.solver.core.testdomain.TestdataEntity;
 import ai.timefold.solver.core.testdomain.TestdataObject;
@@ -56,6 +58,9 @@ public void runCacheType(SelectionCacheType cacheType, int timesCalled) {
         EntitySelector entitySelector = new SortingEntitySelector(childEntitySelector, cacheType, sorter);
 
         SolverScope solverScope = mock(SolverScope.class);
+        InnerScoreDirector<?, ?> scoreDirector = mock(InnerScoreDirector.class);
+        doReturn(scoreDirector).when(solverScope).getScoreDirector();
+        doReturn(new TestdataSolution()).when(scoreDirector).getWorkingSolution();
         entitySelector.solvingStarted(solverScope);
 
         AbstractPhaseScope phaseScopeA = mock(AbstractPhaseScope.class);
diff --git a/core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/move/decorator/SortingMoveSelectorTest.java b/core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/move/decorator/SortingMoveSelectorTest.java
@@ -5,6 +5,7 @@
 import static ai.timefold.solver.core.testutil.PlannerAssert.verifyPhaseLifecycle;
 import static ai.timefold.solver.core.testutil.PlannerTestUtils.mockScoreDirector;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -27,6 +28,7 @@
 import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
 import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
 import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
+import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
 import ai.timefold.solver.core.impl.solver.scope.SolverScope;
 import ai.timefold.solver.core.testdomain.TestdataSolution;
 import ai.timefold.solver.core.testutil.CodeAssertable;
@@ -109,6 +111,9 @@ public void runCacheType(SelectionCacheType cacheType, int timesCalled) {
         MoveSelector moveSelector = new SortingMoveSelector(childMoveSelector, cacheType, sorter);
 
         SolverScope solverScope = mock(SolverScope.class);
+        InnerScoreDirector<?, ?> scoreDirector = mock(InnerScoreDirector.class);
+        doReturn(scoreDirector).when(solverScope).getScoreDirector();
+        doReturn(new TestdataSolution()).when(scoreDirector).getWorkingSolution();
         moveSelector.solvingStarted(solverScope);
 
         AbstractPhaseScope phaseScopeA = mock(AbstractPhaseScope.class);
diff --git a/core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/value/decorator/SortingValueSelectorTest.java b/core/src/test/java/ai/timefold/solver/core/impl/heuristic/selector/value/decorator/SortingValueSelectorTest.java
@@ -2,6 +2,7 @@
 
 import static ai.timefold.solver.core.testutil.PlannerAssert.assertAllCodesOfValueSelector;
 import static ai.timefold.solver.core.testutil.PlannerAssert.verifyPhaseLifecycle;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -15,6 +16,7 @@
 import ai.timefold.solver.core.impl.heuristic.selector.value.IterableValueSelector;
 import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
 import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
+import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
 import ai.timefold.solver.core.impl.solver.scope.SolverScope;
 import ai.timefold.solver.core.testdomain.TestdataEntity;
 import ai.timefold.solver.core.testdomain.TestdataObject;
@@ -51,6 +53,9 @@ public void runOriginalSelection(SelectionCacheType cacheType, int timesCalled)
         IterableValueSelector valueSelector = new SortingValueSelector(childValueSelector, cacheType, sorter);
 
         SolverScope solverScope = mock(SolverScope.class);
+        InnerScoreDirector<?, ?> scoreDirector = mock(InnerScoreDirector.class);
+        doReturn(scoreDirector).when(solverScope).getScoreDirector();
+        doReturn(new TestdataSolution()).when(scoreDirector).getWorkingSolution();
         valueSelector.solvingStarted(solverScope);
 
         AbstractPhaseScope phaseScopeA = mock(AbstractPhaseScope.class);

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@`
`6`	`6`	`import java.util.Objects;`
`7`	`7`
`8`	`8`	`import ai.timefold.solver.core.api.domain.solution.PlanningSolution;`
`9`		`-import ai.timefold.solver.core.api.score.director.ScoreDirector;`
`10`	`9`	`import ai.timefold.solver.core.config.heuristic.selector.common.decorator.SelectionSorterOrder;`
`11`	`10`
`12`	`11`	`/**`
`@@ -34,7 +33,7 @@ public ComparatorSelectionSorter(Comparator<T> comparator, SelectionSorterOrder`
`34`	`33`	`}`
`35`	`34`
`36`	`35`	`@Override`
`37`		`- public void sort(ScoreDirector<Solution_> scoreDirector, List<T> selectionList) {`
	`36`	`+ public void sort(Solution_ solution, List<T> selectionList) {`
`38`	`37`	`selectionList.sort(appliedComparator);`
`39`	`38`	`}`
`40`	`39`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ public void constructCache(SolverScope<Solution_> solverScope) {`
`60`	`60`	`return;`
`61`	`61`	`}`
`62`	`62`	`super.constructCache(solverScope);`
`63`		`- sorter.sort(solverScope.getScoreDirector(), cachedEntityList);`
	`63`	`+ sorter.sort(solverScope.getScoreDirector().getWorkingSolution(), cachedEntityList);`
`64`	`64`	`logger.trace(" Sorted cachedEntityList: size ({}), entitySelector ({}).",`
`65`	`65`	`cachedEntityList.size(), this);`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public SortingMoveSelector(MoveSelector<Solution_> childMoveSelector, SelectionC`
`25`	`25`	`@Override`
`26`	`26`	`public void constructCache(SolverScope<Solution_> solverScope) {`
`27`	`27`	`super.constructCache(solverScope);`
`28`		`- sorter.sort(solverScope.getScoreDirector(), cachedMoveList);`
	`28`	`+ sorter.sort(solverScope.getScoreDirector().getWorkingSolution(), cachedMoveList);`
`29`	`29`	`logger.trace(" Sorted cachedMoveList: size ({}), moveSelector ({}).",`
`30`	`30`	`cachedMoveList.size(), this);`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public SortingValueSelector(IterableValueSelector<Solution_> childValueSelector,`
`27`	`27`	`@Override`
`28`	`28`	`public void constructCache(SolverScope<Solution_> solverScope) {`
`29`	`29`	`super.constructCache(solverScope);`
`30`		`- sorter.sort(solverScope.getScoreDirector(), cachedValueList);`
	`30`	`+ sorter.sort(solverScope.getScoreDirector().getWorkingSolution(), cachedValueList);`
`31`	`31`	`logger.trace(" Sorted cachedValueList: size ({}), valueSelector ({}).",`
`32`	`32`	`cachedValueList.size(), this);`
`33`	`33`	`}`