chore: remove RandomFactory and RandomType

Author: Christopher-Chianelli

core/src/main/java/ai/timefold/solver/core/config/solver/SolverConfig.java

@@ -41,15 +41,13 @@
 import ai.timefold.solver.core.config.score.director.ScoreDirectorFactoryConfig;
 import ai.timefold.solver.core.config.solver.monitoring.MonitoringConfig;
 import ai.timefold.solver.core.config.solver.monitoring.SolverMetric;
-import ai.timefold.solver.core.config.solver.random.RandomType;
 import ai.timefold.solver.core.config.solver.termination.TerminationConfig;
 import ai.timefold.solver.core.config.util.ConfigUtils;
 import ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessor;
 import ai.timefold.solver.core.impl.heuristic.selector.common.nearby.NearbyDistanceMeter;
 import ai.timefold.solver.core.impl.io.jaxb.SolverConfigIO;
 import ai.timefold.solver.core.impl.io.jaxb.TimefoldXmlSerializationException;
 import ai.timefold.solver.core.impl.phase.PhaseFactory;
-import ai.timefold.solver.core.impl.solver.random.RandomFactory;
 
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
@@ -63,9 +61,7 @@
         "enablePreviewFeatureSet",
         "environmentMode",
         "daemon",
-        "randomType",
         "randomSeed",
-        "randomFactoryClass",
         "moveThreadCount",
         "moveThreadBufferSize",
         "threadFactoryClass",
@@ -215,9 +211,7 @@ public final class SolverConfig extends AbstractConfig<SolverConfig> {
     private Set<PreviewFeature> enablePreviewFeatureSet = null;
     private EnvironmentMode environmentMode = null;
     private Boolean daemon = null;
-    private RandomType randomType = null;
     private Long randomSeed = null;
-    private Class<? extends RandomFactory> randomFactoryClass = null;
     private String moveThreadCount = null;
     private Integer moveThreadBufferSize = null;
     private Class<? extends ThreadFactory> threadFactoryClass = null;
@@ -332,14 +326,6 @@ public void setDaemon(@Nullable Boolean daemon) {
         this.daemon = daemon;
     }
 
-    public @Nullable RandomType getRandomType() {
-        return randomType;
-    }
-
-    public void setRandomType(@Nullable RandomType randomType) {
-        this.randomType = randomType;
-    }
-
     public @Nullable Long getRandomSeed() {
         return randomSeed;
     }
@@ -348,14 +334,6 @@ public void setRandomSeed(@Nullable Long randomSeed) {
         this.randomSeed = randomSeed;
     }
 
-    public @Nullable Class<? extends RandomFactory> getRandomFactoryClass() {
-        return randomFactoryClass;
-    }
-
-    public void setRandomFactoryClass(@Nullable Class<? extends RandomFactory> randomFactoryClass) {
-        this.randomFactoryClass = randomFactoryClass;
-    }
-
     public @Nullable String getMoveThreadCount() {
         return moveThreadCount;
     }
@@ -471,21 +449,11 @@ public void setMonitoringConfig(@Nullable MonitoringConfig monitoringConfig) {
         return this;
     }
 
-    public @NonNull SolverConfig withRandomType(@NonNull RandomType randomType) {
-        this.randomType = randomType;
-        return this;
-    }
-
     public @NonNull SolverConfig withRandomSeed(@NonNull Long randomSeed) {
         this.randomSeed = randomSeed;
         return this;
     }
 
-    public @NonNull SolverConfig withRandomFactoryClass(@NonNull Class<? extends RandomFactory> randomFactoryClass) {
-        this.randomFactoryClass = randomFactoryClass;
-        return this;
-    }
-
     public @NonNull SolverConfig withMoveThreadCount(@NonNull String moveThreadCount) {
         this.moveThreadCount = moveThreadCount;
         return this;
@@ -648,7 +616,7 @@ public boolean canTerminate() {
     // ************************************************************************
 
     public void offerRandomSeedFromSubSingleIndex(long subSingleIndex) {
-        if ((environmentMode == null || environmentMode.isReproducible()) && randomFactoryClass == null && randomSeed == null) {
+        if ((environmentMode == null || environmentMode.isReproducible()) && randomSeed == null) {
             randomSeed = subSingleIndex;
         }
     }
@@ -665,10 +633,7 @@ public void offerRandomSeedFromSubSingleIndex(long subSingleIndex) {
                 inheritedConfig.getEnablePreviewFeatureSet());
         environmentMode = ConfigUtils.inheritOverwritableProperty(environmentMode, inheritedConfig.getEnvironmentMode());
         daemon = ConfigUtils.inheritOverwritableProperty(daemon, inheritedConfig.getDaemon());
-        randomType = ConfigUtils.inheritOverwritableProperty(randomType, inheritedConfig.getRandomType());
         randomSeed = ConfigUtils.inheritOverwritableProperty(randomSeed, inheritedConfig.getRandomSeed());
-        randomFactoryClass = ConfigUtils.inheritOverwritableProperty(randomFactoryClass,
-                inheritedConfig.getRandomFactoryClass());
         moveThreadCount = ConfigUtils.inheritOverwritableProperty(moveThreadCount,
                 inheritedConfig.getMoveThreadCount());
         moveThreadBufferSize = ConfigUtils.inheritOverwritableProperty(moveThreadBufferSize,
@@ -700,7 +665,6 @@ public void offerRandomSeedFromSubSingleIndex(long subSingleIndex) {
 
     @Override
     public void visitReferencedClasses(@NonNull Consumer<Class<?>> classVisitor) {
-        classVisitor.accept(randomFactoryClass);
         classVisitor.accept(threadFactoryClass);
         classVisitor.accept(solutionClass);
         if (entityClassList != null) {

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

@@ -5,6 +5,8 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+import java.util.random.RandomGenerator;
 
 import ai.timefold.solver.core.api.domain.common.PlanningId;
 import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
@@ -16,7 +18,6 @@
 import ai.timefold.solver.core.impl.phase.Phase;
 import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
 import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactory;
-import ai.timefold.solver.core.impl.solver.random.RandomFactory;
 import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecaller;
 import ai.timefold.solver.core.impl.solver.scope.SolverScope;
 import ai.timefold.solver.core.impl.solver.termination.BasicPlumbingTermination;
@@ -38,7 +39,7 @@
 public class DefaultSolver<Solution_> extends AbstractSolver<Solution_> {
 
     protected final EnvironmentMode environmentMode;
-    protected final RandomFactory randomFactory;
+    protected final Supplier<RandomGenerator> randomFactory;
     protected final BasicPlumbingTermination<Solution_> basicPlumbingTermination;
     protected final AtomicBoolean solving = new AtomicBoolean(false);
     protected final SolverScope<Solution_> solverScope;
@@ -48,7 +49,7 @@ public class DefaultSolver<Solution_> extends AbstractSolver<Solution_> {
     // Constructors and simple getters/setters
     // ************************************************************************
 
-    public DefaultSolver(EnvironmentMode environmentMode, RandomFactory randomFactory,
+    public DefaultSolver(EnvironmentMode environmentMode, Supplier<RandomGenerator> randomFactory,
             BestSolutionRecaller<Solution_> bestSolutionRecaller, BasicPlumbingTermination<Solution_> basicPlumbingTermination,
             UniversalTermination<Solution_> termination, List<Phase<Solution_>> phaseList,
             SolverScope<Solution_> solverScope, String moveThreadCountDescription) {
@@ -65,7 +66,7 @@ public EnvironmentMode getEnvironmentMode() {
         return environmentMode;
     }
 
-    public RandomFactory getRandomFactory() {
+    public Supplier<RandomGenerator> getRandomSupplier() {
         return randomFactory;
     }
 
@@ -187,7 +188,7 @@ public void outerSolvingStarted(SolverScope<Solution_> solverScope) {
         solving.set(true);
         basicPlumbingTermination.resetTerminateEarly();
         solverScope.setStartingSolverCount(0);
-        solverScope.setWorkingRandom(randomFactory.createRandom());
+        solverScope.setWorkingRandom(randomFactory.get());
     }
 
     @Override

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

@@ -7,6 +7,8 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.OptionalInt;
+import java.util.function.Supplier;
+import java.util.random.RandomGenerator;
 
 import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
 import ai.timefold.solver.core.api.score.Score;
@@ -21,7 +23,6 @@
 import ai.timefold.solver.core.config.solver.PreviewFeature;
 import ai.timefold.solver.core.config.solver.SolverConfig;
 import ai.timefold.solver.core.config.solver.monitoring.SolverMetric;
-import ai.timefold.solver.core.config.solver.random.RandomType;
 import ai.timefold.solver.core.config.solver.termination.TerminationConfig;
 import ai.timefold.solver.core.config.util.ConfigUtils;
 import ai.timefold.solver.core.impl.AbstractFromConfigFactory;
@@ -36,8 +37,7 @@
 import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactory;
 import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactoryFactory;
 import ai.timefold.solver.core.impl.solver.change.DefaultProblemChangeDirector;
-import ai.timefold.solver.core.impl.solver.random.DefaultRandomFactory;
-import ai.timefold.solver.core.impl.solver.random.RandomFactory;
+import ai.timefold.solver.core.impl.solver.random.DelegatingSplittableRandomGenerator;
 import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecaller;
 import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecallerFactory;
 import ai.timefold.solver.core.impl.solver.scope.SolverScope;
@@ -133,7 +133,7 @@ public Solver<Solution_> buildSolver(SolverConfigOverride configOverride) {
 
         var moveThreadCount = resolveMoveThreadCount(true);
         var bestSolutionRecaller = BestSolutionRecallerFactory.create().<Solution_> buildBestSolutionRecaller(environmentMode);
-        var randomFactory = buildRandomFactory(environmentMode);
+        var randomFactory = buildRandomSupplier(environmentMode);
         var previewFeaturesEnabled = solverConfig.getEnablePreviewFeatureSet();
 
         var scoreDirectorFactoryConfig = solverConfig.getScoreDirectorFactoryConfig();
@@ -153,7 +153,7 @@ public Solver<Solution_> buildSolver(SolverConfigOverride configOverride) {
                 .withMoveThreadBufferSize(solverConfig.getMoveThreadBufferSize())
                 .withThreadFactoryClass(solverConfig.getThreadFactoryClass())
                 .withNearbyDistanceMeterClass(solverConfig.getNearbyDistanceMeterClass())
-                .withRandom(randomFactory.createRandom())
+                .withRandom(randomFactory.get())
                 .withInitializingScoreTrend(scoreDirectorFactory.getInitializingScoreTrend())
                 .withSolutionDescriptor(solutionDescriptor)
                 .withClassInstanceCache(ClassInstanceCache.create())
@@ -212,25 +212,15 @@ private <Score_ extends Score<Score_>> ScoreDirectorFactory<Solution_, Score_> b
         return scoreDirectorFactoryFactory.buildScoreDirectorFactory(environmentMode, solutionDescriptor);
     }
 
-    public RandomFactory buildRandomFactory(EnvironmentMode environmentMode_) {
-        var randomFactoryClass = solverConfig.getRandomFactoryClass();
-        if (randomFactoryClass != null) {
-            var randomType = solverConfig.getRandomType();
-            var randomSeed = solverConfig.getRandomSeed();
-            if (randomType != null || randomSeed != null) {
-                throw new IllegalArgumentException(
-                        "The solverConfig with randomFactoryClass (%s) has a non-null randomType (%s) or a non-null randomSeed (%s)."
-                                .formatted(randomFactoryClass, randomType, randomSeed));
-            }
-            return ConfigUtils.newInstance(solverConfig, "randomFactoryClass", randomFactoryClass);
+    public Supplier<RandomGenerator> buildRandomSupplier(EnvironmentMode environmentMode_) {
+        var randomSeed_ = solverConfig.getRandomSeed();
+        if (randomSeed_ == null && environmentMode_ != EnvironmentMode.NON_REPRODUCIBLE) {
+            randomSeed_ = DEFAULT_RANDOM_SEED;
         } else {
-            var randomType_ = Objects.requireNonNullElse(solverConfig.getRandomType(), RandomType.JDK);
-            var randomSeed_ = solverConfig.getRandomSeed();
-            if (solverConfig.getRandomSeed() == null && environmentMode_ != EnvironmentMode.NON_REPRODUCIBLE) {
-                randomSeed_ = DEFAULT_RANDOM_SEED;
-            }
-            return new DefaultRandomFactory(randomType_, randomSeed_);
+            randomSeed_ = RandomGenerator.getDefault().nextLong();
         }
+        Long finalRandomSeed_ = randomSeed_;
+        return () -> new DelegatingSplittableRandomGenerator(finalRandomSeed_);
     }
 
     public List<Phase<Solution_>> buildPhaseList(HeuristicConfigPolicy<Solution_> configPolicy,