refactor: remove Solution_ generic from SolverConfigOverride

Author: triceo

core/src/main/java/ai/timefold/solver/core/api/solver/SolverConfigOverride.java

@@ -3,10 +3,10 @@
 import java.time.Duration;
 import java.util.Objects;
 
-import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
 import ai.timefold.solver.core.config.solver.termination.TerminationConfig;
 
-import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Includes settings to override default {@link ai.timefold.solver.core.api.solver.Solver} configuration.
@@ -22,15 +22,14 @@
  * it must be called before any specific termination methods like {@link #withTerminationSpentLimit(Duration)}
  * or {@link #withTerminationUnimprovedSpentLimit(Duration)}. This prevents accidental override of previously
  * set specific configurations.
- *
- * @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
  */
-public final class SolverConfigOverride<Solution_> {
+@NullMarked
+public final class SolverConfigOverride {
 
-    private TerminationConfig terminationConfig = null;
+    private @Nullable TerminationConfig terminationConfig = null;
     private boolean hasSpecificTerminationSettings = false;
 
-    public TerminationConfig getTerminationConfig() {
+    public @Nullable TerminationConfig getTerminationConfig() {
         return terminationConfig;
     }
 
@@ -40,33 +39,30 @@ public TerminationConfig getTerminationConfig() {
      * <p>
      * After calling this method, additional specific termination methods can be chained to further
      * customize the configuration:
-     * 
-     * <pre>{@code
-     * new SolverConfigOverride<MySolution>()
+     * {@snippet :
+     * new SolverConfigOverride()
      *         .withTerminationConfig(new TerminationConfig())
      *         .withTerminationSpentLimit(Duration.ofMinutes(5))
      *         .withTerminationUnimprovedSpentLimit(Duration.ofMinutes(2));
-     * }</pre>
+     * }
      *
      * <p>
      * <strong>Important:</strong> This method must be called before any specific termination methods
      * like {@link #withTerminationSpentLimit(Duration)} or {@link #withTerminationUnimprovedSpentLimit(Duration)}.
      * <p>
      * Calling this method after specific termination settings have been applied will throw an exception
      * to prevent accidental override of those settings.
-     *
-     *
-     * <pre>{@code
-     * new SolverConfigOverride<MySolution>()
+     * {@snippet :
+     * new SolverConfigOverride()
      *         .withTerminationSpentLimit(Duration.ofMinutes(5))
      *         .withTerminationConfig(new TerminationConfig()); // Will throw exception
-     * }</pre>
+     * }
      *
      * @param terminationConfig allows overriding the default termination config of {@link Solver}
      * @return this
      * @throws IllegalStateException if specific termination settings have already been applied
      */
-    public @NonNull SolverConfigOverride<Solution_> withTerminationConfig(@NonNull TerminationConfig terminationConfig) {
+    public SolverConfigOverride withTerminationConfig(TerminationConfig terminationConfig) {
         if (hasSpecificTerminationSettings) {
             throw new IllegalStateException("""
                     Cannot set terminationConfig after specific termination settings
@@ -89,27 +85,26 @@ public TerminationConfig getTerminationConfig() {
      * update its spent limit setting.
      * <p>
      * Usage examples:
-     * 
-     * <pre>{@code
+     * {@snippet :
      * // Set only spent limit
-     * new SolverConfigOverride<MySolution>()
+     * new SolverConfigOverride()
      *         .withTerminationSpentLimit(Duration.ofMinutes(10));
      *
      * // Combine with unimproved spent limit
-     * new SolverConfigOverride<MySolution>()
+     * new SolverConfigOverride()
      *         .withTerminationSpentLimit(Duration.ofMinutes(10))
      *         .withTerminationUnimprovedSpentLimit(Duration.ofMinutes(3));
      *
      * // Use with base config
-     * new SolverConfigOverride<MySolution>()
+     * new SolverConfigOverride()
      *         .withTerminationConfig(new TerminationConfig())
      *         .withTerminationSpentLimit(Duration.ofMinutes(10));
-     * }</pre>
+     * }
      *
      * @param spentLimit the maximum duration the solver is allowed to run
      * @return this
      */
-    public @NonNull SolverConfigOverride<Solution_> withTerminationSpentLimit(@NonNull Duration spentLimit) {
+    public SolverConfigOverride withTerminationSpentLimit(Duration spentLimit) {
         if (this.terminationConfig == null) {
             this.terminationConfig = new TerminationConfig();
         }
@@ -134,28 +129,26 @@ public TerminationConfig getTerminationConfig() {
      * update its unimproved spent limit setting.
      * <p>
      * Usage examples:
-     * 
-     * <pre>{@code
+     * {@snippet :
      * // Set only unimproved spent limit
-     * new SolverConfigOverride<MySolution>()
+     * new SolverConfigOverride()
      *         .withTerminationUnimprovedSpentLimit(Duration.ofMinutes(2));
      *
      * // Combine with total spent limit
-     * new SolverConfigOverride<MySolution>()
+     * new SolverConfigOverride()
      *         .withTerminationSpentLimit(Duration.ofMinutes(10))
      *         .withTerminationUnimprovedSpentLimit(Duration.ofMinutes(2));
      *
      * // Use with base config
-     * new SolverConfigOverride<MySolution>()
+     * new SolverConfigOverride()
      *         .withTerminationConfig(new TerminationConfig())
      *         .withTerminationUnimprovedSpentLimit(Duration.ofMinutes(2));
-     * }</pre>
+     * }
      *
      * @param unimprovedSpentLimit the maximum duration the solver is allowed to run without improvement
      * @return this
      */
-    public @NonNull SolverConfigOverride<Solution_>
-            withTerminationUnimprovedSpentLimit(@NonNull Duration unimprovedSpentLimit) {
+    public SolverConfigOverride withTerminationUnimprovedSpentLimit(Duration unimprovedSpentLimit) {
         if (this.terminationConfig == null) {
             this.terminationConfig = new TerminationConfig();
         }

core/src/main/java/ai/timefold/solver/core/api/solver/SolverFactory.java

@@ -116,13 +116,13 @@ static <Solution_> SolverFactory<Solution_> create(SolverConfig solverConfig) {
      * Creates a new {@link Solver} instance.
      */
     default Solver<Solution_> buildSolver() {
-        return this.buildSolver(new SolverConfigOverride<>());
+        return this.buildSolver(new SolverConfigOverride());
     }
 
     /**
      * As defined by {@link #buildSolver()}.
      *
      * @param configOverride includes settings that override the default configuration
      */
-    Solver<Solution_> buildSolver(SolverConfigOverride<Solution_> configOverride);
+    Solver<Solution_> buildSolver(SolverConfigOverride configOverride);
 }

core/src/main/java/ai/timefold/solver/core/api/solver/SolverJobBuilder.java

@@ -115,7 +115,7 @@ SolverJobBuilder<Solution_> withFirstInitializedSolutionEventConsumer(
      * @param solverConfigOverride allows overriding the default behavior of {@link Solver}
      * @return this
      */
-    SolverJobBuilder<Solution_> withConfigOverride(SolverConfigOverride<Solution_> solverConfigOverride);
+    SolverJobBuilder<Solution_> withConfigOverride(SolverConfigOverride solverConfigOverride);
 
     /**
      * Submits a planning problem to solve and returns immediately. The planning problem is solved on a solver {@link Thread},

core/src/main/java/ai/timefold/solver/core/impl/solver/DefaultSolverFactory.java

@@ -96,7 +96,7 @@ public <Score_ extends Score<Score_>> ScoreDirectorFactory<Solution_, Score_> ge
     }
 
     @Override
-    public Solver<Solution_> buildSolver(SolverConfigOverride<Solution_> configOverride) {
+    public Solver<Solution_> buildSolver(SolverConfigOverride configOverride) {
         Objects.requireNonNull(configOverride, "Invalid configOverride (null) given to SolverFactory.");
         var isDaemon = Objects.requireNonNullElse(solverConfig.getDaemon(), false);
 
@@ -178,7 +178,7 @@ public Solver<Solution_> buildSolver(SolverConfigOverride<Solution_> configOverr
     }
 
     private SolverTermination<Solution_> buildTermination(BasicPlumbingTermination<Solution_> basicPlumbingTermination,
-            HeuristicConfigPolicy<Solution_> configPolicy, SolverConfigOverride<Solution_> solverConfigOverride) {
+            HeuristicConfigPolicy<Solution_> configPolicy, SolverConfigOverride solverConfigOverride) {
         var terminationConfig = Objects.requireNonNullElseGet(solverConfigOverride.getTerminationConfig(),
                 () -> Objects.requireNonNullElseGet(solverConfig.getTerminationConfig(), TerminationConfig::new));
         return TerminationFactory.<Solution_> create(terminationConfig)

core/src/main/java/ai/timefold/solver/core/impl/solver/DefaultSolverJobBuilder.java

@@ -31,7 +31,7 @@ public final class DefaultSolverJobBuilder<Solution_> implements SolverJobBuilde
     private @Nullable Consumer<FirstInitializedSolutionEvent<Solution_>> initializedSolutionConsumer;
     private @Nullable Consumer<SolverJobStartedEvent<Solution_>> solverJobStartedConsumer;
     private @Nullable BiConsumer<? super Object, ? super Throwable> exceptionHandler;
-    private @Nullable SolverConfigOverride<Solution_> solverConfigOverride;
+    private @Nullable SolverConfigOverride solverConfigOverride;
 
     public DefaultSolverJobBuilder(DefaultSolverManager<Solution_> solverManager) {
         this.solverManager = Objects.requireNonNull(solverManager, "The SolverManager (" + solverManager + ") cannot be null.");
@@ -93,8 +93,7 @@ public SolverJobBuilder<Solution_> withProblemId(Object problemId) {
     }
 
     @Override
-    public SolverJobBuilder<Solution_>
-            withConfigOverride(SolverConfigOverride<Solution_> solverConfigOverride) {
+    public SolverJobBuilder<Solution_> withConfigOverride(SolverConfigOverride solverConfigOverride) {
         this.solverConfigOverride =
                 Objects.requireNonNull(solverConfigOverride, "Invalid solverConfigOverride (null) given to SolverJobBuilder.");
         return this;
@@ -110,7 +109,7 @@ public SolverJob<Solution_> run() {
         }
         if (solverConfigOverride == null) {
             // The config is required by SolverFactory and it must be initialized
-            this.solverConfigOverride = new SolverConfigOverride<>();
+            this.solverConfigOverride = new SolverConfigOverride();
         }
 
         if (this.bestSolutionConsumer == null) {

core/src/main/java/ai/timefold/solver/core/impl/solver/DefaultSolverManager.java

@@ -85,7 +85,7 @@ SolverJob<Solution_> solveAndListen(Object problemId, Function<? super Object, ?
             @Nullable Consumer<FirstInitializedSolutionEvent<Solution_>> initializedSolutionConsumer,
             @Nullable Consumer<SolverJobStartedEvent<Solution_>> solverJobStartedConsumer,
             @Nullable BiConsumer<? super Object, ? super Throwable> exceptionHandler,
-            SolverConfigOverride<Solution_> solverConfigOverride) {
+            SolverConfigOverride solverConfigOverride) {
         return solve(problemId, problemFinder, bestSolutionConsumer, finalBestSolutionConsumer, initializedSolutionConsumer,
                 solverJobStartedConsumer, exceptionHandler, solverConfigOverride);
     }
@@ -96,7 +96,7 @@ SolverJob<Solution_> solve(Object problemId, Function<? super Object, ? extends
             @Nullable Consumer<FirstInitializedSolutionEvent<Solution_>> initializedSolutionConsumer,
             @Nullable Consumer<SolverJobStartedEvent<Solution_>> solverJobStartedConsumer,
             @Nullable BiConsumer<? super Object, ? super Throwable> exceptionHandler,
-            SolverConfigOverride<Solution_> configOverride) {
+            SolverConfigOverride configOverride) {
         var solver = solverFactory.buildSolver(configOverride);
         ((DefaultSolver<Solution_>) solver).setMonitorTagMap(Map.of("problem.id", problemId.toString()));
         BiConsumer<? super Object, ? super Throwable> finalExceptionHandler =

core/src/test/java/ai/timefold/solver/core/api/solver/SolverFactoryTest.java

@@ -144,7 +144,7 @@ void create() {
     void createAndOverrideSettings() {
         var solverConfig = PlannerTestUtils.buildSolverConfig(TestdataSolution.class, TestdataEntity.class);
         SolverFactory<TestdataSolution> solverFactory = SolverFactory.create(solverConfig);
-        SolverConfigOverride<TestdataSolution> configOverride = mock(SolverConfigOverride.class);
+        SolverConfigOverride configOverride = mock(SolverConfigOverride.class);
         var terminationConfig = new TerminationConfig();
         terminationConfig.withSpentLimit(Duration.ofSeconds(60));
         doReturn(terminationConfig).when(configOverride).getTerminationConfig();

core/src/test/java/ai/timefold/solver/core/api/solver/SolverManagerTest.java

@@ -591,7 +591,7 @@ void solveWithOverride() {
             assertThat(solverJob.getSolverTermination().calculateSolverTimeGradient(solverScope)).isEqualTo(0.05);
 
             // Spent limit overridden by 100L
-            var configOverride = new SolverConfigOverride<TestdataSolution>()
+            var configOverride = new SolverConfigOverride()
                     .withTerminationConfig(new TerminationConfig().withSpentLimit(Duration.ofMillis(100L)));
             solverJob = (DefaultSolverJob<TestdataSolution>) solverManager.solveBuilder()
                     .withProblemId(2L)
@@ -617,7 +617,7 @@ void solveWithTerminationSpentLimit() {
             doReturn(50L).when(solverScope).calculateTimeMillisSpentUpToNow();
 
             // Override spent limit to 100 milliseconds
-            var configOverride = new SolverConfigOverride<TestdataSolution>()
+            var configOverride = new SolverConfigOverride()
                     .withTerminationSpentLimit(Duration.ofMillis(100L));
             var solverJob = (DefaultSolverJob<TestdataSolution>) solverManager.solveBuilder()
                     .withProblemId(1L)
@@ -642,7 +642,7 @@ void solveWithTerminationUnimprovedSpentLimit() {
             try (var solverManager = createDefaultSolverManager(solverConfig)) {
                 var problem = PlannerTestUtils.generateTestdataSolution("s1");
                 // Override unimproved spent limit to 500 milliseconds, keep the longer spent limit
-                var configOverride = new SolverConfigOverride<TestdataSolution>()
+                var configOverride = new SolverConfigOverride()
                         .withTerminationUnimprovedSpentLimit(Duration.ofMillis(500L));
 
                 // create a job so we can see the passed termination

core/src/test/java/ai/timefold/solver/core/impl/solver/DefaultSolverFactoryTest.java

@@ -127,7 +127,7 @@ void testInvalidRandomConfiguration() {
                 SolverConfig.createFromXmlResource("ai/timefold/solver/core/config/solver/testdataSolverConfig.xml")
                         .withRandomFactoryClass(RandomFactory.class)
                         .withRandomSeed(1000L);
-        assertThatCode(() -> new DefaultSolverFactory<>(solverConfig).buildSolver(new SolverConfigOverride<>()))
+        assertThatCode(() -> new DefaultSolverFactory<>(solverConfig).buildSolver(new SolverConfigOverride()))
                 .hasMessageContaining("The solverConfig with randomFactoryClass ")
                 .hasMessageContaining("has a non-null randomType (null) or a non-null randomSeed (1000).");
     }
@@ -137,7 +137,7 @@ void testInvalidMoveThreadCountConfiguration() {
         SolverConfig solverConfig =
                 SolverConfig.createFromXmlResource("ai/timefold/solver/core/config/solver/testdataSolverConfig.xml")
                         .withMoveThreadCount("-1");
-        assertThatCode(() -> new DefaultSolverFactory<>(solverConfig).buildSolver(new SolverConfigOverride<>()))
+        assertThatCode(() -> new DefaultSolverFactory<>(solverConfig).buildSolver(new SolverConfigOverride()))
                 .hasMessageContaining("The moveThreadCount")
                 .hasMessageContaining("resulted in a resolvedMoveThreadCount")
                 .hasMessageContaining("that is lower than 1.");
@@ -151,7 +151,7 @@ void testInvalidConstraintProfilingWithoutEnterprise() {
                 .withScoreDirectorFactory(new ScoreDirectorFactoryConfig()
                         .withConstraintProviderClass(TestdataConstraintProvider.class)
                         .withConstraintStreamProfilingEnabled(true));
-        assertThatCode(() -> new DefaultSolverFactory<>(solverConfig).buildSolver(new SolverConfigOverride<>()))
+        assertThatCode(() -> new DefaultSolverFactory<>(solverConfig).buildSolver(new SolverConfigOverride()))
                 .hasMessageContainingAll("Constraint profiling",
                         "remove constraintStreamProfilingEnabled from the solver configuration");
     }