@Override
public MoveSelector buildBaseMoveSelector(
HeuristicConfigPolicy configPolicy,
SelectionCacheType minimumCacheType,
boolean randomSelection) {
EntitySelectorConfig entitySelectorConfig_ =
entitySelectorConfig == null ? new EntitySelectorConfig() : entitySelectorConfig;
EntitySelector entitySelector =
entitySelectorConfig_.buildEntitySelector(
configPolicy,
minimumCacheType,
SelectionOrder.fromRandomSelectionBoolean(randomSelection));
ValueSelectorConfig valueSelectorConfig_ =
valueSelectorConfig == null ? new ValueSelectorConfig() : valueSelectorConfig;
ValueSelector[] valueSelectors = new ValueSelector[K - 1];
for (int i = 0; i < valueSelectors.length; i++) {
valueSelectors[i] =
valueSelectorConfig_.buildValueSelector(
configPolicy,
entitySelector.getEntityDescriptor(),
minimumCacheType,
SelectionOrder.fromRandomSelectionBoolean(randomSelection));
}
return new KOptMoveSelector(entitySelector, valueSelectors, 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());
}
public SwapMoveSelector(
EntitySelector leftEntitySelector,
EntitySelector rightEntitySelector,
Collection<GenuineVariableDescriptor> variableDescriptors,
boolean randomSelection) {
this.leftEntitySelector = leftEntitySelector;
this.rightEntitySelector = rightEntitySelector;
this.variableDescriptors = variableDescriptors;
this.randomSelection = randomSelection;
EntityDescriptor leftEntityDescriptor = leftEntitySelector.getEntityDescriptor();
EntityDescriptor rightEntityDescriptor = rightEntitySelector.getEntityDescriptor();
if (!leftEntityDescriptor.getEntityClass().equals(rightEntityDescriptor.getEntityClass())) {
throw new IllegalStateException(
"The selector ("
+ this
+ ") has a leftEntitySelector's entityClass ("
+ leftEntityDescriptor.getEntityClass()
+ ") which is not equal to the rightEntitySelector's entityClass ("
+ rightEntityDescriptor.getEntityClass()
+ ").");
}
boolean anyChained = false;
if (variableDescriptors.isEmpty()) {
throw new IllegalStateException(
"The selector ("
+ this
+ ")'s variableDescriptors ("
+ variableDescriptors
+ ") is empty.");
}
for (GenuineVariableDescriptor variableDescriptor : variableDescriptors) {
if (!variableDescriptor
.getEntityDescriptor()
.getEntityClass()
.isAssignableFrom(leftEntityDescriptor.getEntityClass())) {
throw new IllegalStateException(
"The selector ("
+ this
+ ") has a variableDescriptor with a entityClass ("
+ variableDescriptor.getEntityDescriptor().getEntityClass()
+ ") which is not equal or a superclass to the leftEntitySelector's entityClass ("
+ leftEntityDescriptor.getEntityClass()
+ ").");
}
if (variableDescriptor.isChained()) {
anyChained = true;
}
}
this.anyChained = anyChained;
phaseLifecycleSupport.addEventListener(leftEntitySelector);
if (leftEntitySelector != rightEntitySelector) {
phaseLifecycleSupport.addEventListener(rightEntitySelector);
}
}
public static EntitySelector mockEntitySelector(
EntityDescriptor entityDescriptor, Object... entities) {
EntitySelector entitySelector = mock(EntitySelector.class);
when(entitySelector.getEntityDescriptor()).thenReturn(entityDescriptor);
final List<Object> entityList = Arrays.<Object>asList(entities);
when(entitySelector.iterator())
.thenAnswer(
new Answer<Iterator<Object>>() {
@Override
public Iterator<Object> answer(InvocationOnMock invocation) throws Throwable {
return entityList.iterator();
}
});
when(entitySelector.listIterator())
.thenAnswer(
new Answer<ListIterator<Object>>() {
@Override
public ListIterator<Object> answer(InvocationOnMock invocation) throws Throwable {
return entityList.listIterator();
}
});
for (int i = 0; i < entityList.size(); i++) {
final int index = i;
when(entitySelector.listIterator(index))
.thenAnswer(
new Answer<ListIterator<Object>>() {
@Override
public ListIterator<Object> answer(InvocationOnMock invocation) throws Throwable {
return entityList.listIterator(index);
}
});
}
when(entitySelector.endingIterator())
.thenAnswer(
new Answer<Iterator<Object>>() {
@Override
public Iterator<Object> answer(InvocationOnMock invocation) throws Throwable {
return entityList.iterator();
}
});
when(entitySelector.isCountable()).thenReturn(true);
when(entitySelector.isNeverEnding()).thenReturn(false);
when(entitySelector.getSize()).thenReturn((long) entityList.size());
return entitySelector;
}
@Override
protected S createUpcomingSelection() {
// Ideally, this code should have read:
// Object entity = entityIterator.next();
// Iterator<Object> valueIterator = valueSelector.iterator(entity);
// Object toValue = valueIterator.next();
// But empty selectors and ending selectors (such as non-random or shuffled) make it more
// complex
if (!entityIterator.hasNext()) {
entityIterator = entitySelector.iterator();
if (!entityIterator.hasNext()) {
return noUpcomingSelection();
}
}
Object entity = entityIterator.next();
Iterator<Object> valueIterator = valueSelector.iterator(entity);
int entityIteratorCreationCount = 0;
// This loop is mostly only relevant when the entityIterator or valueIterator is non-random or
// shuffled
while (!valueIterator.hasNext()) {
// Try the next entity
if (!entityIterator.hasNext()) {
entityIterator = entitySelector.iterator();
entityIteratorCreationCount++;
if (entityIteratorCreationCount >= 2) {
// All entity-value combinations have been tried (some even more than once)
return noUpcomingSelection();
}
}
entity = entityIterator.next();
valueIterator = valueSelector.iterator(entity);
}
Object toValue = valueIterator.next();
return newChangeSelection(entity, toValue);
}
public AbstractRandomChangeIterator(EntitySelector entitySelector, ValueSelector valueSelector) {
this.entitySelector = entitySelector;
this.valueSelector = valueSelector;
entityIterator = entitySelector.iterator();
// Don't do hasNext() in constructor (to avoid upcoming selections breaking mimic recording)
}
public boolean isNeverEnding() {
return randomSelection
|| leftEntitySelector.isNeverEnding()
|| rightEntitySelector.isNeverEnding();
}
public boolean isCountable() {
return leftEntitySelector.isCountable() && rightEntitySelector.isCountable();
}
public Iterator<Placement> iterator() {
return new QueuedEntityPlacingIterator(entitySelector.iterator());
}