chore: minor Nearby fix

Author: zepfred

core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/entity/EntitySelectorFactory.java

@@ -107,12 +107,16 @@ public EntitySelector<Solution_> buildEntitySelector(HeuristicConfigPolicy<Solut
         var entitySelector = buildBaseEntitySelector(entityDescriptor, baseSelectionCacheType,
                 baseRandomSelection);
         var instanceCache = configPolicy.getClassInstanceCache();
-        entitySelector = applyEntityValueRangeFiltering(configPolicy, entitySelector, entityValueRangeRecorderId,
-                minimumCacheType, inheritedSelectionOrder, baseRandomSelection);
         if (nearbySelectionConfig != null) {
             // TODO Static filtering (such as movableEntitySelectionFilter) should affect nearbySelection
             entitySelector = applyNearbySelection(configPolicy, nearbySelectionConfig, minimumCacheType,
                     resolvedSelectionOrder, entitySelector);
+        } else {
+            // The nearby selector will implement its own logic to filter out unreachable elements.
+            // Therefore, we only apply entity value range filtering if the nearby feature is not enabled;
+            // otherwise, we would end up applying the filtering logic twice.
+            entitySelector = applyEntityValueRangeFiltering(configPolicy, entitySelector, entityValueRangeRecorderId,
+                    minimumCacheType, inheritedSelectionOrder, baseRandomSelection);
         }
         entitySelector = applyFiltering(entitySelector, instanceCache);
         entitySelector = applySorting(resolvedCacheType, resolvedSelectionOrder, entitySelector, instanceCache);

core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/list/DestinationSelectorFactory.java

@@ -40,7 +40,8 @@ public DestinationSelector<Solution_> buildDestinationSelector(HeuristicConfigPo
                 minimumCacheType, selectionOrder, entityValueRangeRecorderId);
         var baseDestinationSelector =
                 new ElementDestinationSelector<>(entitySelector, valueSelector, selectionOrder.toRandomSelectionBoolean());
-        return applyNearbySelection(configPolicy, minimumCacheType, selectionOrder, baseDestinationSelector);
+        return applyNearbySelection(configPolicy, minimumCacheType, selectionOrder, baseDestinationSelector,
+                entityValueRangeRecorderId != null);
     }
 
     private IterableValueSelector<Solution_> buildIterableValueSelector(
@@ -72,14 +73,34 @@ private IterableValueSelector<Solution_> buildIterableValueSelector(
     }
 
     private DestinationSelector<Solution_> applyNearbySelection(HeuristicConfigPolicy<Solution_> configPolicy,
-            SelectionCacheType minimumCacheType, SelectionOrder resolvedSelectionOrder,
-            ElementDestinationSelector<Solution_> destinationSelector) {
+            SelectionCacheType minimumCacheType, SelectionOrder selectionOrder,
+            ElementDestinationSelector<Solution_> destinationSelector, boolean enableEntityValueRange) {
         NearbySelectionConfig nearbySelectionConfig = config.getNearbySelectionConfig();
         if (nearbySelectionConfig == null) {
             return destinationSelector;
         }
-        return TimefoldSolverEnterpriseService.loadOrFail(TimefoldSolverEnterpriseService.Feature.NEARBY_SELECTION)
-                .applyNearbySelection(config, configPolicy, minimumCacheType, resolvedSelectionOrder, destinationSelector);
+        // The nearby selector will implement its own logic to filter out unreachable elements.
+        // It requires the child selectors to not be FilteringEntityValueRangeSelector or FilteringValueRangeSelector,
+        // as it needs to iterate over all available values to construct the distance matrix.
+        if (enableEntityValueRange) {
+            var entitySelector =
+                    EntitySelectorFactory.<Solution_> create(Objects.requireNonNull(config.getEntitySelectorConfig()))
+                            .buildEntitySelector(configPolicy, minimumCacheType, selectionOrder);
+            var valueSelector = ValueSelectorFactory
+                    .<Solution_> create(Objects.requireNonNull(config.getValueSelectorConfig()))
+                    .buildValueSelector(configPolicy, entitySelector.getEntityDescriptor(), minimumCacheType,
+                            selectionOrder, configPolicy.isReinitializeVariableFilterEnabled(),
+                            ValueSelectorFactory.ListValueFilteringType.ACCEPT_ASSIGNED, null, false);
+            var updatedDestinationSelector =
+                    new ElementDestinationSelector<>(entitySelector, (IterableValueSelector<Solution_>) valueSelector,
+                            selectionOrder.toRandomSelectionBoolean());
+            return TimefoldSolverEnterpriseService.loadOrFail(TimefoldSolverEnterpriseService.Feature.NEARBY_SELECTION)
+                    .applyNearbySelection(config, configPolicy, minimumCacheType, selectionOrder,
+                            updatedDestinationSelector);
+        } else {
+            return TimefoldSolverEnterpriseService.loadOrFail(TimefoldSolverEnterpriseService.Feature.NEARBY_SELECTION)
+                    .applyNearbySelection(config, configPolicy, minimumCacheType, selectionOrder, destinationSelector);
+        }
     }
 
 }

core/src/main/java/ai/timefold/solver/core/impl/heuristic/selector/value/ValueSelectorFactory.java

@@ -126,13 +126,16 @@ public ValueSelector<Solution_> buildValueSelector(HeuristicConfigPolicy<Solutio
                 buildBaseValueSelector(variableDescriptor, SelectionCacheType.max(minimumCacheType, resolvedCacheType),
                         randomSelection);
         var instanceCache = configPolicy.getClassInstanceCache();
-        valueSelector = applyValueRangeFiltering(configPolicy, valueSelector, entityDescriptor, minimumCacheType,
-                inheritedSelectionOrder, randomSelection, entityValueRangeRecorderId,
-                assertBothSides);
         if (nearbySelectionConfig != null) {
             // TODO Static filtering (such as movableEntitySelectionFilter) should affect nearbySelection too
             valueSelector = applyNearbySelection(configPolicy, entityDescriptor, minimumCacheType,
                     resolvedSelectionOrder, valueSelector);
+        } else {
+            // The nearby selector will implement its own logic to filter out unreachable elements.
+            // Therefore, we only apply entity value range filtering if the nearby feature is not enabled;
+            // otherwise, we would end up applying the filtering logic twice.
+            valueSelector = applyValueRangeFiltering(configPolicy, valueSelector, entityDescriptor, minimumCacheType,
+                    inheritedSelectionOrder, randomSelection, entityValueRangeRecorderId, assertBothSides);
         }
         valueSelector = applyFiltering(valueSelector, instanceCache);
         valueSelector = applyInitializedChainedValueFilter(configPolicy, variableDescriptor, valueSelector);