refactor: remove deprecations from entities and variables

Author: triceo

core/src/main/java/ai/timefold/solver/core/api/domain/entity/PinningFilter.java

@@ -10,7 +10,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.domain.variable.PlanningVariable;
-import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.SelectionSorterWeightFactory;
 
 /**
  * Specifies that the class is a planning entity.
@@ -69,80 +68,4 @@ interface NullComparator<T> extends Comparator<T> {
     interface NullComparatorFactory<Solution_, T> extends ComparatorFactory<Solution_, T> {
     }
 
-    /**
-     * A pinned planning entity is never changed during planning,
-     * this is useful in repeated planning use cases (such as continuous planning and real-time planning).
-     * This applies to all the planning variables of this planning entity.
-     * <p>
-     * The method {@link PinningFilter#accept(Object, Object)} returns false if the selection entity is pinned
-     * and it returns true if the selection entity is movable
-     *
-     * @return {@link NullPinningFilter} when it is null (workaround for annotation limitation)
-     * @deprecated Prefer using {@link PlanningPin}.
-     */
-    @Deprecated(forRemoval = true, since = "1.23.0")
-    Class<? extends PinningFilter> pinningFilter() default NullPinningFilter.class;
-
-    /**
-     * Workaround for annotation limitation in {@link #pinningFilter()}.
-     *
-     * @deprecated Prefer using {@link PlanningPin}.
-     */
-    @Deprecated(forRemoval = true, since = "1.23.0")
-    interface NullPinningFilter extends PinningFilter {
-    }
-
-    /**
-     * Allows a collection of planning entities to be sorted by difficulty.
-     * A difficultyWeight estimates how hard is to plan a certain PlanningEntity.
-     * Some algorithms benefit from planning on more difficult planning entities first/last or from focusing on them.
-     * <p>
-     * The {@link Comparator} should sort in ascending difficulty
-     * (even though many optimization algorithms will reverse it).
-     * For example: sorting 3 processes on difficultly based on their RAM usage requirement:
-     * Process B (1GB RAM), Process A (2GB RAM), Process C (7GB RAM),
-     * <p>
-     * Do not use together with {@link #difficultyWeightFactoryClass()}.
-     *
-     * @deprecated Deprecated in favor of {@link #comparatorClass()}.
-     *
-     * @return {@link NullDifficultyComparator} when it is null (workaround for annotation limitation)
-     * @see #difficultyWeightFactoryClass()
-     */
-    @Deprecated(forRemoval = true, since = "1.28.0")
-    Class<? extends Comparator> difficultyComparatorClass() default NullDifficultyComparator.class;
-
-    /**
-     * Workaround for annotation limitation in {@link #difficultyComparatorClass()}.
-     *
-     * @deprecated Deprecated in favor of {@link NullComparator}.
-     */
-    @Deprecated(forRemoval = true, since = "1.28.0")
-    interface NullDifficultyComparator<T> extends NullComparator<T> {
-    }
-
-    /**
-     * The {@link SelectionSorterWeightFactory} alternative for {@link #difficultyComparatorClass()}.
-     * <p>
-     * Do not use together with {@link #difficultyComparatorClass()}.
-     *
-     * @deprecated Deprecated in favor of {@link #comparatorFactoryClass()}.
-     *
-     * @return {@link NullDifficultyWeightFactory} when it is null (workaround for annotation limitation)
-     * @see #difficultyComparatorClass()
-     */
-    @Deprecated(forRemoval = true, since = "1.28.0")
-    Class<? extends SelectionSorterWeightFactory> difficultyWeightFactoryClass() default NullDifficultyWeightFactory.class;
-
-    /**
-     * Workaround for annotation limitation in {@link #difficultyWeightFactoryClass()}.
-     *
-     * @deprecated Deprecated in favor of {@link NullComparatorFactory}.
-     */
-    @Deprecated(forRemoval = true, since = "1.28.0")
-    interface NullDifficultyWeightFactory<Solution_, T>
-            extends SelectionSorterWeightFactory<Solution_, T>,
-            NullComparatorFactory<Solution_, T> {
-    }
-
 }

core/src/main/java/ai/timefold/solver/core/api/domain/entity/PlanningEntity.java

@@ -12,7 +12,6 @@
 import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
 import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
 import ai.timefold.solver.core.api.domain.valuerange.ValueRangeProvider;
-import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.SelectionSorterWeightFactory;
 
 /**
  * Specifies that a bean property (or a field) can be changed and should be optimized by the optimization algorithms.
@@ -84,63 +83,4 @@ interface NullComparator<T> extends Comparator<T> {
     interface NullComparatorFactory<Solution_, T> extends ComparatorFactory<Solution_, T> {
     }
 
-    /**
-     * As defined by {@link #allowsUnassigned()}.
-     *
-     * @deprecated Use {@link #allowsUnassigned()} instead.
-     * @return true if null is a valid value for this planning variable
-     */
-    @Deprecated(forRemoval = true, since = "1.8.0")
-    boolean nullable() default false;
-
-    /**
-     * Allows a collection of planning values for this variable to be sorted by strength.
-     * A strengthWeight estimates how strong a planning value is.
-     * Some algorithms benefit from planning on weaker planning values first or from focusing on them.
-     * <p>
-     * The {@link Comparator} should sort in ascending strength.
-     * For example: sorting 3 computers on strength based on their RAM capacity:
-     * Computer B (1GB RAM), Computer A (2GB RAM), Computer C (7GB RAM),
-     * <p>
-     * Do not use together with {@link #strengthWeightFactoryClass()}.
-     *
-     * @deprecated Deprecated in favor of {@link #comparatorClass()}.
-     *
-     * @return {@link NullStrengthComparator} when it is null (workaround for annotation limitation)
-     * @see #strengthWeightFactoryClass()
-     */
-    @Deprecated(forRemoval = true, since = "1.28.0")
-    Class<? extends Comparator> strengthComparatorClass() default NullStrengthComparator.class;
-
-    /**
-     * Workaround for annotation limitation in {@link #strengthComparatorClass()}.
-     *
-     * @deprecated Deprecated in favor of {@link NullComparator}.
-     */
-    @Deprecated(forRemoval = true, since = "1.28.0")
-    interface NullStrengthComparator<T> extends NullComparator<T> {
-    }
-
-    /**
-     * The {@link SelectionSorterWeightFactory} alternative for {@link #strengthComparatorClass()}.
-     * <p>
-     * Do not use together with {@link #strengthComparatorClass()}.
-     *
-     * @deprecated Deprecated in favor of {@link #comparatorFactoryClass()}.
-     *
-     * @return {@link NullStrengthWeightFactory} when it is null (workaround for annotation limitation)
-     * @see #strengthComparatorClass()
-     */
-    @Deprecated(forRemoval = true, since = "1.28.0")
-    Class<? extends SelectionSorterWeightFactory> strengthWeightFactoryClass() default NullStrengthWeightFactory.class;
-
-    /**
-     * Workaround for annotation limitation in {@link #strengthWeightFactoryClass()}.
-     *
-     * @deprecated Deprecated in favor of {@link NullComparatorFactory}.
-     */
-    @Deprecated(forRemoval = true, since = "1.28.0")
-    interface NullStrengthWeightFactory<Solution_, T>
-            extends SelectionSorterWeightFactory<Solution_, T>, NullComparatorFactory<Solution_, T> {
-    }
 }

core/src/main/java/ai/timefold/solver/core/api/domain/variable/PlanningVariable.java

@@ -23,7 +23,6 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
-import ai.timefold.solver.core.api.domain.entity.PinningFilter;
 import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
 import ai.timefold.solver.core.api.domain.entity.PlanningPin;
 import ai.timefold.solver.core.api.domain.entity.PlanningPinToIndex;
@@ -100,7 +99,6 @@ public class EntityDescriptor<Solution_> {
     private ShadowVariablesInconsistentVariableDescriptor<Solution_> shadowVariablesInconsistentDescriptor;
 
     // Only declared movable filter, excludes inherited and descending movable filters
-    private MovableFilter<Solution_> declaredMovableEntityFilter;
     private SelectionSorter<Solution_, Object> descendingSorter;
 
     // Only declared variable descriptors, excludes inherited variable descriptors
@@ -232,76 +230,28 @@ private void processEntityAnnotations() {
                     .orElseThrow(
                             () -> new IllegalStateException("Impossible state as the previous if block would fail first."));
         }
-        processMovable(entityAnnotation);
         processSorting(entityAnnotation);
     }
 
-    /**
-     * @deprecated Remove in the next major version of Timefold Solver.
-     */
-    @Deprecated(forRemoval = true, since = "1.23.0")
-    private void processMovable(PlanningEntity entityAnnotation) {
-        if (entityAnnotation == null) {
-            return;
-        }
-        var pinningFilterClass = entityAnnotation.pinningFilter();
-        var hasPinningFilter = pinningFilterClass != PlanningEntity.NullPinningFilter.class;
-        if (hasPinningFilter) {
-            var pinningFilter = ConfigUtils.newInstance(this::toString, "pinningFilterClass",
-                    (Class<? extends PinningFilter<Solution_, Object>>) pinningFilterClass);
-            declaredMovableEntityFilter = (solution, selection) -> !pinningFilter.accept(solution, selection);
-        }
-    }
-
     private void processSorting(PlanningEntity entityAnnotation) {
         if (entityAnnotation == null) {
             return;
         }
-        var difficultyComparatorClass = entityAnnotation.difficultyComparatorClass();
-        if (difficultyComparatorClass != null
-                && PlanningEntity.NullComparator.class.isAssignableFrom(difficultyComparatorClass)) {
-            difficultyComparatorClass = null;
-        }
         var comparatorClass = entityAnnotation.comparatorClass();
         if (comparatorClass != null
                 && PlanningEntity.NullComparator.class.isAssignableFrom(comparatorClass)) {
             comparatorClass = null;
         }
-        if (difficultyComparatorClass != null && comparatorClass != null) {
-            throw new IllegalStateException(
-                    "The entityClass (%s) cannot have a %s (%s) and a %s (%s) at the same time.".formatted(getEntityClass(),
-                            "difficultyComparatorClass", difficultyComparatorClass.getName(), "comparatorClass",
-                            comparatorClass.getName()));
-        }
-        var difficultyWeightFactoryClass = entityAnnotation.difficultyWeightFactoryClass();
-        if (difficultyWeightFactoryClass != null
-                && PlanningEntity.NullComparatorFactory.class.isAssignableFrom(difficultyWeightFactoryClass)) {
-            difficultyWeightFactoryClass = null;
-        }
         var comparatorFactoryClass = entityAnnotation.comparatorFactoryClass();
         if (comparatorFactoryClass != null
                 && PlanningEntity.NullComparatorFactory.class.isAssignableFrom(comparatorFactoryClass)) {
             comparatorFactoryClass = null;
         }
-        if (difficultyWeightFactoryClass != null && comparatorFactoryClass != null) {
-            throw new IllegalStateException(
-                    "The entityClass (%s) cannot have a %s (%s) and a %s (%s) at the same time.".formatted(getEntityClass(),
-                            "difficultyWeightFactoryClass", difficultyWeightFactoryClass.getName(), "comparatorFactoryClass",
-                            comparatorFactoryClass.getName()));
-        }
         // Selected settings
         var selectedComparatorPropertyName = "comparatorClass";
         var selectedComparatorClass = comparatorClass;
         var selectedComparatorFactoryPropertyName = "comparatorFactoryClass";
         var selectedComparatorFactoryClass = comparatorFactoryClass;
-        if (difficultyComparatorClass != null) {
-            selectedComparatorPropertyName = "difficultyComparatorClass";
-            selectedComparatorClass = difficultyComparatorClass;
-        }
-        if (difficultyWeightFactoryClass != null) {
-            selectedComparatorFactoryPropertyName = "difficultyWeightFactoryClass";
-            selectedComparatorFactoryClass = difficultyWeightFactoryClass;
-        }
         if (selectedComparatorClass != null && selectedComparatorFactoryClass != null) {
             throw new IllegalStateException("The entityClass (%s) cannot have a %s (%s) and a %s (%s) at the same time."
                     .formatted(entityClass, selectedComparatorPropertyName, selectedComparatorClass.getName(),
@@ -552,11 +502,6 @@ Maybe remove the variables (%s) from the class (%s).""".formatted(entityClass,
     }
 
     private void createEffectiveMovableEntitySelectionFilter() {
-        if (declaredMovableEntityFilter != null && !hasAnyDeclaredGenuineVariableDescriptor()) {
-            throw new IllegalStateException(
-                    "The entityClass (%s) has a movableEntitySelectionFilterClass (%s), but it has no declared genuine variables, only shadow variables."
-                            .formatted(entityClass, declaredMovableEntityFilter.getClass()));
-        }
         var movableFilterList = new ArrayList<MovableFilter<Solution_>>();
         // TODO Also add in child entity selectors
         for (var inheritedEntityDescriptor : effectiveInheritedEntityDescriptorList) {
@@ -565,9 +510,6 @@ private void createEffectiveMovableEntitySelectionFilter() {
                 movableFilterList.add(inheritedEntityDescriptor.effectiveMovableEntityFilter);
             }
         }
-        if (declaredMovableEntityFilter != null) {
-            movableFilterList.add(declaredMovableEntityFilter);
-        }
         movableFilterList.addAll(declaredPinEntityFilterList);
         if (movableFilterList.isEmpty()) {
             effectiveMovableEntityFilter = null;
@@ -637,10 +579,6 @@ public boolean matchesEntity(Object entity) {
         return entityClass.isAssignableFrom(entity.getClass());
     }
 
-    public boolean hasPinningFilter() {
-        return declaredMovableEntityFilter != null;
-    }
-
     public boolean hasEffectiveMovableEntityFilter() {
         return effectiveMovableEntityFilter != null;
     }

core/src/main/java/ai/timefold/solver/core/impl/domain/entity/descriptor/EntityDescriptor.java

@@ -42,76 +42,34 @@ protected void processPropertyAnnotations(DescriptorPolicy descriptorPolicy) {
 
     private SortingProperties assertSortingProperties(PlanningVariable planningVariableAnnotation) {
         // Comparator property
-        var strengthComparatorClass = planningVariableAnnotation.strengthComparatorClass();
         var comparatorClass = planningVariableAnnotation.comparatorClass();
-        if (strengthComparatorClass != null
-                && PlanningVariable.NullComparator.class.isAssignableFrom(strengthComparatorClass)) {
-            strengthComparatorClass = null;
-        }
         if (comparatorClass != null && PlanningVariable.NullComparator.class.isAssignableFrom(comparatorClass)) {
             comparatorClass = null;
         }
-        if (strengthComparatorClass != null && comparatorClass != null) {
-            throw new IllegalStateException(
-                    "The entityClass (%s) property (%s) cannot have a %s (%s) and a %s (%s) at the same time.".formatted(
-                            entityDescriptor.getEntityClass(), variableMemberAccessor.getName(), "strengthComparatorClass",
-                            strengthComparatorClass.getName(), "comparatorClass", comparatorClass.getName()));
-        }
         // Comparator factory property
-        var strengthWeightFactoryClass = planningVariableAnnotation.strengthWeightFactoryClass();
         var comparatorFactoryClass = planningVariableAnnotation.comparatorFactoryClass();
-        if (strengthWeightFactoryClass != null
-                && PlanningVariable.NullComparatorFactory.class.isAssignableFrom(strengthWeightFactoryClass)) {
-            strengthWeightFactoryClass = null;
-        }
         if (comparatorFactoryClass != null
                 && PlanningVariable.NullComparatorFactory.class.isAssignableFrom(comparatorFactoryClass)) {
             comparatorFactoryClass = null;
         }
-        if (strengthWeightFactoryClass != null && comparatorFactoryClass != null) {
-            throw new IllegalStateException(
-                    "The entityClass (%s) property (%s) cannot have a %s (%s) and a %s (%s) at the same time.".formatted(
-                            entityDescriptor.getEntityClass(), variableMemberAccessor.getName(), "strengthWeightFactoryClass",
-                            strengthWeightFactoryClass.getName(), "comparatorFactoryClass", comparatorFactoryClass.getName()));
-        }
         // Selected settings
         var selectedComparatorPropertyName = "comparatorClass";
         var selectedComparatorClass = comparatorClass;
         var selectedComparatorFactoryPropertyName = "comparatorFactoryClass";
         var selectedComparatorFactoryClass = comparatorFactoryClass;
-        if (strengthComparatorClass != null) {
-            selectedComparatorPropertyName = "strengthComparatorClass";
-            selectedComparatorClass = strengthComparatorClass;
-        }
-        if (strengthWeightFactoryClass != null) {
-            selectedComparatorFactoryPropertyName = "strengthWeightFactoryClass";
-            selectedComparatorFactoryClass = strengthWeightFactoryClass;
-        }
         return new SortingProperties(selectedComparatorPropertyName, selectedComparatorClass,
                 selectedComparatorFactoryPropertyName, selectedComparatorFactoryClass);
     }
 
     private void processAllowsUnassigned(PlanningVariable planningVariableAnnotation) {
-        var deprecatedNullable = planningVariableAnnotation.nullable();
-        if (planningVariableAnnotation.allowsUnassigned()) {
-            // If the user has specified allowsUnassigned = true, it takes precedence.
-            if (deprecatedNullable) {
-                throw new IllegalArgumentException(
-                        "The entityClass (%s) has a @%s-annotated property (%s) with allowsUnassigned (%s) and nullable (%s) which are mutually exclusive."
-                                .formatted(entityDescriptor.getEntityClass(), PlanningVariable.class.getSimpleName(),
-                                        variableMemberAccessor.getName(), true, true));
-            }
-            this.allowsUnassigned = true;
-        } else { // If the user has not specified allowsUnassigned = true, nullable is taken.
-            this.allowsUnassigned = deprecatedNullable;
-        }
-        if (this.allowsUnassigned && variableMemberAccessor.getType().isPrimitive()) {
+        allowsUnassigned = planningVariableAnnotation.allowsUnassigned();
+        if (allowsUnassigned && variableMemberAccessor.getType().isPrimitive()) {
             throw new IllegalArgumentException(
                     "The entityClass (%s) has a @%s-annotated property (%s) with allowsUnassigned (%s) which is not compatible with the primitive propertyType (%s)."
                             .formatted(entityDescriptor.getEntityClass(),
                                     PlanningVariable.class.getSimpleName(),
                                     variableMemberAccessor.getName(),
-                                    this.allowsUnassigned,
+                                    allowsUnassigned,
                                     variableMemberAccessor.getType()));
         }
     }