private ValueSelector buildBaseValueSelector(
EnvironmentMode environmentMode,
PlanningVariableDescriptor variableDescriptor,
SelectionCacheType minimumCacheType,
boolean randomSelection) {
if (variableDescriptor.getValueRangeDescriptor().isEntityDependent()) {
FromEntityPropertyPlanningValueRangeDescriptor valueRangeDescriptor =
(FromEntityPropertyPlanningValueRangeDescriptor)
variableDescriptor.getValueRangeDescriptor();
// TODO should we ignore the minimumCacheType so it can be cached on changeMoves too?
return new FromEntityPropertyValueSelector(
valueRangeDescriptor, minimumCacheType, randomSelection);
} else {
// FromSolutionPropertyValueSelector caches by design, so it uses the minimumCacheType
if (variableDescriptor.isPlanningValuesCacheable()) {
if (minimumCacheType.compareTo(SelectionCacheType.PHASE) < 0) {
// TODO we probably want to default this to SelectionCacheType.JUST_IN_TIME
minimumCacheType = SelectionCacheType.PHASE;
}
} else {
if (minimumCacheType.compareTo(SelectionCacheType.STEP) < 0) {
// TODO we probably want to default this to SelectionCacheType.JUST_IN_TIME
minimumCacheType = SelectionCacheType.STEP;
}
}
return new FromSolutionPropertyValueSelector(
variableDescriptor, minimumCacheType, randomSelection);
}
}
/**
* @param configPolicy never null
* @param minimumCacheType never null, If caching is used (different from {@link
* SelectionCacheType#JUST_IN_TIME}), then it should be at least this {@link
* SelectionCacheType} because an ancestor already uses such caching and less would be
* pointless.
* @param inheritedSelectionOrder never null
* @return never null
*/
public PillarSelector buildPillarSelector(
HeuristicConfigPolicy configPolicy,
SelectionCacheType minimumCacheType,
SelectionOrder inheritedSelectionOrder) {
if (minimumCacheType.compareTo(SelectionCacheType.STEP) > 0) {
throw new IllegalArgumentException(
"The pillarSelectorConfig ("
+ this
+ ")'s minimumCacheType ("
+ minimumCacheType
+ ") must not be higher than "
+ SelectionCacheType.STEP
+ " because the pillars change every step.");
}
// EntitySelector uses SelectionOrder.ORIGINAL because a SameValuePillarSelector STEP caches the
// values
EntitySelectorConfig entitySelectorConfig_ =
entitySelectorConfig == null ? new EntitySelectorConfig() : entitySelectorConfig;
EntitySelector entitySelector =
entitySelectorConfig_.buildEntitySelector(
configPolicy, minimumCacheType, SelectionOrder.ORIGINAL);
Collection<GenuineVariableDescriptor> variableDescriptors =
entitySelector.getEntityDescriptor().getVariableDescriptors();
return new SameValuePillarSelector(
entitySelector, variableDescriptors, inheritedSelectionOrder.toRandomSelectionBoolean());
}
private ValueSelector applyCaching(
SelectionCacheType resolvedCacheType,
SelectionOrder resolvedSelectionOrder,
ValueSelector valueSelector) {
if (resolvedCacheType.isCached()
&& resolvedCacheType.compareTo(valueSelector.getCacheType()) > 0) {
if (!(valueSelector instanceof EntityIndependentValueSelector)) {
throw new IllegalArgumentException(
"The valueSelectorConfig ("
+ this
+ ") with resolvedSelectionOrder ("
+ resolvedSelectionOrder
+ ") needs to be based on a EntityIndependentValueSelector."
+ " Check your @"
+ ValueRange.class.getSimpleName()
+ " annotations.");
}
valueSelector =
new CachingValueSelector(
(EntityIndependentValueSelector) valueSelector,
resolvedCacheType,
resolvedSelectionOrder.toRandomSelectionBoolean());
}
return valueSelector;
}
