Value ranges are immutable

Author: triceo

core/src/main/java/ai/timefold/solver/core/impl/score/director/AbstractScoreDirector.java

@@ -486,7 +486,6 @@ public void afterVariableChanged(VariableDescriptor<Solution_> variableDescripto
         if (moveRepository instanceof MoveStreamsBasedMoveRepository<Solution_> moveStreamsBasedMoveRepository) {
             moveStreamsBasedMoveRepository.update(entity);
         }
-        valueRangeState.markEntityDependentValueRangesAsInvalid(entity);
         variableListenerSupport.afterVariableChanged(variableDescriptor, entity);
     }
 
@@ -540,7 +539,6 @@ Attempting to change list variable (%s) on an entity (%s) in range [%d, %d), whi
     @Override
     public void afterListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor,
             Object entity, int fromIndex, int toIndex) {
-        valueRangeState.markEntityDependentValueRangesAsInvalid(entity);
         variableListenerSupport.afterListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
         if (moveRepository instanceof MoveStreamsBasedMoveRepository<Solution_> moveStreamsBasedMoveRepository) {
             moveStreamsBasedMoveRepository.update(entity);
@@ -560,7 +558,6 @@ public void afterEntityRemoved(EntityDescriptor<Solution_> entityDescriptor, Obj
         if (lookUpEnabled) {
             lookUpManager.removeWorkingObject(entity);
         }
-        valueRangeState.markEntityDependentValueRangesAsInvalid(entity);
         if (!allChangesWillBeUndoneBeforeStepEnds) {
             if (moveRepository instanceof MoveStreamsBasedMoveRepository<Solution_> moveStreamsBasedMoveRepository) {
                 moveStreamsBasedMoveRepository.retract(entity);

core/src/main/java/ai/timefold/solver/core/impl/score/director/ValueRangeState.java

@@ -1,18 +1,14 @@
 package ai.timefold.solver.core.impl.score.director;
 
-import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Objects;
 
 import ai.timefold.solver.core.api.domain.valuerange.ValueRange;
+import ai.timefold.solver.core.api.solver.change.ProblemChange;
 import ai.timefold.solver.core.impl.domain.valuerange.descriptor.ValueRangeDescriptor;
 import ai.timefold.solver.core.impl.domain.variable.descriptor.BasicVariableDescriptor;
 import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
-import ai.timefold.solver.core.impl.phase.event.PhaseLifecycleListener;
-import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
-import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
-import ai.timefold.solver.core.impl.solver.scope.SolverScope;
 import ai.timefold.solver.core.preview.api.domain.metamodel.GenuineVariableMetaModel;
 
 import org.jspecify.annotations.NullMarked;
@@ -28,21 +24,13 @@
  * It is not built in advance as it would be too expensive, and some code paths do not use it at all.
  * 
  * <p>
+ * Outside a {@link ProblemChange}, value ranges are not allowed to change.
  * Call {@link #resetWorkingSolution(Object)} every time the working solution changes through a problem fact,
  * so that all caches can be invalidated.
- *
- * <p>
- * Call {@link #markEntityDependentValueRangesAsInvalid(Object)} every time an entity is changed,
- * so that the cached value range can be invalidated.
- * The actual invalidation happens at {@link #stepEnded(AbstractStepScope)}, called by the solver.
- * Otherwise every undone move would be invalidating the value ranges.
- * Value ranges should only be invalidated when a move has been selected at the end of a step.
  */
 @NullMarked
-public final class ValueRangeState<Solution_>
-        implements PhaseLifecycleListener<Solution_> {
+public final class ValueRangeState<Solution_> {
 
-    private final HashSet<Object> entitiesWithInvalidValueRangesSet = new HashSet<>();
     private final Map<ValueRangeDescriptor<Solution_>, ValueRange<Object>> fromSolutionValueRangeMap = new IdentityHashMap<>();
     private final Map<Object, Map<ValueRangeDescriptor<Solution_>, ValueRange<Object>>> fromEntityValueRangeMap =
             new IdentityHashMap<>();
@@ -93,40 +81,4 @@ public boolean isInRange(ValueRangeDescriptor<Solution_> valueRangeDescriptor, @
         }
     }
 
-    void markEntityDependentValueRangesAsInvalid(Object entity) {
-        entitiesWithInvalidValueRangesSet.add(entity);
-    }
-
-    @Override
-    public void solvingStarted(SolverScope<Solution_> solverScope) {
-        // No need to do anything here.
-    }
-
-    @Override
-    public void phaseStarted(AbstractPhaseScope<Solution_> phaseScope) {
-        // No need to do anything here.
-    }
-
-    @Override
-    public void stepStarted(AbstractStepScope<Solution_> stepScope) {
-        // No need to do anything here.
-    }
-
-    @Override
-    public void stepEnded(AbstractStepScope<Solution_> stepScope) {
-        entitiesWithInvalidValueRangesSet.forEach(fromEntityValueRangeMap::remove);
-        entitiesWithInvalidValueRangesSet.clear();
-    }
-
-    @Override
-    public void phaseEnded(AbstractPhaseScope<Solution_> phaseScope) {
-        // No need to do anything here.
-    }
-
-    @Override
-    public void solvingEnded(SolverScope<Solution_> solverScope) {
-        this.workingSolution = null;
-        fromSolutionValueRangeMap.clear();
-        fromEntityValueRangeMap.clear();
-    }
 }

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

@@ -57,7 +57,6 @@ protected AbstractSolver(BestSolutionRecaller<Solution_> bestSolutionRecaller,
 
     public void solvingStarted(SolverScope<Solution_> solverScope) {
         solverScope.setWorkingSolutionFromBestSolution();
-        solverScope.getValueRangeState().solvingStarted(solverScope);
         bestSolutionRecaller.solvingStarted(solverScope);
         globalTermination.solvingStarted(solverScope);
         phaseLifecycleSupport.fireSolvingStarted(solverScope);
@@ -93,7 +92,6 @@ public void solvingEnded(SolverScope<Solution_> solverScope) {
         bestSolutionRecaller.solvingEnded(solverScope);
         globalTermination.solvingEnded(solverScope);
         phaseLifecycleSupport.fireSolvingEnded(solverScope);
-        solverScope.getValueRangeState().solvingEnded(solverScope);
     }
 
     public void solvingError(SolverScope<Solution_> solverScope, Exception exception) {
@@ -104,7 +102,6 @@ public void solvingError(SolverScope<Solution_> solverScope, Exception exception
     }
 
     public void phaseStarted(AbstractPhaseScope<Solution_> phaseScope) {
-        phaseScope.getSolverScope().getValueRangeState().phaseStarted(phaseScope);
         bestSolutionRecaller.phaseStarted(phaseScope);
         phaseLifecycleSupport.firePhaseStarted(phaseScope);
         globalTermination.phaseStarted(phaseScope);
@@ -115,12 +112,10 @@ public void phaseEnded(AbstractPhaseScope<Solution_> phaseScope) {
         bestSolutionRecaller.phaseEnded(phaseScope);
         phaseLifecycleSupport.firePhaseEnded(phaseScope);
         globalTermination.phaseEnded(phaseScope);
-        phaseScope.getSolverScope().getValueRangeState().phaseEnded(phaseScope);
         // Do not propagate to phases; the active phase does that for itself and they should not propagate further.
     }
 
     public void stepStarted(AbstractStepScope<Solution_> stepScope) {
-        stepScope.getPhaseScope().getSolverScope().getValueRangeState().stepStarted(stepScope);
         bestSolutionRecaller.stepStarted(stepScope);
         phaseLifecycleSupport.fireStepStarted(stepScope);
         globalTermination.stepStarted(stepScope);
@@ -131,7 +126,6 @@ public void stepEnded(AbstractStepScope<Solution_> stepScope) {
         bestSolutionRecaller.stepEnded(stepScope);
         phaseLifecycleSupport.fireStepEnded(stepScope);
         globalTermination.stepEnded(stepScope);
-        stepScope.getPhaseScope().getSolverScope().getValueRangeState().stepEnded(stepScope);
         // Do not propagate to phases; the active phase does that for itself and they should not propagate further.
     }