index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb/SolverConfigIO.java | package ai.timefold.solver.core.impl.io.jaxb;
import java.io.Reader;
import java.io.Writer;
import ai.timefold.solver.core.config.solver.SolverConfig;
import org.w3c.dom.Document;
public class SolverConfigIO implements JaxbIO<SolverConfig> {
private static final String SOLVER_XSD_RESOURCE = "/solver.xsd";
private final GenericJaxbIO<SolverConfig> genericJaxbIO = new GenericJaxbIO<>(SolverConfig.class);
@Override
public SolverConfig read(Reader reader) {
Document document = genericJaxbIO.parseXml(reader);
String rootElementNamespace = document.getDocumentElement().getNamespaceURI();
if (SolverConfig.XML_NAMESPACE.equals(rootElementNamespace)) { // If there is the correct namespace, validate.
return genericJaxbIO.readAndValidate(document, SOLVER_XSD_RESOURCE);
} else if (rootElementNamespace == null || rootElementNamespace.isEmpty()) {
// If not, add the missing namespace to maintain backward compatibility.
return genericJaxbIO.readOverridingNamespace(document,
ElementNamespaceOverride.of(SolverConfig.XML_ELEMENT_NAME, SolverConfig.XML_NAMESPACE));
} else { // If there is an unexpected namespace, fail fast.
String errorMessage = String.format("The <%s/> element belongs to a different namespace (%s) than expected (%s).\n"
+ "Maybe you passed a benchmark configuration to a method expecting a solver configuration.",
SolverConfig.XML_ELEMENT_NAME, rootElementNamespace, SolverConfig.XML_NAMESPACE);
throw new IllegalArgumentException(errorMessage);
}
}
@Override
public void write(SolverConfig solverConfig, Writer writer) {
genericJaxbIO.writeWithoutNamespaces(solverConfig, writer);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb/TimefoldXmlSerializationException.java | package ai.timefold.solver.core.impl.io.jaxb;
public class TimefoldXmlSerializationException extends RuntimeException {
public TimefoldXmlSerializationException() {
super();
}
public TimefoldXmlSerializationException(String message) {
super(message);
}
public TimefoldXmlSerializationException(String message, Throwable cause) {
super(message, cause);
}
public TimefoldXmlSerializationException(Throwable cause) {
super(cause);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb/adapter/JaxbCustomPropertiesAdapter.java | package ai.timefold.solver.core.impl.io.jaxb.adapter;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import jakarta.xml.bind.annotation.XmlAttribute;
import jakarta.xml.bind.annotation.XmlElement;
import jakarta.xml.bind.annotation.XmlType;
import jakarta.xml.bind.annotation.adapters.XmlAdapter;
import ai.timefold.solver.core.config.solver.SolverConfig;
public class JaxbCustomPropertiesAdapter extends XmlAdapter<JaxbCustomPropertiesAdapter.JaxbAdaptedMap, Map<String, String>> {
@Override
public Map<String, String> unmarshal(JaxbAdaptedMap jaxbAdaptedMap) {
if (jaxbAdaptedMap == null) {
return null;
}
return jaxbAdaptedMap.entries.stream()
.collect(Collectors.toMap(JaxbAdaptedMapEntry::getName, JaxbAdaptedMapEntry::getValue));
}
@Override
public JaxbAdaptedMap marshal(Map<String, String> originalMap) {
if (originalMap == null) {
return null;
}
List<JaxbAdaptedMapEntry> entries = originalMap.entrySet().stream()
.map(entry -> new JaxbCustomPropertiesAdapter.JaxbAdaptedMapEntry(entry.getKey(), entry.getValue()))
.collect(Collectors.toList());
return new JaxbAdaptedMap(entries);
}
// Required to generate the XSD type in the same namespace.
@XmlType(namespace = SolverConfig.XML_NAMESPACE)
static class JaxbAdaptedMap {
@XmlElement(name = "property", namespace = SolverConfig.XML_NAMESPACE)
private List<JaxbAdaptedMapEntry> entries;
private JaxbAdaptedMap() {
// Required by JAXB
}
public JaxbAdaptedMap(List<JaxbAdaptedMapEntry> entries) {
this.entries = entries;
}
}
// Required to generate the XSD type in the same namespace.
@XmlType(namespace = SolverConfig.XML_NAMESPACE)
static class JaxbAdaptedMapEntry {
@XmlAttribute
private String name;
@XmlAttribute
private String value;
public JaxbAdaptedMapEntry() {
}
public JaxbAdaptedMapEntry(String name, String value) {
this.name = name;
this.value = value;
}
public String getName() {
return name;
}
public String getValue() {
return value;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb/adapter/JaxbDurationAdapter.java | package ai.timefold.solver.core.impl.io.jaxb.adapter;
import java.time.Duration;
import jakarta.xml.bind.annotation.adapters.XmlAdapter;
// TODO: Move the code to the jaxb-ri
public class JaxbDurationAdapter extends XmlAdapter<String, Duration> {
@Override
public Duration unmarshal(String durationString) {
if (durationString == null) {
return null;
}
return Duration.parse(durationString);
}
@Override
public String marshal(Duration duration) {
if (duration == null) {
return null;
}
return duration.toString();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb/adapter/JaxbLocaleAdapter.java | package ai.timefold.solver.core.impl.io.jaxb.adapter;
import java.util.Locale;
import jakarta.xml.bind.annotation.adapters.XmlAdapter;
public class JaxbLocaleAdapter extends XmlAdapter<String, Locale> {
@Override
public Locale unmarshal(String localeString) {
if (localeString == null) {
return null;
}
return new Locale(localeString);
}
@Override
public String marshal(Locale locale) {
if (locale == null) {
return null;
}
return locale.toString();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/io/jaxb/adapter/JaxbOffsetDateTimeAdapter.java | package ai.timefold.solver.core.impl.io.jaxb.adapter;
import java.time.DateTimeException;
import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.temporal.ChronoField;
import jakarta.xml.bind.annotation.adapters.XmlAdapter;
// TODO: Move the code to the jaxb-ri
public class JaxbOffsetDateTimeAdapter extends XmlAdapter<String, OffsetDateTime> {
private final DateTimeFormatter formatter;
public JaxbOffsetDateTimeAdapter() {
formatter = new DateTimeFormatterBuilder()
.appendPattern("uuuu-MM-dd'T'HH:mm:ss")
.appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true)
.appendOffsetId()
.toFormatter();
}
@Override
public OffsetDateTime unmarshal(String offsetDateTimeString) {
if (offsetDateTimeString == null) {
return null;
}
try {
return OffsetDateTime.from(formatter.parse(offsetDateTimeString));
} catch (DateTimeException e) {
throw new IllegalStateException("Failed to convert string (" + offsetDateTimeString + ") to type ("
+ OffsetDateTime.class.getName() + ").");
}
}
@Override
public String marshal(OffsetDateTime offsetDateTimeObject) {
if (offsetDateTimeObject == null) {
return null;
}
return formatter.format(offsetDateTimeObject);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/DefaultLocalSearchPhase.java | package ai.timefold.solver.core.impl.localsearch;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatchTotal;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.config.solver.monitoring.SolverMetric;
import ai.timefold.solver.core.impl.localsearch.decider.LocalSearchDecider;
import ai.timefold.solver.core.impl.localsearch.event.LocalSearchPhaseLifecycleListener;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
import ai.timefold.solver.core.impl.phase.AbstractPhase;
import ai.timefold.solver.core.impl.score.definition.ScoreDefinition;
import ai.timefold.solver.core.impl.score.director.InnerScore;
import ai.timefold.solver.core.impl.solver.monitoring.ScoreLevels;
import ai.timefold.solver.core.impl.solver.monitoring.SolverMetricUtil;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.impl.solver.termination.PhaseTermination;
import io.micrometer.core.instrument.Metrics;
import io.micrometer.core.instrument.Tags;
/**
* Default implementation of {@link LocalSearchPhase}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class DefaultLocalSearchPhase<Solution_> extends AbstractPhase<Solution_> implements LocalSearchPhase<Solution_>,
LocalSearchPhaseLifecycleListener<Solution_> {
protected final LocalSearchDecider<Solution_> decider;
protected final AtomicLong acceptedMoveCountPerStep = new AtomicLong(0);
protected final AtomicLong selectedMoveCountPerStep = new AtomicLong(0);
protected final Map<Tags, AtomicLong> constraintMatchTotalTagsToStepCount = new ConcurrentHashMap<>();
protected final Map<Tags, AtomicLong> constraintMatchTotalTagsToBestCount = new ConcurrentHashMap<>();
protected final Map<Tags, ScoreLevels> constraintMatchTotalStepScoreMap = new ConcurrentHashMap<>();
protected final Map<Tags, ScoreLevels> constraintMatchTotalBestScoreMap = new ConcurrentHashMap<>();
private DefaultLocalSearchPhase(Builder<Solution_> builder) {
super(builder);
decider = builder.decider;
}
@Override
public String getPhaseTypeString() {
return "Local Search";
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void solve(SolverScope<Solution_> solverScope) {
var hasAnythingToImprove = solverScope.getProblemSizeStatistics().approximateProblemSizeLog() != 0.0;
if (!hasAnythingToImprove) {
// Reaching local search means that the solution is already fully initialized.
// Yet the problem size indicates there is only 1 possible solution.
// Therefore, this solution must be it and there is nothing to improve.
logger.info("{}Local Search phase ({}) has no entities or values to move.", logIndentation, phaseIndex);
return;
}
var phaseScope = new LocalSearchPhaseScope<>(solverScope, phaseIndex);
phaseStarted(phaseScope);
if (solverScope.isMetricEnabled(SolverMetric.MOVE_COUNT_PER_STEP)) {
Metrics.gauge(SolverMetric.MOVE_COUNT_PER_STEP.getMeterId() + ".accepted",
solverScope.getMonitoringTags(), acceptedMoveCountPerStep);
Metrics.gauge(SolverMetric.MOVE_COUNT_PER_STEP.getMeterId() + ".selected",
solverScope.getMonitoringTags(), selectedMoveCountPerStep);
}
while (!phaseTermination.isPhaseTerminated(phaseScope)) {
var stepScope = new LocalSearchStepScope<>(phaseScope);
stepScope.setTimeGradient(phaseTermination.calculatePhaseTimeGradient(phaseScope));
stepStarted(stepScope);
decider.decideNextStep(stepScope);
if (stepScope.getStep() == null) {
if (phaseTermination.isPhaseTerminated(phaseScope)) {
logger.trace("{} Step index ({}), time spent ({}) terminated without picking a nextStep.",
logIndentation,
stepScope.getStepIndex(),
stepScope.getPhaseScope().calculateSolverTimeMillisSpentUpToNow());
} else if (stepScope.getSelectedMoveCount() == 0L) {
logger.warn("{} No doable selected move at step index ({}), time spent ({})."
+ " Terminating phase early.",
logIndentation,
stepScope.getStepIndex(),
stepScope.getPhaseScope().calculateSolverTimeMillisSpentUpToNow());
} else {
throw new IllegalStateException("The step index (" + stepScope.getStepIndex()
+ ") has accepted/selected move count (" + stepScope.getAcceptedMoveCount() + "/"
+ stepScope.getSelectedMoveCount()
+ ") but failed to pick a nextStep (" + stepScope.getStep() + ").");
}
// Although stepStarted has been called, stepEnded is not called for this step
break;
}
doStep(stepScope);
stepEnded(stepScope);
phaseScope.setLastCompletedStepScope(stepScope);
}
phaseEnded(phaseScope);
}
protected void doStep(LocalSearchStepScope<Solution_> stepScope) {
var step = stepScope.getStep();
stepScope.getScoreDirector().executeMove(step);
predictWorkingStepScore(stepScope, step);
var solver = stepScope.getPhaseScope().getSolverScope().getSolver();
solver.getBestSolutionRecaller().processWorkingSolutionDuringStep(stepScope);
}
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
super.solvingStarted(solverScope);
decider.solvingStarted(solverScope);
}
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
decider.phaseStarted(phaseScope);
assertWorkingSolutionInitialized(phaseScope);
}
@Override
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
super.stepStarted(stepScope);
decider.stepStarted(stepScope);
}
@Override
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
super.stepEnded(stepScope);
decider.stepEnded(stepScope);
collectMetrics(stepScope);
var phaseScope = stepScope.getPhaseScope();
if (logger.isDebugEnabled()) {
if (stepScope.getAcceptedMoveCount() == 0 && phaseTermination.isPhaseTerminated(phaseScope)) {
// Terminated early
logger.debug("{} LS step ({}), time spent ({}), score ({}), {} best score ({})," +
" terminated prematurely after selecting {} moves.",
logIndentation,
stepScope.getStepIndex(),
phaseScope.calculateSolverTimeMillisSpentUpToNow(),
stepScope.getScore().raw(),
(stepScope.getBestScoreImproved() ? "new" : " "), phaseScope.getBestScore().raw(),
stepScope.getSelectedMoveCount());
} else {
logger.debug("{} LS step ({}), time spent ({}), score ({}), {} best score ({})," +
" accepted/selected move count ({}/{}), picked move ({}).",
logIndentation,
stepScope.getStepIndex(),
phaseScope.calculateSolverTimeMillisSpentUpToNow(),
stepScope.getScore().raw(),
(stepScope.getBestScoreImproved() ? "new" : " "), phaseScope.getBestScore().raw(),
stepScope.getAcceptedMoveCount(),
stepScope.getSelectedMoveCount(),
stepScope.getStepString());
}
}
}
private void collectMetrics(LocalSearchStepScope<Solution_> stepScope) {
var phaseScope = stepScope.getPhaseScope();
var solverScope = phaseScope.getSolverScope();
if (solverScope.isMetricEnabled(SolverMetric.MOVE_COUNT_PER_STEP)) {
acceptedMoveCountPerStep.set(stepScope.getAcceptedMoveCount());
selectedMoveCountPerStep.set(stepScope.getSelectedMoveCount());
}
if (solverScope.isMetricEnabled(SolverMetric.CONSTRAINT_MATCH_TOTAL_STEP_SCORE)
|| solverScope.isMetricEnabled(SolverMetric.CONSTRAINT_MATCH_TOTAL_BEST_SCORE)) {
var scoreDirector = stepScope.getScoreDirector();
var scoreDefinition = solverScope.getScoreDefinition();
if (scoreDirector.getConstraintMatchPolicy().isEnabled()) {
for (ConstraintMatchTotal<?> constraintMatchTotal : scoreDirector.getConstraintMatchTotalMap()
.values()) {
var tags = solverScope.getMonitoringTags().and(
"constraint.package", constraintMatchTotal.getConstraintRef().packageName(),
"constraint.name", constraintMatchTotal.getConstraintRef().constraintName());
collectConstraintMatchTotalMetrics(SolverMetric.CONSTRAINT_MATCH_TOTAL_BEST_SCORE, tags,
constraintMatchTotalTagsToBestCount,
constraintMatchTotalBestScoreMap, constraintMatchTotal, scoreDefinition, solverScope);
collectConstraintMatchTotalMetrics(SolverMetric.CONSTRAINT_MATCH_TOTAL_STEP_SCORE, tags,
constraintMatchTotalTagsToStepCount,
constraintMatchTotalStepScoreMap, constraintMatchTotal, scoreDefinition, solverScope);
}
}
}
}
private <Score_ extends Score<Score_>> void collectConstraintMatchTotalMetrics(SolverMetric metric, Tags tags,
Map<Tags, AtomicLong> countMap, Map<Tags, ScoreLevels> scoreMap,
ConstraintMatchTotal<Score_> constraintMatchTotal, ScoreDefinition<Score_> scoreDefinition,
SolverScope<Solution_> solverScope) {
if (solverScope.isMetricEnabled(metric)) {
if (countMap.containsKey(tags)) {
countMap.get(tags).set(constraintMatchTotal.getConstraintMatchCount());
} else {
var count = new AtomicLong(constraintMatchTotal.getConstraintMatchCount());
countMap.put(tags, count);
Metrics.gauge(metric.getMeterId() + ".count",
tags, count);
}
SolverMetricUtil.registerScore(metric, tags, scoreDefinition, scoreMap,
InnerScore.fullyAssigned(constraintMatchTotal.getScore()));
}
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
decider.phaseEnded(phaseScope);
phaseScope.endingNow();
logger.info("{}Local Search phase ({}) ended: time spent ({}), best score ({}),"
+ " move evaluation speed ({}/sec), step total ({}).",
logIndentation,
phaseIndex,
phaseScope.calculateSolverTimeMillisSpentUpToNow(),
phaseScope.getBestScore().raw(),
phaseScope.getPhaseMoveEvaluationSpeed(),
phaseScope.getNextStepIndex());
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
super.solvingEnded(solverScope);
decider.solvingEnded(solverScope);
}
@Override
public void solvingError(SolverScope<Solution_> solverScope, Exception exception) {
super.solvingError(solverScope, exception);
decider.solvingError(solverScope, exception);
}
public static class Builder<Solution_> extends AbstractPhaseBuilder<Solution_> {
private final LocalSearchDecider<Solution_> decider;
public Builder(int phaseIndex, String logIndentation, PhaseTermination<Solution_> phaseTermination,
LocalSearchDecider<Solution_> decider) {
super(phaseIndex, logIndentation, phaseTermination);
this.decider = decider;
}
@Override
public Builder<Solution_> enableAssertions(EnvironmentMode environmentMode) {
super.enableAssertions(environmentMode);
return this;
}
@Override
public DefaultLocalSearchPhase<Solution_> build() {
return new DefaultLocalSearchPhase<>(this);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/DefaultLocalSearchPhaseFactory.java | package ai.timefold.solver.core.impl.localsearch;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.core.api.domain.entity.PinningFilter;
import ai.timefold.solver.core.api.domain.entity.PlanningPin;
import ai.timefold.solver.core.api.domain.variable.PlanningListVariable;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionCacheType;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionOrder;
import ai.timefold.solver.core.config.heuristic.selector.move.MoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.NearbyAutoConfigurationEnabled;
import ai.timefold.solver.core.config.heuristic.selector.move.composite.UnionMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.ChangeMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.SwapMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.chained.TailChainSwapMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.list.ListChangeMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.list.ListSwapMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.list.kopt.KOptListMoveSelectorConfig;
import ai.timefold.solver.core.config.localsearch.LocalSearchPhaseConfig;
import ai.timefold.solver.core.config.localsearch.LocalSearchType;
import ai.timefold.solver.core.config.localsearch.decider.acceptor.AcceptorType;
import ai.timefold.solver.core.config.localsearch.decider.acceptor.LocalSearchAcceptorConfig;
import ai.timefold.solver.core.config.localsearch.decider.forager.LocalSearchForagerConfig;
import ai.timefold.solver.core.config.localsearch.decider.forager.LocalSearchPickEarlyType;
import ai.timefold.solver.core.config.solver.PreviewFeature;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.enterprise.TimefoldSolverEnterpriseService;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.heuristic.selector.move.AbstractMoveSelectorFactory;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelectorFactory;
import ai.timefold.solver.core.impl.heuristic.selector.move.composite.UnionMoveSelectorFactory;
import ai.timefold.solver.core.impl.localsearch.decider.LocalSearchDecider;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.Acceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.AcceptorFactory;
import ai.timefold.solver.core.impl.localsearch.decider.forager.LocalSearchForager;
import ai.timefold.solver.core.impl.localsearch.decider.forager.LocalSearchForagerFactory;
import ai.timefold.solver.core.impl.move.MoveRepository;
import ai.timefold.solver.core.impl.move.MoveSelectorBasedMoveRepository;
import ai.timefold.solver.core.impl.move.MoveStreamsBasedMoveRepository;
import ai.timefold.solver.core.impl.move.streams.DefaultMoveStreamFactory;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveProviders;
import ai.timefold.solver.core.impl.phase.AbstractPhaseFactory;
import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecaller;
import ai.timefold.solver.core.impl.solver.termination.PhaseTermination;
import ai.timefold.solver.core.impl.solver.termination.SolverTermination;
import ai.timefold.solver.core.preview.api.domain.metamodel.PlanningVariableMetaModel;
public class DefaultLocalSearchPhaseFactory<Solution_> extends AbstractPhaseFactory<Solution_, LocalSearchPhaseConfig> {
public DefaultLocalSearchPhaseFactory(LocalSearchPhaseConfig phaseConfig) {
super(phaseConfig);
}
@Override
public LocalSearchPhase<Solution_> buildPhase(int phaseIndex, boolean lastInitializingPhase,
HeuristicConfigPolicy<Solution_> solverConfigPolicy, BestSolutionRecaller<Solution_> bestSolutionRecaller,
SolverTermination<Solution_> solverTermination) {
var moveProviderClass = phaseConfig.<Solution_> getMoveProvidersClass();
var moveStreamsEnabled = moveProviderClass != null;
var moveSelectorConfig = phaseConfig.getMoveSelectorConfig();
var moveSelectorsEnabled = moveSelectorConfig != null;
if (moveSelectorsEnabled && moveStreamsEnabled) {
throw new UnsupportedOperationException("""
The solver configuration enabled both move selectors and Move Streams.
These are mutually exclusive features, please pick one or the other.""");
}
var phaseConfigPolicy = solverConfigPolicy.createPhaseConfigPolicy();
var phaseTermination = buildPhaseTermination(phaseConfigPolicy, solverTermination);
var decider = moveStreamsEnabled
? buildMoveStreamsBasedDecider(phaseConfigPolicy, phaseTermination, moveProviderClass)
: buildMoveSelectorBasedDecider(phaseConfigPolicy, phaseTermination);
return new DefaultLocalSearchPhase.Builder<>(phaseIndex, solverConfigPolicy.getLogIndentation(), phaseTermination,
decider)
.enableAssertions(phaseConfigPolicy.getEnvironmentMode())
.build();
}
private LocalSearchDecider<Solution_> buildMoveSelectorBasedDecider(HeuristicConfigPolicy<Solution_> configPolicy,
PhaseTermination<Solution_> termination) {
var moveRepository = new MoveSelectorBasedMoveRepository<>(buildMoveSelector(configPolicy));
return buildDecider(moveRepository, configPolicy, termination);
}
private LocalSearchDecider<Solution_> buildMoveStreamsBasedDecider(HeuristicConfigPolicy<Solution_> configPolicy,
PhaseTermination<Solution_> termination, Class<? extends MoveProviders<Solution_>> moveProvidersClass) {
configPolicy.ensurePreviewFeature(PreviewFeature.MOVE_STREAMS);
var solutionDescriptor = configPolicy.getSolutionDescriptor();
var solutionMetaModel = solutionDescriptor.getMetaModel();
if (solutionMetaModel.genuineEntities().size() > 1) {
throw new UnsupportedOperationException(
"Move Streams currently only support solutions with a single entity class, not multiple.");
}
var entityMetaModel = solutionMetaModel.genuineEntities().get(0);
if (entityMetaModel.genuineVariables().size() > 1) {
throw new UnsupportedOperationException(
"Move Streams currently only support solutions with a single variable class, not multiple.");
}
var variableMetaModel = entityMetaModel.genuineVariables().get(0);
if (variableMetaModel instanceof PlanningVariableMetaModel<Solution_, ?, ?> planningVariableMetaModel
&& planningVariableMetaModel.isChained()) {
throw new UnsupportedOperationException("""
Move Streams don't support solutions with chained variables.
Convert your model to use @%s instead."""
.formatted(PlanningListVariable.class.getSimpleName()));
}
var entitiesWithPinningFilters = solutionDescriptor.getEntityDescriptors().stream()
.filter(EntityDescriptor::hasPinningFilter)
.toList();
if (!entitiesWithPinningFilters.isEmpty()) {
throw new UnsupportedOperationException("""
%s is deprecated and Move Streams do not support it.
Convert your entities (%s) to use @%s instead."""
.formatted(PinningFilter.class.getSimpleName(), entitiesWithPinningFilters,
PlanningPin.class.getSimpleName()));
}
if (!MoveProviders.class.isAssignableFrom(moveProvidersClass)) {
throw new IllegalArgumentException(
"The moveProvidersClass (%s) does not implement %s."
.formatted(moveProvidersClass, MoveProviders.class.getSimpleName()));
}
var moveProviders =
ConfigUtils.newInstance(LocalSearchPhaseConfig.class::getSimpleName, "moveProvidersClass", moveProvidersClass);
var moveProviderList = moveProviders.defineMoves(solutionMetaModel);
if (moveProviderList.size() != 1) {
throw new IllegalArgumentException(
"The moveProvidersClass (%s) must define exactly one MoveProvider, not %s."
.formatted(moveProvidersClass, moveProviderList.size()));
}
var moveProvider = moveProviderList.get(0);
var moveStreamFactory = new DefaultMoveStreamFactory<>(solutionDescriptor, configPolicy.getEnvironmentMode());
var moveProducer = moveProvider.apply(moveStreamFactory);
var moveRepository = new MoveStreamsBasedMoveRepository<>(moveStreamFactory, moveProducer,
pickSelectionOrder() == SelectionOrder.RANDOM);
return buildDecider(moveRepository, configPolicy, termination);
}
private LocalSearchDecider<Solution_> buildDecider(MoveRepository<Solution_> moveRepository,
HeuristicConfigPolicy<Solution_> configPolicy, PhaseTermination<Solution_> termination) {
var acceptor = buildAcceptor(configPolicy, moveRepository instanceof MoveStreamsBasedMoveRepository<Solution_>);
var forager = buildForager(configPolicy);
if (moveRepository.isNeverEnding() && !forager.supportsNeverEndingMoveSelector()) {
throw new IllegalStateException("""
The move repository (%s) is neverEnding (%s), but the forager (%s) does not support it.
Maybe configure the <forager> with an <acceptedCountLimit>."""
.formatted(moveRepository, moveRepository.isNeverEnding(), forager));
}
var moveThreadCount = configPolicy.getMoveThreadCount();
var environmentMode = configPolicy.getEnvironmentMode();
var decider = moveThreadCount == null
? new LocalSearchDecider<>(configPolicy.getLogIndentation(), termination, moveRepository, acceptor, forager)
: TimefoldSolverEnterpriseService.loadOrFail(TimefoldSolverEnterpriseService.Feature.MULTITHREADED_SOLVING)
.buildLocalSearch(moveThreadCount, termination, moveRepository, acceptor, forager, environmentMode,
configPolicy);
decider.enableAssertions(environmentMode);
return decider;
}
protected Acceptor<Solution_> buildAcceptor(HeuristicConfigPolicy<Solution_> configPolicy, boolean moveStreamsEnabled) {
var acceptorConfig = phaseConfig.getAcceptorConfig();
var localSearchType = phaseConfig.getLocalSearchType();
if (acceptorConfig != null) {
if (localSearchType != null) {
throw new IllegalArgumentException(
"The localSearchType (%s) must not be configured if the acceptorConfig (%s) is explicitly configured."
.formatted(localSearchType, acceptorConfig));
}
return buildAcceptor(acceptorConfig, configPolicy);
} else {
var localSearchType_ = Objects.requireNonNullElse(localSearchType, LocalSearchType.LATE_ACCEPTANCE);
var acceptorConfig_ = new LocalSearchAcceptorConfig();
if (moveStreamsEnabled && localSearchType_ == LocalSearchType.VARIABLE_NEIGHBORHOOD_DESCENT) {
// Maybe works, but never tested.
throw new UnsupportedOperationException(
"Variable Neighborhood descent is not yet supported with Move Streams.");
}
var acceptorType = switch (localSearchType_) {
case HILL_CLIMBING, VARIABLE_NEIGHBORHOOD_DESCENT -> AcceptorType.HILL_CLIMBING;
case TABU_SEARCH -> AcceptorType.ENTITY_TABU;
case SIMULATED_ANNEALING -> AcceptorType.SIMULATED_ANNEALING;
case LATE_ACCEPTANCE -> AcceptorType.LATE_ACCEPTANCE;
case DIVERSIFIED_LATE_ACCEPTANCE -> AcceptorType.DIVERSIFIED_LATE_ACCEPTANCE;
case GREAT_DELUGE -> AcceptorType.GREAT_DELUGE;
};
if (moveStreamsEnabled && acceptorType.isTabu()) {
throw new UnsupportedOperationException("Tabu search is not yet supported with Move Streams.");
}
acceptorConfig_.setAcceptorTypeList(Collections.singletonList(acceptorType));
return buildAcceptor(acceptorConfig_, configPolicy);
}
}
private Acceptor<Solution_> buildAcceptor(LocalSearchAcceptorConfig acceptorConfig,
HeuristicConfigPolicy<Solution_> configPolicy) {
return AcceptorFactory.<Solution_> create(acceptorConfig)
.buildAcceptor(configPolicy);
}
protected LocalSearchForager<Solution_> buildForager(HeuristicConfigPolicy<Solution_> configPolicy) {
LocalSearchForagerConfig foragerConfig_;
if (phaseConfig.getForagerConfig() != null) {
if (phaseConfig.getLocalSearchType() != null) {
throw new IllegalArgumentException(
"The localSearchType (%s) must not be configured if the foragerConfig (%s) is explicitly configured."
.formatted(phaseConfig.getLocalSearchType(), phaseConfig.getForagerConfig()));
}
foragerConfig_ = phaseConfig.getForagerConfig();
} else {
var localSearchType_ =
Objects.requireNonNullElse(phaseConfig.getLocalSearchType(), LocalSearchType.LATE_ACCEPTANCE);
foragerConfig_ = new LocalSearchForagerConfig();
switch (localSearchType_) {
case HILL_CLIMBING:
foragerConfig_.setAcceptedCountLimit(1);
break;
case TABU_SEARCH:
// Slow stepping algorithm
foragerConfig_.setAcceptedCountLimit(1000);
break;
case SIMULATED_ANNEALING:
case LATE_ACCEPTANCE:
case DIVERSIFIED_LATE_ACCEPTANCE:
case GREAT_DELUGE:
// Fast stepping algorithm
foragerConfig_.setAcceptedCountLimit(1);
break;
case VARIABLE_NEIGHBORHOOD_DESCENT:
foragerConfig_.setPickEarlyType(LocalSearchPickEarlyType.FIRST_LAST_STEP_SCORE_IMPROVING);
break;
default:
throw new IllegalStateException("The localSearchType (%s) is not implemented."
.formatted(localSearchType_));
}
}
return LocalSearchForagerFactory.<Solution_> create(foragerConfig_).buildForager();
}
@SuppressWarnings("rawtypes")
private MoveSelector<Solution_> buildMoveSelector(HeuristicConfigPolicy<Solution_> configPolicy) {
MoveSelector<Solution_> moveSelector;
var defaultCacheType = SelectionCacheType.JUST_IN_TIME;
var defaultSelectionOrder = pickSelectionOrder();
var moveSelectorConfig = phaseConfig.getMoveSelectorConfig();
if (moveSelectorConfig == null) {
moveSelector = new UnionMoveSelectorFactory<Solution_>(determineDefaultMoveSelectorConfig(configPolicy))
.buildMoveSelector(configPolicy, defaultCacheType, defaultSelectionOrder, true);
} else {
AbstractMoveSelectorFactory<Solution_, ?> moveSelectorFactory = MoveSelectorFactory.create(moveSelectorConfig);
if (configPolicy.getNearbyDistanceMeterClass() != null
&& NearbyAutoConfigurationEnabled.class.isAssignableFrom(moveSelectorConfig.getClass())
&& !UnionMoveSelectorConfig.class.isAssignableFrom(moveSelectorConfig.getClass())) {
// The move selector config is not a composite selector, but it accepts Nearby autoconfiguration.
// We create a new UnionMoveSelectorConfig with the existing selector to enable Nearby autoconfiguration.
var moveSelectorCopy = (MoveSelectorConfig) moveSelectorConfig.copyConfig();
var updatedConfig = new UnionMoveSelectorConfig()
.withMoveSelectors(moveSelectorCopy);
moveSelectorFactory = MoveSelectorFactory.create(updatedConfig);
}
moveSelector = moveSelectorFactory.buildMoveSelector(configPolicy, defaultCacheType, defaultSelectionOrder, true);
}
return moveSelector;
}
private SelectionOrder pickSelectionOrder() {
return phaseConfig.getLocalSearchType() == LocalSearchType.VARIABLE_NEIGHBORHOOD_DESCENT ? SelectionOrder.ORIGINAL
: SelectionOrder.RANDOM;
}
private UnionMoveSelectorConfig determineDefaultMoveSelectorConfig(HeuristicConfigPolicy<Solution_> configPolicy) {
var solutionDescriptor = configPolicy.getSolutionDescriptor();
if (solutionDescriptor.hasBothBasicAndListVariables()) {
var moveSelectorList = new ArrayList<MoveSelectorConfig>();
// Specific basic variable moves
moveSelectorList.addAll(List.of(new ChangeMoveSelectorConfig(), new SwapMoveSelectorConfig()));
// Specific list variable moves
moveSelectorList.addAll(List.of(new ListChangeMoveSelectorConfig(), new ListSwapMoveSelectorConfig(),
new KOptListMoveSelectorConfig()));
return new UnionMoveSelectorConfig().withMoveSelectorList(moveSelectorList);
} else if (solutionDescriptor.hasListVariable()) {
// We only have the one list variable.
return new UnionMoveSelectorConfig().withMoveSelectors(new ListChangeMoveSelectorConfig(),
new ListSwapMoveSelectorConfig(), new KOptListMoveSelectorConfig());
} else {
// We only have basic variables.
var basicVariableDescriptorList = solutionDescriptor.getBasicVariableDescriptorList();
if (solutionDescriptor.hasChainedVariable() && basicVariableDescriptorList.size() == 1) {
// if there is only one chained variable, we add TailChainSwapMoveSelectorConfig
return new UnionMoveSelectorConfig()
.withMoveSelectors(new ChangeMoveSelectorConfig(), new SwapMoveSelectorConfig(),
new TailChainSwapMoveSelectorConfig());
} else {
// Basic variables or a mixed model with basic and chained variables
return new UnionMoveSelectorConfig().withMoveSelectors(new ChangeMoveSelectorConfig(),
new SwapMoveSelectorConfig());
}
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/LocalSearchPhase.java | package ai.timefold.solver.core.impl.localsearch;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.lateacceptance.LateAcceptanceAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.simulatedannealing.SimulatedAnnealingAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.AbstractTabuAcceptor;
import ai.timefold.solver.core.impl.phase.AbstractPhase;
import ai.timefold.solver.core.impl.phase.Phase;
/**
* A {@link LocalSearchPhase} is a {@link Phase} which uses a Local Search algorithm,
* such as {@link AbstractTabuAcceptor Tabu Search}, {@link SimulatedAnnealingAcceptor Simulated Annealing},
* {@link LateAcceptanceAcceptor Late Acceptance}, ...
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @see Phase
* @see AbstractPhase
* @see DefaultLocalSearchPhase
*/
public interface LocalSearchPhase<Solution_> extends Phase<Solution_> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/LocalSearchDecider.java | package ai.timefold.solver.core.impl.localsearch.decider;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.heuristic.move.LegacyMoveAdapter;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.Acceptor;
import ai.timefold.solver.core.impl.localsearch.decider.forager.LocalSearchForager;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
import ai.timefold.solver.core.impl.move.MoveRepository;
import ai.timefold.solver.core.impl.phase.scope.SolverLifecyclePoint;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.impl.solver.termination.PhaseTermination;
import ai.timefold.solver.core.impl.solver.termination.Termination;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class LocalSearchDecider<Solution_> {
protected final transient Logger logger = LoggerFactory.getLogger(getClass());
protected final String logIndentation;
protected final PhaseTermination<Solution_> termination;
protected final MoveRepository<Solution_> moveRepository;
protected final Acceptor<Solution_> acceptor;
protected final LocalSearchForager<Solution_> forager;
protected boolean assertMoveScoreFromScratch = false;
protected boolean assertExpectedUndoMoveScore = false;
public LocalSearchDecider(String logIndentation, PhaseTermination<Solution_> termination,
MoveRepository<Solution_> moveRepository, Acceptor<Solution_> acceptor, LocalSearchForager<Solution_> forager) {
this.logIndentation = logIndentation;
this.termination = termination;
this.moveRepository = moveRepository;
this.acceptor = acceptor;
this.forager = forager;
}
public Termination<Solution_> getTermination() {
return termination;
}
public MoveRepository<Solution_> getMoveRepository() {
return moveRepository;
}
public Acceptor<Solution_> getAcceptor() {
return acceptor;
}
public LocalSearchForager<Solution_> getForager() {
return forager;
}
public void enableAssertions(EnvironmentMode environmentMode) {
assertMoveScoreFromScratch = environmentMode.isFullyAsserted();
assertExpectedUndoMoveScore = environmentMode.isIntrusivelyAsserted();
}
// ************************************************************************
// Worker methods
// ************************************************************************
public void solvingStarted(SolverScope<Solution_> solverScope) {
moveRepository.solvingStarted(solverScope);
acceptor.solvingStarted(solverScope);
forager.solvingStarted(solverScope);
}
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
moveRepository.phaseStarted(phaseScope);
acceptor.phaseStarted(phaseScope);
forager.phaseStarted(phaseScope);
}
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
moveRepository.stepStarted(stepScope);
acceptor.stepStarted(stepScope);
forager.stepStarted(stepScope);
}
public void decideNextStep(LocalSearchStepScope<Solution_> stepScope) {
var scoreDirector = stepScope.getScoreDirector();
scoreDirector.setAllChangesWillBeUndoneBeforeStepEnds(true);
var moveIndex = 0;
for (var move : moveRepository) {
var moveScope = new LocalSearchMoveScope<>(stepScope, moveIndex, move);
moveIndex++;
doMove(moveScope);
if (forager.isQuitEarly()) {
break;
}
stepScope.getPhaseScope().getSolverScope().checkYielding();
if (termination.isPhaseTerminated(stepScope.getPhaseScope())) {
break;
}
}
scoreDirector.setAllChangesWillBeUndoneBeforeStepEnds(false);
pickMove(stepScope);
}
protected <Score_ extends Score<Score_>> void doMove(LocalSearchMoveScope<Solution_> moveScope) {
var scoreDirector = moveScope.<Score_> getScoreDirector();
var moveDirector = moveScope.getStepScope().<Score_> getMoveDirector();
var move = moveScope.getMove();
if (!LegacyMoveAdapter.isDoable(moveDirector, move)) {
throw new IllegalStateException("Impossible state: Local search move selector (" + moveRepository
+ ") provided a non-doable move (" + moveScope.getMove() + ").");
}
var score = scoreDirector.executeTemporaryMove(moveScope.getMove(), assertMoveScoreFromScratch);
moveScope.setScore(score);
moveScope.setAccepted(acceptor.isAccepted(moveScope));
forager.addMove(moveScope);
if (assertExpectedUndoMoveScore) {
scoreDirector.assertExpectedUndoMoveScore(moveScope.getMove(),
moveScope.getStepScope().getPhaseScope().getLastCompletedStepScope().getScore(),
SolverLifecyclePoint.of(moveScope));
}
logger.trace("{} Move index ({}), score ({}), accepted ({}), move ({}).",
logIndentation, moveScope.getMoveIndex(), moveScope.getScore().raw(), moveScope.getAccepted(),
moveScope.getMove());
}
protected void pickMove(LocalSearchStepScope<Solution_> stepScope) {
var pickedMoveScope = forager.pickMove(stepScope);
if (pickedMoveScope != null) {
var step = pickedMoveScope.getMove();
stepScope.setStep(step);
if (logger.isDebugEnabled()) {
stepScope.setStepString(step.toString());
}
stepScope.setScore(pickedMoveScope.getScore());
}
}
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
moveRepository.stepEnded(stepScope);
acceptor.stepEnded(stepScope);
forager.stepEnded(stepScope);
}
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
moveRepository.phaseEnded(phaseScope);
acceptor.phaseEnded(phaseScope);
forager.phaseEnded(phaseScope);
}
public void solvingEnded(SolverScope<Solution_> solverScope) {
moveRepository.solvingEnded(solverScope);
acceptor.solvingEnded(solverScope);
forager.solvingEnded(solverScope);
}
public void solvingError(SolverScope<Solution_> solverScope, Exception exception) {
// Overridable by a subclass.
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/AbstractAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor;
import ai.timefold.solver.core.impl.localsearch.event.LocalSearchPhaseLifecycleListenerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Abstract superclass for {@link Acceptor}.
*
* @see Acceptor
*/
public abstract class AbstractAcceptor<Solution_> extends LocalSearchPhaseLifecycleListenerAdapter<Solution_>
implements Acceptor<Solution_> {
protected final transient Logger logger = LoggerFactory.getLogger(getClass());
// ************************************************************************
// Worker methods
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/Acceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor;
import ai.timefold.solver.core.impl.heuristic.move.Move;
import ai.timefold.solver.core.impl.localsearch.decider.forager.LocalSearchForager;
import ai.timefold.solver.core.impl.localsearch.event.LocalSearchPhaseLifecycleListener;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
/**
* An Acceptor accepts or rejects a selected {@link Move}.
* Note that the {@link LocalSearchForager} can still ignore the advice of the {@link Acceptor}.
*
* @see AbstractAcceptor
*/
public interface Acceptor<Solution_> extends LocalSearchPhaseLifecycleListener<Solution_> {
/**
* @param moveScope not null
* @return true if accepted
*/
boolean isAccepted(LocalSearchMoveScope<Solution_> moveScope);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/AcceptorFactory.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import ai.timefold.solver.core.config.localsearch.decider.acceptor.AcceptorType;
import ai.timefold.solver.core.config.localsearch.decider.acceptor.LocalSearchAcceptorConfig;
import ai.timefold.solver.core.config.localsearch.decider.acceptor.stepcountinghillclimbing.StepCountingHillClimbingType;
import ai.timefold.solver.core.config.solver.PreviewFeature;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.greatdeluge.GreatDelugeAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.hillclimbing.HillClimbingAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.lateacceptance.DiversifiedLateAcceptanceAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.lateacceptance.LateAcceptanceAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.simulatedannealing.SimulatedAnnealingAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.stepcountinghillclimbing.StepCountingHillClimbingAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.EntityTabuAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.MoveTabuAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.ValueTabuAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.size.EntityRatioTabuSizeStrategy;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.size.FixedTabuSizeStrategy;
public class AcceptorFactory<Solution_> {
// Based on Tomas Muller's work. TODO Confirm with benchmark across our examples/datasets
private static final double DEFAULT_WATER_LEVEL_INCREMENT_RATIO = 0.00_000_005;
public static <Solution_> AcceptorFactory<Solution_> create(LocalSearchAcceptorConfig acceptorConfig) {
return new AcceptorFactory<>(acceptorConfig);
}
private final LocalSearchAcceptorConfig acceptorConfig;
public AcceptorFactory(LocalSearchAcceptorConfig acceptorConfig) {
this.acceptorConfig = acceptorConfig;
}
public Acceptor<Solution_> buildAcceptor(HeuristicConfigPolicy<Solution_> configPolicy) {
List<Acceptor<Solution_>> acceptorList = Stream.of(
buildHillClimbingAcceptor(),
buildStepCountingHillClimbingAcceptor(),
buildEntityTabuAcceptor(configPolicy),
buildValueTabuAcceptor(configPolicy),
buildMoveTabuAcceptor(configPolicy),
buildSimulatedAnnealingAcceptor(configPolicy),
buildLateAcceptanceAcceptor(),
buildDiversifiedLateAcceptanceAcceptor(configPolicy),
buildGreatDelugeAcceptor(configPolicy))
.filter(Optional::isPresent)
.map(Optional::get)
.collect(Collectors.toList());
if (acceptorList.size() == 1) {
return acceptorList.get(0);
} else if (acceptorList.size() > 1) {
return new CompositeAcceptor<>(acceptorList);
} else {
throw new IllegalArgumentException(
"The acceptor does not specify any acceptorType (" + acceptorConfig.getAcceptorTypeList()
+ ") or other acceptor property.\n"
+ "For a good starting values,"
+ " see the docs section \"Which optimization algorithms should I use?\".");
}
}
private Optional<HillClimbingAcceptor<Solution_>> buildHillClimbingAcceptor() {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.HILL_CLIMBING)) {
return Optional.of(new HillClimbingAcceptor<>());
}
return Optional.empty();
}
private boolean acceptorTypeListsContainsAcceptorType(AcceptorType acceptorType) {
var acceptorTypeList = acceptorConfig.getAcceptorTypeList();
return acceptorTypeList != null && acceptorTypeList.contains(acceptorType);
}
private Optional<StepCountingHillClimbingAcceptor<Solution_>> buildStepCountingHillClimbingAcceptor() {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.STEP_COUNTING_HILL_CLIMBING)
|| acceptorConfig.getStepCountingHillClimbingSize() != null) {
int stepCountingHillClimbingSize_ =
Objects.requireNonNullElse(acceptorConfig.getStepCountingHillClimbingSize(), 400);
var stepCountingHillClimbingType_ =
Objects.requireNonNullElse(acceptorConfig.getStepCountingHillClimbingType(),
StepCountingHillClimbingType.STEP);
var acceptor = new StepCountingHillClimbingAcceptor<Solution_>(
stepCountingHillClimbingSize_, stepCountingHillClimbingType_);
return Optional.of(acceptor);
}
return Optional.empty();
}
private Optional<EntityTabuAcceptor<Solution_>> buildEntityTabuAcceptor(HeuristicConfigPolicy<Solution_> configPolicy) {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.ENTITY_TABU)
|| acceptorConfig.getEntityTabuSize() != null || acceptorConfig.getEntityTabuRatio() != null
|| acceptorConfig.getFadingEntityTabuSize() != null || acceptorConfig.getFadingEntityTabuRatio() != null) {
var acceptor = new EntityTabuAcceptor<Solution_>(configPolicy.getLogIndentation());
if (acceptorConfig.getEntityTabuSize() != null) {
if (acceptorConfig.getEntityTabuRatio() != null) {
throw new IllegalArgumentException("The acceptor cannot have both acceptorConfig.getEntityTabuSize() ("
+ acceptorConfig.getEntityTabuSize() + ") and acceptorConfig.getEntityTabuRatio() ("
+ acceptorConfig.getEntityTabuRatio() + ").");
}
acceptor.setTabuSizeStrategy(new FixedTabuSizeStrategy<>(acceptorConfig.getEntityTabuSize()));
} else if (acceptorConfig.getEntityTabuRatio() != null) {
acceptor.setTabuSizeStrategy(new EntityRatioTabuSizeStrategy<>(acceptorConfig.getEntityTabuRatio()));
} else if (acceptorConfig.getFadingEntityTabuSize() == null && acceptorConfig.getFadingEntityTabuRatio() == null) {
acceptor.setTabuSizeStrategy(new EntityRatioTabuSizeStrategy<>(0.1));
}
if (acceptorConfig.getFadingEntityTabuSize() != null) {
if (acceptorConfig.getFadingEntityTabuRatio() != null) {
throw new IllegalArgumentException(
"The acceptor cannot have both acceptorConfig.getFadingEntityTabuSize() ("
+ acceptorConfig.getFadingEntityTabuSize()
+ ") and acceptorConfig.getFadingEntityTabuRatio() ("
+ acceptorConfig.getFadingEntityTabuRatio() + ").");
}
acceptor.setFadingTabuSizeStrategy(new FixedTabuSizeStrategy<>(acceptorConfig.getFadingEntityTabuSize()));
} else if (acceptorConfig.getFadingEntityTabuRatio() != null) {
acceptor.setFadingTabuSizeStrategy(
new EntityRatioTabuSizeStrategy<>(acceptorConfig.getFadingEntityTabuRatio()));
}
if (configPolicy.getEnvironmentMode().isFullyAsserted()) {
acceptor.setAssertTabuHashCodeCorrectness(true);
}
return Optional.of(acceptor);
}
return Optional.empty();
}
private Optional<ValueTabuAcceptor<Solution_>> buildValueTabuAcceptor(HeuristicConfigPolicy<Solution_> configPolicy) {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.VALUE_TABU)
|| acceptorConfig.getValueTabuSize() != null || acceptorConfig.getValueTabuRatio() != null
|| acceptorConfig.getFadingValueTabuSize() != null || acceptorConfig.getFadingValueTabuRatio() != null) {
var acceptor = new ValueTabuAcceptor<Solution_>(configPolicy.getLogIndentation());
if (acceptorConfig.getValueTabuSize() != null) {
if (acceptorConfig.getValueTabuRatio() != null) {
throw new IllegalArgumentException("The acceptor cannot have both acceptorConfig.getValueTabuSize() ("
+ acceptorConfig.getValueTabuSize() + ") and acceptorConfig.getValueTabuRatio() ("
+ acceptorConfig.getValueTabuRatio() + ").");
}
acceptor.setTabuSizeStrategy(new FixedTabuSizeStrategy<>(acceptorConfig.getValueTabuSize()));
} else if (acceptorConfig.getValueTabuRatio() != null) {
/*
* Although the strategy was implemented, it always threw UnsupportedOperationException.
* Therefore the strategy was removed and exception thrown here directly.
*/
throw new UnsupportedOperationException();
}
if (acceptorConfig.getFadingValueTabuSize() != null) {
if (acceptorConfig.getFadingValueTabuRatio() != null) {
throw new IllegalArgumentException("The acceptor cannot have both acceptorConfig.getFadingValueTabuSize() ("
+ acceptorConfig.getFadingValueTabuSize() + ") and acceptorConfig.getFadingValueTabuRatio() ("
+ acceptorConfig.getFadingValueTabuRatio() + ").");
}
acceptor.setFadingTabuSizeStrategy(new FixedTabuSizeStrategy<>(acceptorConfig.getFadingValueTabuSize()));
} else if (acceptorConfig.getFadingValueTabuRatio() != null) {
/*
* Although the strategy was implemented, it always threw UnsupportedOperationException.
* Therefore the strategy was removed and exception thrown here directly.
*/
throw new UnsupportedOperationException();
}
if (acceptorConfig.getValueTabuSize() != null) {
acceptor.setTabuSizeStrategy(new FixedTabuSizeStrategy<>(acceptorConfig.getValueTabuSize()));
}
if (acceptorConfig.getFadingValueTabuSize() != null) {
acceptor.setFadingTabuSizeStrategy(new FixedTabuSizeStrategy<>(acceptorConfig.getFadingValueTabuSize()));
}
if (configPolicy.getEnvironmentMode().isFullyAsserted()) {
acceptor.setAssertTabuHashCodeCorrectness(true);
}
return Optional.of(acceptor);
}
return Optional.empty();
}
private Optional<MoveTabuAcceptor<Solution_>> buildMoveTabuAcceptor(HeuristicConfigPolicy<Solution_> configPolicy) {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.MOVE_TABU)
|| acceptorConfig.getMoveTabuSize() != null || acceptorConfig.getFadingMoveTabuSize() != null) {
var acceptor = new MoveTabuAcceptor<Solution_>(configPolicy.getLogIndentation());
if (acceptorConfig.getMoveTabuSize() != null) {
acceptor.setTabuSizeStrategy(new FixedTabuSizeStrategy<>(acceptorConfig.getMoveTabuSize()));
}
if (acceptorConfig.getFadingMoveTabuSize() != null) {
acceptor.setFadingTabuSizeStrategy(new FixedTabuSizeStrategy<>(acceptorConfig.getFadingMoveTabuSize()));
}
if (configPolicy.getEnvironmentMode().isFullyAsserted()) {
acceptor.setAssertTabuHashCodeCorrectness(true);
}
return Optional.of(acceptor);
}
return Optional.empty();
}
private Optional<SimulatedAnnealingAcceptor<Solution_>>
buildSimulatedAnnealingAcceptor(HeuristicConfigPolicy<Solution_> configPolicy) {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.SIMULATED_ANNEALING)
|| acceptorConfig.getSimulatedAnnealingStartingTemperature() != null) {
var acceptor = new SimulatedAnnealingAcceptor<Solution_>();
if (acceptorConfig.getSimulatedAnnealingStartingTemperature() == null) {
// TODO Support SA without a parameter
throw new IllegalArgumentException("The acceptorType (" + AcceptorType.SIMULATED_ANNEALING
+ ") currently requires a acceptorConfig.getSimulatedAnnealingStartingTemperature() ("
+ acceptorConfig.getSimulatedAnnealingStartingTemperature() + ").");
}
acceptor.setStartingTemperature(
configPolicy.getScoreDefinition().parseScore(acceptorConfig.getSimulatedAnnealingStartingTemperature()));
return Optional.of(acceptor);
}
return Optional.empty();
}
private Optional<LateAcceptanceAcceptor<Solution_>> buildLateAcceptanceAcceptor() {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.LATE_ACCEPTANCE)
|| (!acceptorTypeListsContainsAcceptorType(AcceptorType.DIVERSIFIED_LATE_ACCEPTANCE)
&& acceptorConfig.getLateAcceptanceSize() != null)) {
var acceptor = new LateAcceptanceAcceptor<Solution_>();
acceptor.setLateAcceptanceSize(Objects.requireNonNullElse(acceptorConfig.getLateAcceptanceSize(), 400));
return Optional.of(acceptor);
}
return Optional.empty();
}
private Optional<DiversifiedLateAcceptanceAcceptor<Solution_>>
buildDiversifiedLateAcceptanceAcceptor(HeuristicConfigPolicy<Solution_> configPolicy) {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.DIVERSIFIED_LATE_ACCEPTANCE)) {
configPolicy.ensurePreviewFeature(PreviewFeature.DIVERSIFIED_LATE_ACCEPTANCE);
var acceptor = new DiversifiedLateAcceptanceAcceptor<Solution_>();
acceptor.setLateAcceptanceSize(Objects.requireNonNullElse(acceptorConfig.getLateAcceptanceSize(), 5));
return Optional.of(acceptor);
}
return Optional.empty();
}
private Optional<GreatDelugeAcceptor<Solution_>> buildGreatDelugeAcceptor(HeuristicConfigPolicy<Solution_> configPolicy) {
if (acceptorTypeListsContainsAcceptorType(AcceptorType.GREAT_DELUGE)
|| acceptorConfig.getGreatDelugeWaterLevelIncrementScore() != null
|| acceptorConfig.getGreatDelugeWaterLevelIncrementRatio() != null) {
var acceptor = new GreatDelugeAcceptor<Solution_>();
if (acceptorConfig.getGreatDelugeWaterLevelIncrementScore() != null) {
if (acceptorConfig.getGreatDelugeWaterLevelIncrementRatio() != null) {
throw new IllegalArgumentException("The acceptor cannot have both a "
+ "acceptorConfig.getGreatDelugeWaterLevelIncrementScore() ("
+ acceptorConfig.getGreatDelugeWaterLevelIncrementScore()
+ ") and a acceptorConfig.getGreatDelugeWaterLevelIncrementRatio() ("
+ acceptorConfig.getGreatDelugeWaterLevelIncrementRatio() + ").");
}
acceptor.setWaterLevelIncrementScore(
configPolicy.getScoreDefinition().parseScore(acceptorConfig.getGreatDelugeWaterLevelIncrementScore()));
} else if (acceptorConfig.getGreatDelugeWaterLevelIncrementRatio() != null) {
if (acceptorConfig.getGreatDelugeWaterLevelIncrementRatio() <= 0.0) {
throw new IllegalArgumentException("The acceptorConfig.getGreatDelugeWaterLevelIncrementRatio() ("
+ acceptorConfig.getGreatDelugeWaterLevelIncrementRatio()
+ ") must be positive because the water level should increase.");
}
acceptor.setWaterLevelIncrementRatio(acceptorConfig.getGreatDelugeWaterLevelIncrementRatio());
} else {
acceptor.setWaterLevelIncrementRatio(DEFAULT_WATER_LEVEL_INCREMENT_RATIO);
}
return Optional.of(acceptor);
}
return Optional.empty();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/CompositeAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor;
import java.util.Arrays;
import java.util.List;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
/**
* Combines several acceptors into one.
* Does a logical AND over the accepted status of its acceptors.
* For example: combine planning entity and planning value tabu to do tabu on both.
*/
public class CompositeAcceptor<Solution_> extends AbstractAcceptor<Solution_> {
protected final List<Acceptor<Solution_>> acceptorList;
public CompositeAcceptor(List<Acceptor<Solution_>> acceptorList) {
this.acceptorList = acceptorList;
}
public CompositeAcceptor(Acceptor<Solution_>... acceptors) {
this(Arrays.asList(acceptors));
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
for (Acceptor<Solution_> acceptor : acceptorList) {
acceptor.solvingStarted(solverScope);
}
}
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
for (Acceptor<Solution_> acceptor : acceptorList) {
acceptor.phaseStarted(phaseScope);
}
}
@Override
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
for (Acceptor<Solution_> acceptor : acceptorList) {
acceptor.stepStarted(stepScope);
}
}
@Override
public boolean isAccepted(LocalSearchMoveScope<Solution_> moveScope) {
for (Acceptor<Solution_> acceptor : acceptorList) {
boolean accepted = acceptor.isAccepted(moveScope);
if (!accepted) {
return false;
}
}
return true;
}
@Override
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
for (Acceptor<Solution_> acceptor : acceptorList) {
acceptor.stepEnded(stepScope);
}
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
for (Acceptor<Solution_> acceptor : acceptorList) {
acceptor.phaseEnded(phaseScope);
}
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
for (Acceptor<Solution_> acceptor : acceptorList) {
acceptor.solvingEnded(solverScope);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/greatdeluge/GreatDelugeAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.greatdeluge;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.AbstractAcceptor;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
public class GreatDelugeAcceptor<Solution_> extends AbstractAcceptor<Solution_> {
// Guaranteed inside local search, therefore no need for InnerScore.
private Score initialWaterLevel;
private Score waterLevelIncrementScore;
private Double waterLevelIncrementRatio;
private Score startingWaterLevel = null;
private Score currentWaterLevel = null;
private Double currentWaterLevelRatio = null;
public Score getWaterLevelIncrementScore() {
return this.waterLevelIncrementScore;
}
public void setWaterLevelIncrementScore(Score waterLevelIncrementScore) {
this.waterLevelIncrementScore = waterLevelIncrementScore;
}
public Score getInitialWaterLevel() {
return this.initialWaterLevel;
}
public void setInitialWaterLevel(Score initialLevel) {
this.initialWaterLevel = initialLevel;
}
public Double getWaterLevelIncrementRatio() {
return this.waterLevelIncrementRatio;
}
public void setWaterLevelIncrementRatio(Double waterLevelIncrementRatio) {
this.waterLevelIncrementRatio = waterLevelIncrementRatio;
}
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
startingWaterLevel = initialWaterLevel != null ? initialWaterLevel : phaseScope.getBestScore().raw();
if (waterLevelIncrementRatio != null) {
currentWaterLevelRatio = 0.0;
}
currentWaterLevel = startingWaterLevel;
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
startingWaterLevel = null;
if (waterLevelIncrementRatio != null) {
currentWaterLevelRatio = null;
}
currentWaterLevel = null;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public boolean isAccepted(LocalSearchMoveScope moveScope) {
var moveScore = moveScope.getScore().raw();
if (moveScore.compareTo(currentWaterLevel) >= 0) {
return true;
}
var lastStepScore = moveScope.getStepScope().getPhaseScope().getLastCompletedStepScope().getScore().raw();
return moveScore.compareTo(lastStepScore) > 0; // Aspiration
}
@Override
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
super.stepEnded(stepScope);
if (waterLevelIncrementScore != null) {
currentWaterLevel = currentWaterLevel.add(waterLevelIncrementScore);
} else {
// Avoid numerical instability: SimpleScore.of(500).multiply(0.000_001) underflows to zero
currentWaterLevelRatio += waterLevelIncrementRatio;
currentWaterLevel = startingWaterLevel.add(
// TODO targetWaterLevel.subtract(startingWaterLevel).multiply(waterLevelIncrementRatio);
// Use startingWaterLevel.abs() to keep the number being positive.
startingWaterLevel.abs().multiply(currentWaterLevelRatio));
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/hillclimbing/HillClimbingAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.hillclimbing;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.AbstractAcceptor;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.score.director.InnerScore;
public class HillClimbingAcceptor<Solution_> extends AbstractAcceptor<Solution_> {
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public boolean isAccepted(LocalSearchMoveScope<Solution_> moveScope) {
InnerScore moveScore = moveScope.getScore();
InnerScore lastStepScore = moveScope.getStepScope().getPhaseScope().getLastCompletedStepScope().getScore();
return moveScore.compareTo(lastStepScore) >= 0;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/lateacceptance/DiversifiedLateAcceptanceAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.lateacceptance;
import java.util.Arrays;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.AbstractAcceptor;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.score.director.InnerScore;
public class DiversifiedLateAcceptanceAcceptor<Solution_> extends AbstractAcceptor<Solution_> {
// The worst score in the late elements list
protected InnerScore<?> lateWorseScore;
// Number of occurrences of lateWorse in the late elements
protected int lateWorseOccurrences = -1;
protected int lateAcceptanceSize = -1;
protected InnerScore<?>[] previousScores;
protected int lateScoreIndex = -1;
public void setLateAcceptanceSize(int lateAcceptanceSize) {
this.lateAcceptanceSize = lateAcceptanceSize;
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
validate();
previousScores = new InnerScore[lateAcceptanceSize];
var initialScore = phaseScope.getBestScore();
Arrays.fill(previousScores, initialScore);
lateScoreIndex = 0;
lateWorseOccurrences = lateAcceptanceSize;
lateWorseScore = initialScore;
}
private void validate() {
if (lateAcceptanceSize <= 0) {
throw new IllegalArgumentException(
"The lateAcceptanceSize (%d) cannot be negative or zero.".formatted(lateAcceptanceSize));
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public boolean isAccepted(LocalSearchMoveScope<Solution_> moveScope) {
// The acceptance and replacement strategies are based on the work:
// Diversified Late Acceptance Search by M. Namazi, C. Sanderson, M. A. H. Newton, M. M. A. Polash, and A. Sattar
var moveScore = moveScope.getScore();
var current = (InnerScore) moveScope.getStepScope().getPhaseScope()
.getLastCompletedStepScope().getScore();
var previous = current;
var accept = moveScore.compareTo(current) == 0 || moveScore.compareTo(getLateWorseScore()) > 0;
if (accept) {
current = moveScore;
}
var lateScore = getPreviousScore(lateScoreIndex);
// Improves the diversification to allow the next iterations to find a better solution
var currentScoreCmp = current.compareTo(lateScore);
var currentScoreWorse = currentScoreCmp < 0;
// Improves the intensification but avoids replacing values when the search falls into a plateau or local minima
var currentScoreBetter = currentScoreCmp > 0 && current.compareTo(previous) > 0;
if (currentScoreWorse || currentScoreBetter) {
updateLateScore(current);
}
lateScoreIndex = (lateScoreIndex + 1) % lateAcceptanceSize;
return accept;
}
private <Score_ extends Score<Score_>> void updateLateScore(InnerScore<Score_> newScore) {
var castLateWorse = this.<Score_> getLateWorseScore();
var newScoreWorseCmp = newScore.compareTo(castLateWorse);
var lateScore = this.<Score_> getPreviousScore(lateScoreIndex);
var lateScoreEqual = lateScore.compareTo(castLateWorse) == 0;
if (newScoreWorseCmp < 0) {
castLateWorse = newScore;
this.lateWorseOccurrences = 1;
} else if (lateScoreEqual && newScoreWorseCmp != 0) {
this.lateWorseOccurrences--;
} else if (!lateScoreEqual && newScoreWorseCmp == 0) {
this.lateWorseOccurrences++;
}
previousScores[lateScoreIndex] = newScore;
// Recompute the new lateWorse and the number of occurrences
if (lateWorseOccurrences == 0) {
castLateWorse = getPreviousScore(0);
lateWorseOccurrences = 1;
for (var i = 1; i < lateAcceptanceSize; i++) {
var previousScore = this.<Score_> getPreviousScore(i);
var scoreCmp = previousScore.compareTo(castLateWorse);
if (scoreCmp < 0) {
castLateWorse = previousScore;
lateWorseOccurrences = 1;
} else if (scoreCmp == 0) {
lateWorseOccurrences++;
}
}
}
lateWorseScore = castLateWorse;
}
@SuppressWarnings("unchecked")
private <Score_ extends Score<Score_>> InnerScore<Score_> getLateWorseScore() {
return (InnerScore<Score_>) lateWorseScore;
}
@SuppressWarnings("unchecked")
private <Score_ extends Score<Score_>> InnerScore<Score_> getPreviousScore(int lateScoreIndex) {
return (InnerScore<Score_>) previousScores[lateScoreIndex];
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
previousScores = null;
lateScoreIndex = -1;
lateWorseScore = null;
lateWorseOccurrences = -1;
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/lateacceptance/LateAcceptanceAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.lateacceptance;
import java.util.Arrays;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.AbstractAcceptor;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
import ai.timefold.solver.core.impl.score.director.InnerScore;
public class LateAcceptanceAcceptor<Solution_> extends AbstractAcceptor<Solution_> {
protected int lateAcceptanceSize = -1;
protected boolean hillClimbingEnabled = true;
protected InnerScore<?>[] previousScores;
protected int lateScoreIndex = -1;
public void setLateAcceptanceSize(int lateAcceptanceSize) {
this.lateAcceptanceSize = lateAcceptanceSize;
}
public void setHillClimbingEnabled(boolean hillClimbingEnabled) {
this.hillClimbingEnabled = hillClimbingEnabled;
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
validate();
previousScores = new InnerScore[lateAcceptanceSize];
var initialScore = phaseScope.getBestScore();
Arrays.fill(previousScores, initialScore);
lateScoreIndex = 0;
}
private void validate() {
if (lateAcceptanceSize <= 0) {
throw new IllegalArgumentException(
"The lateAcceptanceSize (%d) cannot be negative or zero.".formatted(lateAcceptanceSize));
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public boolean isAccepted(LocalSearchMoveScope<Solution_> moveScope) {
var moveScore = (InnerScore) moveScope.getScore();
var lateScore = getPreviousScore(lateScoreIndex);
if (moveScore.compareTo(lateScore) >= 0) {
return true;
}
if (hillClimbingEnabled) {
var lastStepScore = moveScope.getStepScope().getPhaseScope()
.getLastCompletedStepScope().getScore();
return moveScore.compareTo(lastStepScore) >= 0;
}
return false;
}
@SuppressWarnings("unchecked")
private <Score_ extends Score<Score_>> InnerScore<Score_> getPreviousScore(int lateScoreIndex) {
return (InnerScore<Score_>) previousScores[lateScoreIndex];
}
@Override
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
super.stepEnded(stepScope);
previousScores[lateScoreIndex] = stepScope.getScore();
lateScoreIndex = (lateScoreIndex + 1) % lateAcceptanceSize;
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
previousScores = null;
lateScoreIndex = -1;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/simulatedannealing/SimulatedAnnealingAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.simulatedannealing;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.AbstractAcceptor;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
/**
* The time gradient implementation of simulated annealing.
*/
public class SimulatedAnnealingAcceptor<Solution_> extends AbstractAcceptor<Solution_> {
protected Score startingTemperature;
protected int levelsLength = -1;
protected double[] startingTemperatureLevels;
// No protected Score temperature do avoid rounding errors when using Score.multiply(double)
protected double[] temperatureLevels;
protected double temperatureMinimum = 1.0E-100; // Double.MIN_NORMAL is E-308
public void setStartingTemperature(Score startingTemperature) {
this.startingTemperature = startingTemperature;
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
for (var startingTemperatureLevel : startingTemperature.toLevelDoubles()) {
if (startingTemperatureLevel < 0.0) {
throw new IllegalArgumentException("The startingTemperature (" + startingTemperature
+ ") cannot have negative level (" + startingTemperatureLevel + ").");
}
}
startingTemperatureLevels = startingTemperature.toLevelDoubles();
temperatureLevels = startingTemperatureLevels;
levelsLength = startingTemperatureLevels.length;
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
startingTemperatureLevels = null;
temperatureLevels = null;
levelsLength = -1;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public boolean isAccepted(LocalSearchMoveScope<Solution_> moveScope) {
var phaseScope = moveScope.getStepScope().getPhaseScope();
// Guaranteed local search; no need for InnerScore.
Score lastStepScore = phaseScope.getLastCompletedStepScope().getScore().raw();
Score moveScore = moveScope.getScore().raw();
if (moveScore.compareTo(lastStepScore) >= 0) {
return true;
}
var moveScoreDifference = lastStepScore.subtract(moveScore);
var moveScoreDifferenceLevels = moveScoreDifference.toLevelDoubles();
var acceptChance = 1.0;
for (var i = 0; i < levelsLength; i++) {
var moveScoreDifferenceLevel = moveScoreDifferenceLevels[i];
var temperatureLevel = temperatureLevels[i];
double acceptChanceLevel;
if (moveScoreDifferenceLevel <= 0.0) {
// In this level, moveScore is better than the lastStepScore, so do not disrupt the acceptChance
acceptChanceLevel = 1.0;
} else {
acceptChanceLevel = Math.exp(-moveScoreDifferenceLevel / temperatureLevel);
}
acceptChance *= acceptChanceLevel;
}
return moveScope.getWorkingRandom().nextDouble() < acceptChance;
}
@Override
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
super.stepStarted(stepScope);
// TimeGradient only refreshes at the beginning of a step, so this code is in stepStarted instead of stepEnded
var timeGradient = stepScope.getTimeGradient();
var reverseTimeGradient = 1.0 - timeGradient;
temperatureLevels = new double[levelsLength];
for (var i = 0; i < levelsLength; i++) {
temperatureLevels[i] = startingTemperatureLevels[i] * reverseTimeGradient;
if (temperatureLevels[i] < temperatureMinimum) {
temperatureLevels[i] = temperatureMinimum;
}
}
// TODO implement reheating
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/stepcountinghillclimbing/StepCountingHillClimbingAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.stepcountinghillclimbing;
import ai.timefold.solver.core.config.localsearch.decider.acceptor.stepcountinghillclimbing.StepCountingHillClimbingType;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.AbstractAcceptor;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
import ai.timefold.solver.core.impl.score.director.InnerScore;
public class StepCountingHillClimbingAcceptor<Solution_> extends AbstractAcceptor<Solution_> {
protected int stepCountingHillClimbingSize = -1;
protected StepCountingHillClimbingType stepCountingHillClimbingType;
protected InnerScore<?> thresholdScore;
protected int count = -1;
public StepCountingHillClimbingAcceptor(int stepCountingHillClimbingSize,
StepCountingHillClimbingType stepCountingHillClimbingType) {
this.stepCountingHillClimbingSize = stepCountingHillClimbingSize;
this.stepCountingHillClimbingType = stepCountingHillClimbingType;
if (stepCountingHillClimbingSize <= 0) {
throw new IllegalArgumentException("The stepCountingHillClimbingSize (" + stepCountingHillClimbingSize
+ ") cannot be negative or zero.");
}
if (stepCountingHillClimbingType == null) {
throw new IllegalArgumentException("The stepCountingHillClimbingType (" + stepCountingHillClimbingType
+ ") cannot be null.");
}
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
thresholdScore = phaseScope.getBestScore();
count = 0;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public boolean isAccepted(LocalSearchMoveScope<Solution_> moveScope) {
InnerScore lastStepScore = moveScope.getStepScope().getPhaseScope().getLastCompletedStepScope().getScore();
InnerScore moveScore = moveScope.getScore();
if (moveScore.compareTo(lastStepScore) >= 0) {
return true;
}
return moveScore.compareTo(thresholdScore) >= 0;
}
@Override
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
super.stepEnded(stepScope);
count += determineCountIncrement(stepScope);
if (count >= stepCountingHillClimbingSize) {
thresholdScore = stepScope.getScore();
count = 0;
}
}
private int determineCountIncrement(LocalSearchStepScope<Solution_> stepScope) {
return switch (stepCountingHillClimbingType) {
case SELECTED_MOVE -> {
long selectedMoveCount = stepScope.getSelectedMoveCount();
yield selectedMoveCount > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) selectedMoveCount;
}
case ACCEPTED_MOVE -> {
long acceptedMoveCount = stepScope.getAcceptedMoveCount();
yield acceptedMoveCount > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) acceptedMoveCount;
}
case STEP -> 1;
case EQUAL_OR_IMPROVING_STEP ->
stepScope.getScore().compareTo(stepScope.getPhaseScope().getLastCompletedStepScope().getScore()) >= 0 ? 1 : 0;
case IMPROVING_STEP ->
stepScope.getScore().compareTo(stepScope.getPhaseScope().getLastCompletedStepScope().getScore()) > 0 ? 1 : 0;
};
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
thresholdScore = null;
count = -1;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu/AbstractTabuAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu;
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.AbstractAcceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.Acceptor;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.size.TabuSizeStrategy;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
/**
* Abstract superclass for all Tabu Acceptors.
*
* @see Acceptor
*/
public abstract class AbstractTabuAcceptor<Solution_> extends AbstractAcceptor<Solution_> {
protected final String logIndentation;
protected TabuSizeStrategy<Solution_> tabuSizeStrategy = null;
protected TabuSizeStrategy<Solution_> fadingTabuSizeStrategy = null;
protected boolean aspirationEnabled = true;
protected boolean assertTabuHashCodeCorrectness = false;
protected Map<Object, Integer> tabuToStepIndexMap;
protected Deque<Object> tabuSequenceDeque;
protected int workingTabuSize = -1;
protected int workingFadingTabuSize = -1;
public AbstractTabuAcceptor(String logIndentation) {
this.logIndentation = logIndentation;
}
public void setTabuSizeStrategy(TabuSizeStrategy<Solution_> tabuSizeStrategy) {
this.tabuSizeStrategy = tabuSizeStrategy;
}
public void setFadingTabuSizeStrategy(TabuSizeStrategy<Solution_> fadingTabuSizeStrategy) {
this.fadingTabuSizeStrategy = fadingTabuSizeStrategy;
}
public void setAspirationEnabled(boolean aspirationEnabled) {
this.aspirationEnabled = aspirationEnabled;
}
public void setAssertTabuHashCodeCorrectness(boolean assertTabuHashCodeCorrectness) {
this.assertTabuHashCodeCorrectness = assertTabuHashCodeCorrectness;
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
var lastCompletedStepScope = phaseScope.getLastCompletedStepScope();
// Tabu sizes do not change during stepStarted(), because they must be in sync with the tabuSequenceList.size()
workingTabuSize = tabuSizeStrategy == null ? 0 : tabuSizeStrategy.determineTabuSize(lastCompletedStepScope);
workingFadingTabuSize = fadingTabuSizeStrategy == null ? 0
: fadingTabuSizeStrategy.determineTabuSize(lastCompletedStepScope);
var totalTabuListSize = workingTabuSize + workingFadingTabuSize; // is at least 1
tabuToStepIndexMap = new HashMap<>(totalTabuListSize);
tabuSequenceDeque = new ArrayDeque<>();
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
tabuToStepIndexMap = null;
tabuSequenceDeque = null;
workingTabuSize = -1;
workingFadingTabuSize = -1;
}
@Override
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
super.stepEnded(stepScope);
// Tabu sizes do not change during stepStarted(), because they must be in sync with the tabuSequenceList.size()
workingTabuSize = tabuSizeStrategy == null ? 0 : tabuSizeStrategy.determineTabuSize(stepScope);
workingFadingTabuSize = fadingTabuSizeStrategy == null ? 0 : fadingTabuSizeStrategy.determineTabuSize(stepScope);
adjustTabuList(stepScope.getStepIndex(), findNewTabu(stepScope));
}
protected void adjustTabuList(int tabuStepIndex, Collection<? extends Object> tabus) {
var totalTabuListSize = workingTabuSize + workingFadingTabuSize; // is at least 1
// Remove the oldest tabu(s)
for (var it = tabuSequenceDeque.iterator(); it.hasNext();) {
var oldTabu = it.next();
var oldTabuStepIndexInteger = tabuToStepIndexMap.get(oldTabu);
if (oldTabuStepIndexInteger == null) {
throw new IllegalStateException("HashCode stability violation: the hashCode() of tabu ("
+ oldTabu + ") of class (" + oldTabu.getClass()
+ ") changed during planning, since it was inserted in the tabu Map or Set.");
}
var oldTabuStepCount = tabuStepIndex - oldTabuStepIndexInteger; // at least 1
if (oldTabuStepCount < totalTabuListSize) {
break;
}
it.remove();
tabuToStepIndexMap.remove(oldTabu);
}
// Add the new tabu(s)
for (var tabu : tabus) {
// Push tabu to the end of the line
if (tabuToStepIndexMap.containsKey(tabu)) {
tabuToStepIndexMap.remove(tabu);
tabuSequenceDeque.remove(tabu);
}
tabuToStepIndexMap.put(tabu, tabuStepIndex);
tabuSequenceDeque.add(tabu);
}
}
@Override
public boolean isAccepted(LocalSearchMoveScope<Solution_> moveScope) {
var maximumTabuStepIndex = locateMaximumTabuStepIndex(moveScope);
if (maximumTabuStepIndex < 0) {
// The move isn't tabu at all
return true;
}
// Natural comparison because shifting penalties don't apply
if (aspirationEnabled &&
moveScope.getScore().compareTo(moveScope.getStepScope().getPhaseScope().getBestScore()) > 0) {
logger.trace("{} Proposed move ({}) is tabu, but is accepted anyway due to aspiration.",
logIndentation, moveScope.getMove());
return true;
}
var tabuStepCount = moveScope.getStepScope().getStepIndex() - maximumTabuStepIndex; // at least 1
if (tabuStepCount <= workingTabuSize) {
logger.trace("{} Proposed move ({}) is tabu and is therefore not accepted.",
logIndentation, moveScope.getMove());
return false;
}
var acceptChance = calculateFadingTabuAcceptChance(tabuStepCount - workingTabuSize);
var accepted = moveScope.getWorkingRandom().nextDouble() < acceptChance;
if (accepted) {
logger.trace("{} Proposed move ({}) is fading tabu with acceptChance ({}) and is accepted.",
logIndentation,
moveScope.getMove(), acceptChance);
} else {
logger.trace("{} Proposed move ({}) is fading tabu with acceptChance ({}) and is not accepted.",
logIndentation,
moveScope.getMove(), acceptChance);
}
return accepted;
}
private int locateMaximumTabuStepIndex(LocalSearchMoveScope<Solution_> moveScope) {
var checkingTabus = findTabu(moveScope);
var maximumTabuStepIndex = -1;
for (var checkingTabu : checkingTabus) {
var tabuStepIndexInteger = tabuToStepIndexMap.get(checkingTabu);
if (tabuStepIndexInteger != null) {
maximumTabuStepIndex = Math.max(tabuStepIndexInteger, maximumTabuStepIndex);
}
if (assertTabuHashCodeCorrectness) {
for (var tabu : tabuSequenceDeque) {
// tabu and checkingTabu can be null with a planning variable which allows unassigned values
if (tabu != null && tabu.equals(checkingTabu)) {
if (tabu.hashCode() != checkingTabu.hashCode()) {
throw new IllegalStateException("HashCode/equals contract violation: tabu (" + tabu
+ ") of class (" + tabu.getClass()
+ ") and checkingTabu (" + checkingTabu
+ ") are equals() but have a different hashCode().");
}
if (tabuStepIndexInteger == null) {
throw new IllegalStateException("HashCode stability violation: the hashCode() of tabu ("
+ tabu + ") of class (" + tabu.getClass()
+ ") changed during planning, since it was inserted in the tabu Map or Set.");
}
}
}
}
}
return maximumTabuStepIndex;
}
/**
* @param fadingTabuStepCount {@code 0 < fadingTabuStepCount <= fadingTabuSize}
* @return {@code 0.0 < acceptChance < 1.0}
*/
protected double calculateFadingTabuAcceptChance(int fadingTabuStepCount) {
// The + 1's are because acceptChance should not be 0.0 or 1.0
// when (fadingTabuStepCount == 0) or (fadingTabuStepCount + 1 == workingFadingTabuSize)
return (workingFadingTabuSize - fadingTabuStepCount) / ((double) (workingFadingTabuSize + 1));
}
protected abstract Collection<? extends Object> findTabu(LocalSearchMoveScope<Solution_> moveScope);
protected abstract Collection<? extends Object> findNewTabu(LocalSearchStepScope<Solution_> stepScope);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu/EntityTabuAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu;
import java.util.Collection;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
public class EntityTabuAcceptor<Solution_> extends AbstractTabuAcceptor<Solution_> {
public EntityTabuAcceptor(String logIndentation) {
super(logIndentation);
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
protected Collection<? extends Object> findTabu(LocalSearchMoveScope<Solution_> moveScope) {
return moveScope.getMove().extractPlanningEntities();
}
@Override
protected Collection<? extends Object> findNewTabu(LocalSearchStepScope<Solution_> stepScope) {
return stepScope.getStep().extractPlanningEntities();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu/MoveTabuAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu;
import java.util.Collection;
import java.util.Collections;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
public class MoveTabuAcceptor<Solution_> extends AbstractTabuAcceptor<Solution_> {
public MoveTabuAcceptor(String logIndentation) {
super(logIndentation);
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
protected Collection<Object> findTabu(LocalSearchMoveScope<Solution_> moveScope) {
return Collections.singletonList(moveScope.getMove());
}
@Override
protected Collection<Object> findNewTabu(LocalSearchStepScope<Solution_> stepScope) {
return Collections.singletonList(stepScope.getStep());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu/ValueTabuAcceptor.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu;
import java.util.Collection;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
public class ValueTabuAcceptor<Solution_> extends AbstractTabuAcceptor<Solution_> {
public ValueTabuAcceptor(String logIndentation) {
super(logIndentation);
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
protected Collection<? extends Object> findTabu(LocalSearchMoveScope<Solution_> moveScope) {
return moveScope.getMove().extractPlanningValues();
}
@Override
protected Collection<? extends Object> findNewTabu(LocalSearchStepScope<Solution_> stepScope) {
return stepScope.getStep().extractPlanningValues();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu/size/AbstractTabuSizeStrategy.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.size;
public sealed abstract class AbstractTabuSizeStrategy<Solution_>
implements TabuSizeStrategy<Solution_>
permits EntityRatioTabuSizeStrategy, FixedTabuSizeStrategy {
protected int protectTabuSizeCornerCases(int totalSize, int tabuSize) {
if (tabuSize < 1) {
// At least one object should be tabu, even if totalSize is 0
tabuSize = 1;
} else if (tabuSize > totalSize - 1) {
// At least one object should not be tabu
tabuSize = totalSize - 1;
}
return tabuSize;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu/size/EntityRatioTabuSizeStrategy.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.size;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
public final class EntityRatioTabuSizeStrategy<Solution_> extends AbstractTabuSizeStrategy<Solution_> {
private final double tabuRatio;
public EntityRatioTabuSizeStrategy(double tabuRatio) {
this.tabuRatio = tabuRatio;
if (tabuRatio <= 0.0 || tabuRatio >= 1.0) {
throw new IllegalArgumentException("The tabuRatio (" + tabuRatio
+ ") must be between 0.0 and 1.0.");
}
}
@Override
public int determineTabuSize(LocalSearchStepScope<Solution_> stepScope) {
// TODO we might want to cache the entityCount if and only if moves don't add/remove entities
int entityCount = stepScope.getPhaseScope().getWorkingEntityCount();
int tabuSize = (int) Math.round(entityCount * tabuRatio);
return protectTabuSizeCornerCases(entityCount, tabuSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu/size/FixedTabuSizeStrategy.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.size;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
public final class FixedTabuSizeStrategy<Solution_> extends AbstractTabuSizeStrategy<Solution_> {
private final int tabuSize;
public FixedTabuSizeStrategy(int tabuSize) {
this.tabuSize = tabuSize;
if (tabuSize < 0) {
throw new IllegalArgumentException("The tabuSize (" + tabuSize
+ ") cannot be negative.");
}
}
@Override
public int determineTabuSize(LocalSearchStepScope<Solution_> stepScope) {
return tabuSize;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/acceptor/tabu/size/TabuSizeStrategy.java | package ai.timefold.solver.core.impl.localsearch.decider.acceptor.tabu.size;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
public sealed interface TabuSizeStrategy<Solution_> permits AbstractTabuSizeStrategy {
/**
* @param stepScope never null
* @return {@code >= 0}
*/
int determineTabuSize(LocalSearchStepScope<Solution_> stepScope);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager/AbstractLocalSearchForager.java | package ai.timefold.solver.core.impl.localsearch.decider.forager;
import ai.timefold.solver.core.impl.localsearch.event.LocalSearchPhaseLifecycleListenerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Abstract superclass for {@link LocalSearchForager}.
*
* @see LocalSearchForager
*/
public abstract class AbstractLocalSearchForager<Solution_> extends LocalSearchPhaseLifecycleListenerAdapter<Solution_>
implements LocalSearchForager<Solution_> {
protected final transient Logger logger = LoggerFactory.getLogger(getClass());
// ************************************************************************
// Worker methods
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager/AcceptedLocalSearchForager.java | package ai.timefold.solver.core.impl.localsearch.decider.forager;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.config.localsearch.decider.forager.LocalSearchPickEarlyType;
import ai.timefold.solver.core.impl.localsearch.decider.acceptor.Acceptor;
import ai.timefold.solver.core.impl.localsearch.decider.forager.finalist.FinalistPodium;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
/**
* A {@link LocalSearchForager} which forages accepted moves and ignores unaccepted moves.
*
* @see LocalSearchForager
* @see Acceptor
*/
public final class AcceptedLocalSearchForager<Solution_> extends AbstractLocalSearchForager<Solution_> {
private final FinalistPodium<Solution_> finalistPodium;
private final LocalSearchPickEarlyType pickEarlyType;
private final int acceptedCountLimit;
private final boolean breakTieRandomly;
private long selectedMoveCount;
private long acceptedMoveCount;
private LocalSearchMoveScope<Solution_> earlyPickedMoveScope;
public AcceptedLocalSearchForager(FinalistPodium<Solution_> finalistPodium,
LocalSearchPickEarlyType pickEarlyType, int acceptedCountLimit, boolean breakTieRandomly) {
this.finalistPodium = finalistPodium;
this.pickEarlyType = pickEarlyType;
this.acceptedCountLimit = acceptedCountLimit;
if (acceptedCountLimit < 1) {
throw new IllegalArgumentException("The acceptedCountLimit (" + acceptedCountLimit
+ ") cannot be negative or zero.");
}
this.breakTieRandomly = breakTieRandomly;
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
super.solvingStarted(solverScope);
finalistPodium.solvingStarted(solverScope);
}
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
finalistPodium.phaseStarted(phaseScope);
}
@Override
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
super.stepStarted(stepScope);
finalistPodium.stepStarted(stepScope);
selectedMoveCount = 0L;
acceptedMoveCount = 0L;
earlyPickedMoveScope = null;
}
@Override
public boolean supportsNeverEndingMoveSelector() {
// TODO FIXME magical value Integer.MAX_VALUE coming from ForagerConfig
return acceptedCountLimit < Integer.MAX_VALUE;
}
@Override
public void addMove(LocalSearchMoveScope<Solution_> moveScope) {
selectedMoveCount++;
moveScope.getStepScope().getPhaseScope().addMoveEvaluationCount(moveScope.getMove(), 1);
if (moveScope.getAccepted()) {
acceptedMoveCount++;
checkPickEarly(moveScope);
}
finalistPodium.addMove(moveScope);
}
private <Score_ extends Score<Score_>> void checkPickEarly(LocalSearchMoveScope<Solution_> moveScope) {
switch (pickEarlyType) {
case NEVER:
break;
case FIRST_BEST_SCORE_IMPROVING:
var bestScore = moveScope.getStepScope().getPhaseScope().<Score_> getBestScore();
if (moveScope.<Score_> getScore().compareTo(bestScore) > 0) {
earlyPickedMoveScope = moveScope;
}
break;
case FIRST_LAST_STEP_SCORE_IMPROVING:
var lastStepScore = moveScope.getStepScope().getPhaseScope()
.getLastCompletedStepScope().<Score_> getScore();
if (moveScope.<Score_> getScore().compareTo(lastStepScore) > 0) {
earlyPickedMoveScope = moveScope;
}
break;
default:
throw new IllegalStateException("The pickEarlyType (" + pickEarlyType + ") is not implemented.");
}
}
@Override
public boolean isQuitEarly() {
return earlyPickedMoveScope != null || acceptedMoveCount >= acceptedCountLimit;
}
@Override
public LocalSearchMoveScope<Solution_> pickMove(LocalSearchStepScope<Solution_> stepScope) {
stepScope.setSelectedMoveCount(selectedMoveCount);
stepScope.setAcceptedMoveCount(acceptedMoveCount);
if (earlyPickedMoveScope != null) {
return earlyPickedMoveScope;
}
var finalistList = finalistPodium.getFinalistList();
if (finalistList.isEmpty()) {
return null;
}
if (finalistList.size() == 1 || !breakTieRandomly) {
return finalistList.get(0);
}
int randomIndex = stepScope.getWorkingRandom().nextInt(finalistList.size());
return finalistList.get(randomIndex);
}
@Override
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
super.stepEnded(stepScope);
finalistPodium.stepEnded(stepScope);
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
finalistPodium.phaseEnded(phaseScope);
selectedMoveCount = 0L;
acceptedMoveCount = 0L;
earlyPickedMoveScope = null;
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
super.solvingEnded(solverScope);
finalistPodium.solvingEnded(solverScope);
}
@Override
public String toString() {
return getClass().getSimpleName() + "(" + pickEarlyType + ", " + acceptedCountLimit + ")";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager/LocalSearchForager.java | package ai.timefold.solver.core.impl.localsearch.decider.forager;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
import ai.timefold.solver.core.impl.localsearch.decider.LocalSearchDecider;
import ai.timefold.solver.core.impl.localsearch.event.LocalSearchPhaseLifecycleListener;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
/**
* Collects the moves and picks the next step from those for the {@link LocalSearchDecider}.
*
* @see AbstractLocalSearchForager
*/
public interface LocalSearchForager<Solution_> extends LocalSearchPhaseLifecycleListener<Solution_> {
/**
* @return true if it can be combined with a {@link MoveSelector#isNeverEnding()} that returns true.
*/
boolean supportsNeverEndingMoveSelector();
/**
* @param moveScope never null
*/
void addMove(LocalSearchMoveScope<Solution_> moveScope);
/**
* @return true if no further moves should be selected (and evaluated) for this step.
*/
boolean isQuitEarly();
/**
* @param stepScope never null
* @return sometimes null, for example if no move is selected
*/
LocalSearchMoveScope<Solution_> pickMove(LocalSearchStepScope<Solution_> stepScope);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager/LocalSearchForagerFactory.java | package ai.timefold.solver.core.impl.localsearch.decider.forager;
import java.util.Objects;
import ai.timefold.solver.core.config.localsearch.decider.forager.FinalistPodiumType;
import ai.timefold.solver.core.config.localsearch.decider.forager.LocalSearchForagerConfig;
import ai.timefold.solver.core.config.localsearch.decider.forager.LocalSearchPickEarlyType;
public class LocalSearchForagerFactory<Solution_> {
public static <Solution_> LocalSearchForagerFactory<Solution_> create(LocalSearchForagerConfig foragerConfig) {
return new LocalSearchForagerFactory<>(foragerConfig);
}
private final LocalSearchForagerConfig foragerConfig;
public LocalSearchForagerFactory(LocalSearchForagerConfig foragerConfig) {
this.foragerConfig = foragerConfig;
}
public LocalSearchForager<Solution_> buildForager() {
var pickEarlyType_ = Objects.requireNonNullElse(foragerConfig.getPickEarlyType(), LocalSearchPickEarlyType.NEVER);
var acceptedCountLimit_ = Objects.requireNonNullElse(foragerConfig.getAcceptedCountLimit(), Integer.MAX_VALUE);
var finalistPodiumType_ =
Objects.requireNonNullElse(foragerConfig.getFinalistPodiumType(), FinalistPodiumType.HIGHEST_SCORE);
// Breaking ties randomly leads to better results statistically
boolean breakTieRandomly_ = Objects.requireNonNullElse(foragerConfig.getBreakTieRandomly(), true);
return new AcceptedLocalSearchForager<>(finalistPodiumType_.buildFinalistPodium(), pickEarlyType_,
acceptedCountLimit_, breakTieRandomly_);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager/finalist/AbstractFinalistPodium.java | package ai.timefold.solver.core.impl.localsearch.decider.forager.finalist;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.impl.localsearch.event.LocalSearchPhaseLifecycleListenerAdapter;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
/**
* Abstract superclass for {@link FinalistPodium}.
*
* @see FinalistPodium
*/
public abstract class AbstractFinalistPodium<Solution_> extends LocalSearchPhaseLifecycleListenerAdapter<Solution_>
implements FinalistPodium<Solution_> {
protected static final int FINALIST_LIST_MAX_SIZE = 1_024_000;
protected boolean finalistIsAccepted;
protected List<LocalSearchMoveScope<Solution_>> finalistList = new ArrayList<>(1024);
@Override
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
super.stepStarted(stepScope);
finalistIsAccepted = false;
finalistList.clear();
}
protected void clearAndAddFinalist(LocalSearchMoveScope<Solution_> moveScope) {
finalistList.clear();
finalistList.add(moveScope);
}
protected void addFinalist(LocalSearchMoveScope<Solution_> moveScope) {
if (finalistList.size() >= FINALIST_LIST_MAX_SIZE) {
// Avoid unbounded growth and OutOfMemoryException
return;
}
finalistList.add(moveScope);
}
@Override
public List<LocalSearchMoveScope<Solution_>> getFinalistList() {
return finalistList;
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
finalistIsAccepted = false;
finalistList.clear();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager/finalist/FinalistPodium.java | package ai.timefold.solver.core.impl.localsearch.decider.forager.finalist;
import java.util.List;
import ai.timefold.solver.core.impl.localsearch.decider.forager.LocalSearchForager;
import ai.timefold.solver.core.impl.localsearch.event.LocalSearchPhaseLifecycleListener;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
/**
* A podium gathers the finalists (the {@link LocalSearchMoveScope}s which might win) and picks the winner.
*
* @see AbstractFinalistPodium
* @see HighestScoreFinalistPodium
*/
public interface FinalistPodium<Solution_> extends LocalSearchPhaseLifecycleListener<Solution_> {
/**
* See {@link LocalSearchForager#addMove(LocalSearchMoveScope)}.
*
* @param moveScope never null
*/
void addMove(LocalSearchMoveScope<Solution_> moveScope);
/**
*
* @return never null, sometimes empty
*/
List<LocalSearchMoveScope<Solution_>> getFinalistList();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager/finalist/HighestScoreFinalistPodium.java | package ai.timefold.solver.core.impl.localsearch.decider.forager.finalist;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
/**
* Default implementation of {@link FinalistPodium}.
*
* @see FinalistPodium
*/
public final class HighestScoreFinalistPodium<Solution_> extends AbstractFinalistPodium<Solution_> {
private Score<?> finalistScore;
@Override
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
super.stepStarted(stepScope);
finalistScore = null;
}
@Override
public void addMove(LocalSearchMoveScope<Solution_> moveScope) {
var accepted = moveScope.getAccepted() != null && moveScope.getAccepted();
if (finalistIsAccepted && !accepted) {
return;
}
if (accepted && !finalistIsAccepted) {
finalistIsAccepted = true;
finalistScore = null;
}
var moveScore = moveScope.getScore().raw(); // Guaranteed local search; no need for InnerScore.
var scoreComparison = doComparison(moveScore);
if (scoreComparison > 0) {
finalistScore = moveScore;
clearAndAddFinalist(moveScope);
} else if (scoreComparison == 0) {
addFinalist(moveScope);
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private int doComparison(Score moveScore) {
if (finalistScore == null) {
return 1;
}
return moveScore.compareTo(finalistScore);
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
finalistScore = null;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/decider/forager/finalist/StrategicOscillationByLevelFinalistPodium.java | package ai.timefold.solver.core.impl.localsearch.decider.forager.finalist;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchMoveScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
/**
* Strategic oscillation, works well with Tabu search.
*
* @see FinalistPodium
*/
public final class StrategicOscillationByLevelFinalistPodium<Solution_> extends AbstractFinalistPodium<Solution_> {
private final boolean referenceBestScoreInsteadOfLastStepScore;
// Guaranteed inside local search, therefore no need for InnerScore.
private Score<?> referenceScore;
private Number[] referenceLevelNumbers;
private Score<?> finalistScore;
private Number[] finalistLevelNumbers;
private boolean finalistImprovesUponReference;
public StrategicOscillationByLevelFinalistPodium(boolean referenceBestScoreInsteadOfLastStepScore) {
this.referenceBestScoreInsteadOfLastStepScore = referenceBestScoreInsteadOfLastStepScore;
}
@Override
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
super.stepStarted(stepScope);
referenceScore = referenceBestScoreInsteadOfLastStepScore
? stepScope.getPhaseScope().getBestScore().raw()
: stepScope.getPhaseScope().getLastCompletedStepScope().getScore().raw();
referenceLevelNumbers = referenceScore.toLevelNumbers();
finalistScore = null;
finalistLevelNumbers = null;
finalistImprovesUponReference = false;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void addMove(LocalSearchMoveScope<Solution_> moveScope) {
boolean accepted = moveScope.getAccepted();
if (finalistIsAccepted && !accepted) {
return;
}
if (accepted && !finalistIsAccepted) {
finalistIsAccepted = true;
finalistScore = null;
finalistLevelNumbers = null;
}
Score moveScore = moveScope.getScore().raw();
var moveLevelNumbers = moveScore.toLevelNumbers();
var comparison = doComparison(moveScore, moveLevelNumbers);
if (comparison > 0) {
finalistScore = moveScore;
finalistLevelNumbers = moveLevelNumbers;
finalistImprovesUponReference = (moveScore.compareTo(referenceScore) > 0);
clearAndAddFinalist(moveScope);
} else if (comparison == 0) {
addFinalist(moveScope);
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private int doComparison(Score moveScore, Number[] moveLevelNumbers) {
if (finalistScore == null) {
return 1;
}
// If there is an improving move, do not oscillate
if (!finalistImprovesUponReference && moveScore.compareTo(referenceScore) < 0) {
for (var i = 0; i < referenceLevelNumbers.length; i++) {
var moveIsHigher = ((Comparable) moveLevelNumbers[i]).compareTo(referenceLevelNumbers[i]) > 0;
var finalistIsHigher = ((Comparable) finalistLevelNumbers[i]).compareTo(referenceLevelNumbers[i]) > 0;
if (moveIsHigher) {
if (finalistIsHigher) {
// Both are higher, take the best one but do not ignore higher levels
break;
} else {
// The move has the first level which is higher while the finalist is lower than the reference
return 1;
}
} else {
if (finalistIsHigher) {
// The finalist has the first level which is higher while the move is lower than the reference
return -1;
} else {
// Both are lower, ignore this level
}
}
}
}
return moveScore.compareTo(finalistScore);
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
referenceScore = null;
referenceLevelNumbers = null;
finalistScore = null;
finalistLevelNumbers = null;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/event/LocalSearchPhaseLifecycleListener.java | package ai.timefold.solver.core.impl.localsearch.event;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
import ai.timefold.solver.core.impl.solver.event.SolverLifecycleListener;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @see LocalSearchPhaseLifecycleListenerAdapter
*/
public interface LocalSearchPhaseLifecycleListener<Solution_> extends SolverLifecycleListener<Solution_> {
void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope);
void stepStarted(LocalSearchStepScope<Solution_> stepScope);
void stepEnded(LocalSearchStepScope<Solution_> stepScope);
void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/event/LocalSearchPhaseLifecycleListenerAdapter.java | package ai.timefold.solver.core.impl.localsearch.event;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchPhaseScope;
import ai.timefold.solver.core.impl.localsearch.scope.LocalSearchStepScope;
import ai.timefold.solver.core.impl.solver.event.SolverLifecycleListenerAdapter;
/**
* An adapter for {@link LocalSearchPhaseLifecycleListener}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public abstract class LocalSearchPhaseLifecycleListenerAdapter<Solution_> extends SolverLifecycleListenerAdapter<Solution_>
implements LocalSearchPhaseLifecycleListener<Solution_> {
@Override
public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
// Hook method
}
@Override
public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
// Hook method
}
@Override
public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
// Hook method
}
@Override
public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
// Hook method
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/scope/LocalSearchMoveScope.java | package ai.timefold.solver.core.impl.localsearch.scope;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.phase.scope.AbstractMoveScope;
import ai.timefold.solver.core.preview.api.move.Move;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public final class LocalSearchMoveScope<Solution_> extends AbstractMoveScope<Solution_> {
private Boolean accepted = null;
public LocalSearchMoveScope(LocalSearchStepScope<Solution_> stepScope, int moveIndex, Move<Solution_> move) {
super(stepScope, moveIndex, move);
}
@Override
public LocalSearchStepScope<Solution_> getStepScope() {
return (LocalSearchStepScope<Solution_>) super.getStepScope();
}
public Boolean getAccepted() {
return accepted;
}
public void setAccepted(Boolean accepted) {
this.accepted = accepted;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/scope/LocalSearchPhaseScope.java | package ai.timefold.solver.core.impl.localsearch.scope;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public final class LocalSearchPhaseScope<Solution_> extends AbstractPhaseScope<Solution_> {
private LocalSearchStepScope<Solution_> lastCompletedStepScope;
public LocalSearchPhaseScope(SolverScope<Solution_> solverScope, int phaseIndex) {
super(solverScope, phaseIndex);
lastCompletedStepScope = new LocalSearchStepScope<>(this, -1);
lastCompletedStepScope.setTimeGradient(0.0);
}
@Override
public LocalSearchStepScope<Solution_> getLastCompletedStepScope() {
return lastCompletedStepScope;
}
public void setLastCompletedStepScope(LocalSearchStepScope<Solution_> lastCompletedStepScope) {
this.lastCompletedStepScope = lastCompletedStepScope;
}
// ************************************************************************
// Calculated methods
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/localsearch/scope/LocalSearchStepScope.java | package ai.timefold.solver.core.impl.localsearch.scope;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
import ai.timefold.solver.core.preview.api.move.Move;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public final class LocalSearchStepScope<Solution_> extends AbstractStepScope<Solution_> {
private final LocalSearchPhaseScope<Solution_> phaseScope;
private double timeGradient = Double.NaN;
private Move<Solution_> step = null;
private String stepString = null;
private Long selectedMoveCount = null;
private Long acceptedMoveCount = null;
public LocalSearchStepScope(LocalSearchPhaseScope<Solution_> phaseScope) {
this(phaseScope, phaseScope.getNextStepIndex());
}
public LocalSearchStepScope(LocalSearchPhaseScope<Solution_> phaseScope, int stepIndex) {
super(stepIndex);
this.phaseScope = phaseScope;
}
@Override
public LocalSearchPhaseScope<Solution_> getPhaseScope() {
return phaseScope;
}
public double getTimeGradient() {
return timeGradient;
}
public void setTimeGradient(double timeGradient) {
this.timeGradient = timeGradient;
}
public Move<Solution_> getStep() {
return step;
}
public void setStep(Move<Solution_> step) {
this.step = step;
}
/**
* @return null if logging level is too high
*/
public String getStepString() {
return stepString;
}
public void setStepString(String stepString) {
this.stepString = stepString;
}
public Long getSelectedMoveCount() {
return selectedMoveCount;
}
public void setSelectedMoveCount(Long selectedMoveCount) {
this.selectedMoveCount = selectedMoveCount;
}
public Long getAcceptedMoveCount() {
return acceptedMoveCount;
}
public void setAcceptedMoveCount(Long acceptedMoveCount) {
this.acceptedMoveCount = acceptedMoveCount;
}
// ************************************************************************
// Calculated methods
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/InnerMutableSolutionView.java | package ai.timefold.solver.core.impl.move;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.MutableSolutionView;
import org.jspecify.annotations.NullMarked;
@NullMarked
public interface InnerMutableSolutionView<Solution_> extends MutableSolutionView<Solution_> {
VariableDescriptorAwareScoreDirector<Solution_> getScoreDirector();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/MoveRepository.java | package ai.timefold.solver.core.impl.move;
import ai.timefold.solver.core.impl.phase.event.PhaseLifecycleListener;
import ai.timefold.solver.core.impl.score.director.SessionContext;
import ai.timefold.solver.core.preview.api.move.Move;
import org.jspecify.annotations.NullMarked;
/**
* This is a shared abstraction for all three types of move iterators currently used in the solver:
*
* <ul>
* <li>{@link MoveSelectorBasedMoveRepository} for local search and exhaustive search.</li>
* <li>{@link PlacerBasedMoveRepository} for construction heuristics.</li>
* <li>{@link MoveStreamsBasedMoveRepository} for move streams.</li>
* </ul>
*
* As move streams become gradually more capable,
* these extra implementations will be removed
* until only {@link MoveStreamsBasedMoveRepository} remains in use.
* At this point, this entire abstraction will be removed,
* and all code will work with move streams directly.
*
* @param <Solution_>
*/
@NullMarked
public sealed interface MoveRepository<Solution_>
extends Iterable<Move<Solution_>>, PhaseLifecycleListener<Solution_>
permits MoveSelectorBasedMoveRepository, MoveStreamsBasedMoveRepository, PlacerBasedMoveRepository {
boolean isNeverEnding();
void initialize(SessionContext<Solution_> context);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/MoveSelectorBasedMoveRepository.java | package ai.timefold.solver.core.impl.move;
import java.util.Iterator;
import java.util.Objects;
import ai.timefold.solver.core.impl.heuristic.move.LegacyMoveAdapter;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
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.score.director.SessionContext;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.preview.api.move.Move;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class MoveSelectorBasedMoveRepository<Solution_>
implements MoveRepository<Solution_>, PhaseLifecycleListener<Solution_> {
private final MoveSelector<Solution_> moveSelector;
public MoveSelectorBasedMoveRepository(MoveSelector<Solution_> moveSelector) {
this.moveSelector = Objects.requireNonNull(moveSelector);
}
@Override
public boolean isNeverEnding() {
return moveSelector.isNeverEnding();
}
@Override
public void initialize(SessionContext<Solution_> context) {
// No need to do anything.
}
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
moveSelector.solvingStarted(solverScope);
}
@Override
public void phaseStarted(AbstractPhaseScope<Solution_> phaseScope) {
moveSelector.phaseStarted(phaseScope);
phaseScope.getScoreDirector().setMoveRepository(this);
}
@Override
public void stepStarted(AbstractStepScope<Solution_> stepScope) {
moveSelector.stepStarted(stepScope);
}
@Override
public void stepEnded(AbstractStepScope<Solution_> stepScope) {
moveSelector.stepEnded(stepScope);
}
@Override
public void phaseEnded(AbstractPhaseScope<Solution_> phaseScope) {
phaseScope.getScoreDirector().setMoveRepository(null);
moveSelector.phaseEnded(phaseScope);
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
moveSelector.solvingEnded(solverScope);
}
@Override
public Iterator<Move<Solution_>> iterator() {
return new Iterator<>() {
private final Iterator<ai.timefold.solver.core.impl.heuristic.move.Move<Solution_>> delegate =
moveSelector.iterator();
@Override
public boolean hasNext() {
return delegate.hasNext();
}
@Override
public Move<Solution_> next() {
return new LegacyMoveAdapter<>(delegate.next());
}
};
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/MoveStreamsBasedMoveRepository.java | package ai.timefold.solver.core.impl.move;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Random;
import ai.timefold.solver.core.impl.move.streams.DefaultMoveStreamFactory;
import ai.timefold.solver.core.impl.move.streams.DefaultMoveStreamSession;
import ai.timefold.solver.core.impl.move.streams.MoveIterable;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveProducer;
import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
import ai.timefold.solver.core.impl.score.director.SessionContext;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.preview.api.move.Move;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public final class MoveStreamsBasedMoveRepository<Solution_>
implements MoveRepository<Solution_> {
private final DefaultMoveStreamFactory<Solution_> moveStreamFactory;
private final MoveProducer<Solution_> moveProducer;
private final boolean random;
private @Nullable DefaultMoveStreamSession<Solution_> moveStreamSession;
private @Nullable MoveIterable<Solution_> moveIterable;
private @Nullable Random workingRandom;
public MoveStreamsBasedMoveRepository(DefaultMoveStreamFactory<Solution_> moveStreamFactory,
MoveProducer<Solution_> moveProducer, boolean random) {
this.moveStreamFactory = Objects.requireNonNull(moveStreamFactory);
this.moveProducer = Objects.requireNonNull(moveProducer);
this.random = random;
}
@Override
public boolean isNeverEnding() {
return random;
}
@Override
public void initialize(SessionContext<Solution_> context) {
if (moveStreamSession != null) {
throw new IllegalStateException("Impossible state: move repository initialized twice.");
}
moveStreamSession = moveStreamFactory.createSession(context);
moveStreamFactory.getSolutionDescriptor().visitAll(context.workingSolution(), moveStreamSession::insert);
moveStreamSession.settle();
moveIterable = moveProducer.getMoveIterable(moveStreamSession);
}
public void insert(Object planningEntityOrProblemFact) {
Objects.requireNonNull(moveStreamSession).insert(planningEntityOrProblemFact);
}
public void update(Object planningEntityOrProblemFact) {
Objects.requireNonNull(moveStreamSession).update(planningEntityOrProblemFact);
}
public void retract(Object planningEntityOrProblemFact) {
Objects.requireNonNull(moveStreamSession).retract(planningEntityOrProblemFact);
}
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
// No need to do anything.
}
@Override
public void phaseStarted(AbstractPhaseScope<Solution_> phaseScope) {
this.workingRandom = phaseScope.getWorkingRandom();
phaseScope.getScoreDirector().setMoveRepository(this);
}
@Override
public void stepStarted(AbstractStepScope<Solution_> stepScope) {
// No need to do anything.
}
@Override
public void stepEnded(AbstractStepScope<Solution_> stepScope) {
Objects.requireNonNull(moveStreamSession).settle();
}
@Override
public void phaseEnded(AbstractPhaseScope<Solution_> phaseScope) {
if (moveStreamSession != null) {
moveStreamSession = null;
}
phaseScope.getScoreDirector().setMoveRepository(null);
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
// No need to do anything.
}
@Override
public Iterator<Move<Solution_>> iterator() {
return new NeverendingMoveIterator<>(moveIterable, random ? workingRandom : null);
}
@NullMarked
private static final class NeverendingMoveIterator<Solution_> implements Iterator<Move<Solution_>> {
private final MoveIterable<Solution_> iterable;
private final @Nullable Random workingRandom;
private Iterator<Move<Solution_>> iterator;
public NeverendingMoveIterator(MoveIterable<Solution_> iterable, @Nullable Random workingRandom) {
this.iterable = Objects.requireNonNull(iterable);
this.workingRandom = workingRandom;
this.iterator = createIterator();
}
private Iterator<Move<Solution_>> createIterator() {
return workingRandom == null ? iterable.iterator() : iterable.iterator(workingRandom);
}
@Override
public boolean hasNext() {
if (iterator.hasNext()) {
return true;
}
// If exhausted, start all over.
iterator = createIterator();
return iterator.hasNext();
}
@Override
public Move<Solution_> next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return iterator.next();
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/PlacerBasedMoveRepository.java | package ai.timefold.solver.core.impl.move;
import java.util.Iterator;
import java.util.Objects;
import ai.timefold.solver.core.impl.constructionheuristic.placer.EntityPlacer;
import ai.timefold.solver.core.impl.constructionheuristic.placer.Placement;
import ai.timefold.solver.core.impl.constructionheuristic.placer.QueuedValuePlacer;
import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
import ai.timefold.solver.core.impl.score.director.SessionContext;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.preview.api.move.Move;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public final class PlacerBasedMoveRepository<Solution_>
implements MoveRepository<Solution_> {
private final EntityPlacer<Solution_> placer;
private @Nullable Iterator<Placement<Solution_>> placementIterator;
public PlacerBasedMoveRepository(EntityPlacer<Solution_> placer) {
this.placer = Objects.requireNonNull(placer);
}
public EntityPlacer<Solution_> getPlacer() {
return placer;
}
@Override
public boolean isNeverEnding() {
return false;
}
@Override
public void initialize(SessionContext<Solution_> context) {
placementIterator = placer.iterator();
}
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
placer.solvingStarted(solverScope);
}
@Override
public void phaseStarted(AbstractPhaseScope<Solution_> phaseScope) {
placer.phaseStarted(phaseScope);
phaseScope.getScoreDirector().setMoveRepository(this);
}
@Override
public void stepStarted(AbstractStepScope<Solution_> stepScope) {
placer.stepStarted(stepScope);
}
@Override
public void stepEnded(AbstractStepScope<Solution_> stepScope) {
placer.stepEnded(stepScope);
}
@Override
public void phaseEnded(AbstractPhaseScope<Solution_> phaseScope) {
phaseScope.getScoreDirector().setMoveRepository(null);
placer.phaseEnded(phaseScope);
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
placer.solvingEnded(solverScope);
}
@Override
public Iterator<Move<Solution_>> iterator() {
return Objects.requireNonNull(placementIterator).next().iterator();
}
public boolean hasNext() {
return Objects.requireNonNull(placementIterator).hasNext();
}
public boolean hasListVariable() {
// When the placer depends on a list variable, the CH phase creates a ListChangeMoveSelector.
// However, in certain cases, such as ALLOCATE_TO_VALUE_FROM_QUEUE,
// a QueuedValuePlacer can be created for a basic planning variable,
// and in these cases, the move selector does not rely on a list variable.
return placer instanceof QueuedValuePlacer<Solution_> queuedValuePlacer
&& queuedValuePlacer.hasListChangeMoveSelector();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/ChangeAction.java | package ai.timefold.solver.core.impl.move.director;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
public sealed interface ChangeAction<Solution_>
permits ListVariableAfterAssignmentAction, ListVariableAfterChangeAction, ListVariableAfterUnassignmentAction,
ListVariableBeforeAssignmentAction, ListVariableBeforeChangeAction, ListVariableBeforeUnassignmentAction,
TriggerVariableListenersAction, VariableChangeAction {
void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector);
ChangeAction<Solution_> rebase(Rebaser rebaser);
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/EphemeralMoveDirector.java | package ai.timefold.solver.core.impl.move.director;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
import ai.timefold.solver.core.preview.api.domain.metamodel.ElementPosition;
import ai.timefold.solver.core.preview.api.domain.metamodel.PlanningListVariableMetaModel;
import ai.timefold.solver.core.preview.api.move.Move;
import org.jspecify.annotations.NullMarked;
/**
* The only move director that supports undoing moves.
* Moves are undone when the director is {@link #close() closed}.
* The class can not be made {@link AutoCloseable},
* as using it in a try-with-resources statement would mean undo would happen even on moves that threw exceptions,
* causing all sorts of unexpected situations.
* This way, the move throws an exception and terminates the execution,
* therefore never even getting to the point of triggering an undo for this move.
*
* @param <Solution_>
*/
@NullMarked
final class EphemeralMoveDirector<Solution_, Score_ extends Score<Score_>>
extends MoveDirector<Solution_, Score_> {
EphemeralMoveDirector(InnerScoreDirector<Solution_, Score_> scoreDirector) {
super(scoreDirector);
}
Move<Solution_> createUndoMove() {
return new RecordedUndoMove<>(getVariableChangeRecordingScoreDirector().copyChanges());
}
@Override
public <Entity_, Value_> ElementPosition
getPositionOf(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel, Value_ value) {
return getPositionOf(getVariableChangeRecordingScoreDirector().getBacking(), variableMetaModel, value);
}
public VariableChangeRecordingScoreDirector<Solution_, Score_> getVariableChangeRecordingScoreDirector() {
return (VariableChangeRecordingScoreDirector<Solution_, Score_>) externalScoreDirector;
}
@Override
public <Result_> Result_ executeTemporary(Move<Solution_> move,
TemporaryMovePostprocessor<Solution_, Score_, Result_> postprocessor) {
throw new UnsupportedOperationException("Impossible state: This move director does not support undoing moves.");
}
public void close() {
getVariableChangeRecordingScoreDirector().undoChanges();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/ListVariableAfterAssignmentAction.java | package ai.timefold.solver.core.impl.move.director;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
record ListVariableAfterAssignmentAction<Solution_>(Object element,
ListVariableDescriptor<Solution_> variableDescriptor) implements ChangeAction<Solution_> {
@Override
public void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector) {
scoreDirector.beforeListVariableElementUnassigned(variableDescriptor, element);
}
@Override
public ChangeAction<Solution_> rebase(Rebaser rebaser) {
return new ListVariableAfterAssignmentAction<>(rebaser.rebase(element), variableDescriptor);
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/ListVariableAfterChangeAction.java | package ai.timefold.solver.core.impl.move.director;
import java.util.List;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
record ListVariableAfterChangeAction<Solution_, Entity_, Value_>(Entity_ entity, int fromIndex, int toIndex,
ListVariableDescriptor<Solution_> variableDescriptor) implements ChangeAction<Solution_> {
@Override
public void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector) {
scoreDirector.beforeListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
@SuppressWarnings("unchecked")
var items = (List<Value_>) variableDescriptor.getValue(entity).subList(fromIndex, toIndex);
items.clear();
}
@Override
public ChangeAction<Solution_> rebase(Rebaser rebaser) {
return new ListVariableAfterChangeAction<>(rebaser.rebase(entity), fromIndex, toIndex, variableDescriptor);
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/ListVariableAfterUnassignmentAction.java | package ai.timefold.solver.core.impl.move.director;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
record ListVariableAfterUnassignmentAction<Solution_>(Object element,
ListVariableDescriptor<Solution_> variableDescriptor) implements ChangeAction<Solution_> {
@Override
public void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector) {
scoreDirector.beforeListVariableElementAssigned(variableDescriptor, element);
}
@Override
public ChangeAction<Solution_> rebase(Rebaser rebaser) {
return new ListVariableAfterUnassignmentAction<>(rebaser.rebase(element), variableDescriptor);
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/ListVariableBeforeAssignmentAction.java | package ai.timefold.solver.core.impl.move.director;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
record ListVariableBeforeAssignmentAction<Solution_>(Object element,
ListVariableDescriptor<Solution_> variableDescriptor) implements ChangeAction<Solution_> {
@Override
public void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector) {
scoreDirector.afterListVariableElementUnassigned(variableDescriptor, element);
}
@Override
public ChangeAction<Solution_> rebase(Rebaser rebaser) {
return new ListVariableBeforeAssignmentAction<>(rebaser.rebase(element), variableDescriptor);
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/ListVariableBeforeChangeAction.java | package ai.timefold.solver.core.impl.move.director;
import java.util.List;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
record ListVariableBeforeChangeAction<Solution_, Entity_, Value_>(Entity_ entity, List<Value_> oldValue, int fromIndex,
int toIndex, ListVariableDescriptor<Solution_> variableDescriptor) implements ChangeAction<Solution_> {
@Override
public void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector) {
variableDescriptor.getValue(entity).addAll(fromIndex, oldValue);
scoreDirector.afterListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
}
@Override
public ChangeAction<Solution_> rebase(Rebaser rebaser) {
var rebasedValueList = oldValue().stream().map(rebaser::rebase).toList();
return new ListVariableBeforeChangeAction<>(rebaser.rebase(entity), rebasedValueList, fromIndex, toIndex,
variableDescriptor);
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/ListVariableBeforeUnassignmentAction.java | package ai.timefold.solver.core.impl.move.director;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
record ListVariableBeforeUnassignmentAction<Solution_>(Object element,
ListVariableDescriptor<Solution_> variableDescriptor) implements ChangeAction<Solution_> {
@Override
public void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector) {
scoreDirector.afterListVariableElementAssigned(variableDescriptor, element);
}
@Override
public ChangeAction<Solution_> rebase(Rebaser rebaser) {
return new ListVariableBeforeUnassignmentAction<>(rebaser.rebase(element), variableDescriptor);
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/MoveDirector.java | package ai.timefold.solver.core.impl.move.director;
import java.util.Objects;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.domain.solution.descriptor.DefaultPlanningListVariableMetaModel;
import ai.timefold.solver.core.impl.domain.solution.descriptor.DefaultPlanningVariableMetaModel;
import ai.timefold.solver.core.impl.domain.solution.descriptor.InnerGenuineVariableMetaModel;
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.heuristic.move.LegacyMoveAdapter;
import ai.timefold.solver.core.impl.move.InnerMutableSolutionView;
import ai.timefold.solver.core.impl.score.director.InnerScore;
import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.domain.metamodel.ElementPosition;
import ai.timefold.solver.core.preview.api.domain.metamodel.GenuineVariableMetaModel;
import ai.timefold.solver.core.preview.api.domain.metamodel.PlanningListVariableMetaModel;
import ai.timefold.solver.core.preview.api.domain.metamodel.PlanningVariableMetaModel;
import ai.timefold.solver.core.preview.api.move.Move;
import ai.timefold.solver.core.preview.api.move.Rebaser;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public sealed class MoveDirector<Solution_, Score_ extends Score<Score_>>
implements InnerMutableSolutionView<Solution_>, Rebaser
permits EphemeralMoveDirector {
protected final VariableDescriptorAwareScoreDirector<Solution_> externalScoreDirector;
private final InnerScoreDirector<Solution_, Score_> backingScoreDirector;
public MoveDirector(InnerScoreDirector<Solution_, Score_> scoreDirector) {
this.backingScoreDirector = Objects.requireNonNull(scoreDirector);
if (EphemeralMoveDirector.class.isAssignableFrom(getClass())) {
// Ephemeral move director records operations for a later undo,
// and the external director is no longer an instance of InnerScoreDirector.
// However, some pieces of code need methods from InnerScoreDirector,
// in which case we turn to the backing score director.
// This is only safe for operations that do not need to be undone, such as calculateScore().
// Operations which need undo must go through the external score director, which is recording in this case.
this.externalScoreDirector = new VariableChangeRecordingScoreDirector<>(scoreDirector, false);
} else {
this.externalScoreDirector = scoreDirector;
}
}
@Override
public final <Entity_, Value_> void assignValue(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
Value_ planningValue, Entity_ destinationEntity, int destinationIndex) {
var variableDescriptor =
((DefaultPlanningListVariableMetaModel<Solution_, Entity_, Value_>) variableMetaModel).variableDescriptor();
externalScoreDirector.beforeListVariableElementAssigned(variableDescriptor, planningValue);
externalScoreDirector.beforeListVariableChanged(variableDescriptor, destinationEntity, destinationIndex,
destinationIndex);
variableDescriptor.addElement(destinationEntity, destinationIndex, planningValue);
externalScoreDirector.afterListVariableChanged(variableDescriptor, destinationEntity, destinationIndex,
destinationIndex + 1);
externalScoreDirector.afterListVariableElementAssigned(variableDescriptor, planningValue);
}
@Override
public <Entity_, Value_> void unassignValue(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
Value_ value) {
var locationInList = getPositionOf(variableMetaModel, value)
.ensureAssigned(() -> """
The value (%s) is not assigned to a list variable.
This may indicate score corruption or a problem with the move's implementation."""
.formatted(value));
unassignValue(variableMetaModel, value, locationInList.entity(), locationInList.index());
}
@Override
public <Entity_, Value_> Value_ unassignValue(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
Entity_ entity, int index) {
var value = getValueAtIndex(variableMetaModel, entity, index);
unassignValue(variableMetaModel, value, entity, index);
return value;
}
private <Entity_, Value_> void unassignValue(
PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel, Value_ movedValue, Entity_ entity,
int index) {
var variableDescriptor =
((DefaultPlanningListVariableMetaModel<Solution_, Entity_, Value_>) variableMetaModel).variableDescriptor();
externalScoreDirector.beforeListVariableElementUnassigned(variableDescriptor, movedValue);
externalScoreDirector.beforeListVariableChanged(variableDescriptor, entity, index, index + 1);
variableDescriptor.getValue(entity).remove(index);
externalScoreDirector.afterListVariableChanged(variableDescriptor, entity, index, index);
externalScoreDirector.afterListVariableElementUnassigned(variableDescriptor, movedValue);
}
public final <Entity_, Value_> void changeVariable(PlanningVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
Entity_ entity, @Nullable Value_ newValue) {
var variableDescriptor = extractVariableDescriptor(variableMetaModel);
externalScoreDirector.beforeVariableChanged(variableDescriptor, entity);
variableDescriptor.setValue(entity, newValue);
externalScoreDirector.afterVariableChanged(variableDescriptor, entity);
}
@SuppressWarnings("unchecked")
public final <Entity_, Value_> @Nullable Value_ moveValueBetweenLists(
PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel, Entity_ sourceEntity, int sourceIndex,
Entity_ destinationEntity, int destinationIndex) {
if (sourceEntity == destinationEntity) {
return moveValueInList(variableMetaModel, sourceEntity, sourceIndex, destinationIndex);
}
var variableDescriptor = extractVariableDescriptor(variableMetaModel);
externalScoreDirector.beforeListVariableChanged(variableDescriptor, sourceEntity, sourceIndex, sourceIndex + 1);
var element = (Value_) variableDescriptor.removeElement(sourceEntity, sourceIndex);
externalScoreDirector.afterListVariableChanged(variableDescriptor, sourceEntity, sourceIndex, sourceIndex);
externalScoreDirector.beforeListVariableChanged(variableDescriptor, destinationEntity, destinationIndex,
destinationIndex);
variableDescriptor.addElement(destinationEntity, destinationIndex, element);
externalScoreDirector.afterListVariableChanged(variableDescriptor, destinationEntity, destinationIndex,
destinationIndex + 1);
return element;
}
@SuppressWarnings("unchecked")
@Override
public final <Entity_, Value_> @Nullable Value_ moveValueInList(
PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel, Entity_ sourceEntity, int sourceIndex,
int destinationIndex) {
if (sourceIndex == destinationIndex) {
return null;
}
var variableDescriptor = extractVariableDescriptor(variableMetaModel);
var fromIndex = Math.min(sourceIndex, destinationIndex);
var toIndex = Math.max(sourceIndex, destinationIndex) + 1;
externalScoreDirector.beforeListVariableChanged(variableDescriptor, sourceEntity, fromIndex, toIndex);
Value_ element = (Value_) variableDescriptor.removeElement(sourceEntity, sourceIndex);
variableDescriptor.addElement(sourceEntity, destinationIndex, element);
externalScoreDirector.afterListVariableChanged(variableDescriptor, sourceEntity, fromIndex, toIndex);
return element;
}
@Override
public <Entity_, Value_> void swapValuesBetweenLists(
PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel, Entity_ leftEntity, int leftIndex,
Entity_ rightEntity, int rightIndex) {
if (leftEntity == rightEntity) {
swapValuesInList(variableMetaModel, leftEntity, leftIndex, rightIndex);
} else {
var variableDescriptor = extractVariableDescriptor(variableMetaModel);
externalScoreDirector.beforeListVariableChanged(variableDescriptor, leftEntity, leftIndex, leftIndex + 1);
externalScoreDirector.beforeListVariableChanged(variableDescriptor, rightEntity, rightIndex, rightIndex + 1);
var oldLeftElement = variableDescriptor.setElement(leftEntity, leftIndex,
variableDescriptor.getElement(rightEntity, rightIndex));
variableDescriptor.setElement(rightEntity, rightIndex, oldLeftElement);
externalScoreDirector.afterListVariableChanged(variableDescriptor, leftEntity, leftIndex, leftIndex + 1);
externalScoreDirector.afterListVariableChanged(variableDescriptor, rightEntity, rightIndex, rightIndex + 1);
}
}
@Override
public <Entity_, Value_> void swapValuesInList(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
Entity_ entity, int leftIndex, int rightIndex) {
if (leftIndex == rightIndex) {
return;
}
var variableDescriptor = extractVariableDescriptor(variableMetaModel);
var fromIndex = Math.min(leftIndex, rightIndex);
var toIndex = Math.max(leftIndex, rightIndex) + 1;
externalScoreDirector.beforeListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
var oldLeftElement =
variableDescriptor.setElement(entity, leftIndex, variableDescriptor.getElement(entity, rightIndex));
variableDescriptor.setElement(entity, rightIndex, oldLeftElement);
externalScoreDirector.afterListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
}
@Override
public <Entity_, Value_> boolean isValueInRange(GenuineVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
@Nullable Entity_ entity, @Nullable Value_ value) {
var innerGenuineVariableMetaModel = (InnerGenuineVariableMetaModel<Solution_>) variableMetaModel;
var valueRangeDescriptor = innerGenuineVariableMetaModel.variableDescriptor()
.getValueRangeDescriptor();
if (valueRangeDescriptor.canExtractValueRangeFromSolution()) {
return backingScoreDirector.getValueRangeManager()
.getFromSolution(valueRangeDescriptor)
.contains(value);
} else {
return backingScoreDirector.getValueRangeManager()
.getFromEntity(valueRangeDescriptor, Objects.requireNonNull(entity))
.contains(value);
}
}
/**
* Execute a given move and make sure shadow variables are up to date after that.
*/
public final void execute(Move<Solution_> move) {
move.execute(this);
externalScoreDirector.triggerVariableListeners();
}
// Only used in tests of legacy moves.
public final void execute(ai.timefold.solver.core.impl.heuristic.move.Move<Solution_> move) {
execute(new LegacyMoveAdapter<>(move));
}
public final InnerScore<Score_> executeTemporary(Move<Solution_> move) {
var ephemeralMoveDirector = ephemeral();
ephemeralMoveDirector.execute(move);
var score = backingScoreDirector.calculateScore();
ephemeralMoveDirector.close(); // This undoes the move.
return score;
}
public <Result_> Result_ executeTemporary(Move<Solution_> move,
TemporaryMovePostprocessor<Solution_, Score_, Result_> postprocessor) {
var ephemeralMoveDirector = ephemeral();
ephemeralMoveDirector.execute(move);
var score = backingScoreDirector.calculateScore();
var result = postprocessor.apply(score, ephemeralMoveDirector.createUndoMove());
ephemeralMoveDirector.close(); // This undoes the move.
return result;
}
// Only used in tests of legacy moves.
public final <Result_> Result_ executeTemporary(ai.timefold.solver.core.impl.heuristic.move.Move<Solution_> move,
TemporaryMovePostprocessor<Solution_, Score_, Result_> postprocessor) {
return executeTemporary(new LegacyMoveAdapter<>(move), postprocessor);
}
@Override
public final <Entity_, Value_> Value_ getValue(PlanningVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
Entity_ entity) {
return extractVariableDescriptor(variableMetaModel).getValue(entity);
}
@Override
public <Entity_, Value_> int countValues(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
Entity_ entity) {
return extractVariableDescriptor(variableMetaModel).getValue(entity).size();
}
@SuppressWarnings("unchecked")
@Override
public final <Entity_, Value_> Value_ getValueAtIndex(
PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel, Entity_ entity, int index) {
return (Value_) extractVariableDescriptor(variableMetaModel).getValue(entity).get(index);
}
@Override
public <Entity_, Value_> ElementPosition
getPositionOf(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel, Value_ value) {
return getPositionOf(backingScoreDirector, variableMetaModel, value);
}
@Override
public <Entity_, Value_> boolean isPinned(PlanningVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
@Nullable Entity_ entity) {
return isPinned(extractVariableDescriptor(variableMetaModel).getEntityDescriptor(), entity);
}
public <Value_> boolean isPinned(EntityDescriptor<Solution_> entityDescriptor, @Nullable Value_ entity) {
if (entity == null) {
return false; // Null is never pinned.
}
return !entityDescriptor.isMovable(backingScoreDirector.getWorkingSolution(), entity);
}
protected static <Solution_, Entity_, Value_> ElementPosition getPositionOf(InnerScoreDirector<Solution_, ?> scoreDirector,
PlanningListVariableMetaModel<Solution_, Entity_, Value_> listVariableDescriptor, Value_ value) {
return scoreDirector.getListVariableStateSupply(extractVariableDescriptor(listVariableDescriptor))
.getElementPosition(value);
}
@Override
public <Entity_, Value_> boolean isPinned(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
@Nullable Value_ value) {
return isPinned(extractVariableDescriptor(variableMetaModel), value);
}
public <Value_> boolean isPinned(ListVariableDescriptor<Solution_> listVariableDescriptor, @Nullable Value_ value) {
if (value == null) {
return false; // Null is never pinned.
}
return backingScoreDirector.getListVariableStateSupply(listVariableDescriptor).isPinned(value);
}
@Override
public final <T> @Nullable T rebase(@Nullable T problemFactOrPlanningEntity) {
return externalScoreDirector.lookUpWorkingObject(problemFactOrPlanningEntity);
}
private static <Solution_, Entity_, Value_> BasicVariableDescriptor<Solution_>
extractVariableDescriptor(PlanningVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel) {
return ((DefaultPlanningVariableMetaModel<Solution_, Entity_, Value_>) variableMetaModel).variableDescriptor();
}
private static <Solution_, Entity_, Value_> ListVariableDescriptor<Solution_>
extractVariableDescriptor(PlanningListVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel) {
return ((DefaultPlanningListVariableMetaModel<Solution_, Entity_, Value_>) variableMetaModel).variableDescriptor();
}
/**
* Moves that are to be undone later need to be run with the instance returned by this method.
* To undo the move, remember to call {@link EphemeralMoveDirector#close()}.
*
* @return never null
*/
final EphemeralMoveDirector<Solution_, Score_> ephemeral() {
return new EphemeralMoveDirector<>(backingScoreDirector);
}
@Override
public final VariableDescriptorAwareScoreDirector<Solution_> getScoreDirector() {
return externalScoreDirector;
}
/**
* Allows for reading data produced by a temporary move, before it is undone.
* The score argument represents the score after executing the move on the solution.
* The move argument represents the undo move for that move.
*
* @param <Solution_> type of the solution
* @param <Score_> score of the move
* @param <Result_> user-defined return type of the function
*/
@FunctionalInterface
public interface TemporaryMovePostprocessor<Solution_, Score_ extends Score<Score_>, Result_>
extends BiFunction<InnerScore<Score_>, Move<Solution_>, Result_> {
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/RecordedUndoMove.java | package ai.timefold.solver.core.impl.move.director;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.core.impl.move.InnerMutableSolutionView;
import ai.timefold.solver.core.preview.api.move.Move;
import ai.timefold.solver.core.preview.api.move.MutableSolutionView;
import ai.timefold.solver.core.preview.api.move.Rebaser;
import org.jspecify.annotations.NullMarked;
@NullMarked
record RecordedUndoMove<Solution_>(List<ChangeAction<Solution_>> variableChangeActionList)
implements
Move<Solution_> {
RecordedUndoMove(List<ChangeAction<Solution_>> variableChangeActionList) {
this.variableChangeActionList = Objects.requireNonNull(variableChangeActionList);
}
@Override
public void execute(MutableSolutionView<Solution_> solutionView) {
var scoreDirector = ((InnerMutableSolutionView<Solution_>) solutionView).getScoreDirector();
for (var changeAction : variableChangeActionList) {
changeAction.undo(scoreDirector);
}
}
@Override
public Move<Solution_> rebase(Rebaser rebaser) {
return new RecordedUndoMove<>(variableChangeActionList.stream()
.map(changeAction -> changeAction.rebase(rebaser))
.toList());
}
@Override
public String toString() {
return "Undo(%s)"
.formatted(variableChangeActionList);
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/TriggerVariableListenersAction.java | package ai.timefold.solver.core.impl.move.director;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
public final class TriggerVariableListenersAction<Solution_> implements ChangeAction<Solution_> {
@Override
public void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector) {
scoreDirector.triggerVariableListeners();
}
@Override
public TriggerVariableListenersAction<Solution_> rebase(Rebaser rebaser) {
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/VariableChangeAction.java | package ai.timefold.solver.core.impl.move.director;
import ai.timefold.solver.core.impl.domain.variable.descriptor.VariableDescriptor;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorAwareScoreDirector;
import ai.timefold.solver.core.preview.api.move.Rebaser;
record VariableChangeAction<Solution_, Entity_, Value_>(Entity_ entity, Value_ oldValue,
VariableDescriptor<Solution_> variableDescriptor) implements ChangeAction<Solution_> {
@Override
public void undo(VariableDescriptorAwareScoreDirector<Solution_> scoreDirector) {
scoreDirector.beforeVariableChanged(variableDescriptor, entity);
variableDescriptor.setValue(entity, oldValue);
scoreDirector.afterVariableChanged(variableDescriptor, entity);
}
@Override
public ChangeAction<Solution_> rebase(Rebaser rebaser) {
return new VariableChangeAction<>(rebaser.rebase(entity), rebaser.rebase(oldValue), variableDescriptor);
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/director/VariableChangeRecordingScoreDirector.java | package ai.timefold.solver.core.impl.move.director;
import java.util.IdentityHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.director.ScoreDirector;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.VariableDescriptor;
import ai.timefold.solver.core.impl.heuristic.move.AbstractMove;
import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
import ai.timefold.solver.core.impl.score.director.RevertableScoreDirector;
import ai.timefold.solver.core.impl.score.director.ValueRangeManager;
import ai.timefold.solver.core.impl.score.director.VariableDescriptorCache;
public final class VariableChangeRecordingScoreDirector<Solution_, Score_ extends Score<Score_>>
implements RevertableScoreDirector<Solution_> {
private final InnerScoreDirector<Solution_, Score_> backingScoreDirector;
private final List<ChangeAction<Solution_>> variableChanges;
/*
* The fromIndex of afterListVariableChanged must match the fromIndex of its beforeListVariableChanged call.
* Otherwise this will happen in the undo move:
*
* // beforeListVariableChanged(0, 3);
* [1, 2, 3, 4]
* change
* [1, 2, 3]
* // afterListVariableChanged(2, 3)
* // Start Undo
* // Undo afterListVariableChanged(2, 3)
* [1, 2, 3] -> [1, 2]
* // Undo beforeListVariableChanged(0, 3);
* [1, 2, 3, 4, 1, 2]
*
* This map exists to ensure that this is the case.
*/
private final Map<Object, Integer> cache;
public VariableChangeRecordingScoreDirector(ScoreDirector<Solution_> backingScoreDirector) {
this(backingScoreDirector, true);
}
public VariableChangeRecordingScoreDirector(ScoreDirector<Solution_> backingScoreDirector, boolean requiresIndexCache) {
this.backingScoreDirector = (InnerScoreDirector<Solution_, Score_>) backingScoreDirector;
this.cache = requiresIndexCache ? new IdentityHashMap<>() : null;
// Intentional LinkedList; fast clear, no allocations upfront,
// will most often only carry a small number of items.
this.variableChanges = new LinkedList<>();
}
private VariableChangeRecordingScoreDirector(InnerScoreDirector<Solution_, Score_> backingScoreDirector,
List<ChangeAction<Solution_>> variableChanges, Map<Object, Integer> cache) {
this.backingScoreDirector = backingScoreDirector;
this.variableChanges = variableChanges;
this.cache = cache;
}
@Override
@SuppressWarnings("unchecked")
public List<ChangeAction<Solution_>> copyChanges() {
return List.copyOf(variableChanges);
}
@Override
public void undoChanges() {
var changeCount = variableChanges.size();
if (changeCount == 0) {
return;
}
var listIterator = variableChanges.listIterator(changeCount);
while (listIterator.hasPrevious()) { // Iterate in reverse.
var changeAction = listIterator.previous();
changeAction.undo(backingScoreDirector);
}
Objects.requireNonNull(backingScoreDirector).triggerVariableListeners();
variableChanges.clear();
if (cache != null) {
cache.clear();
}
}
@Override
public void beforeVariableChanged(VariableDescriptor<Solution_> variableDescriptor, Object entity) {
variableChanges.add(new VariableChangeAction<>(entity, variableDescriptor.getValue(entity), variableDescriptor));
if (backingScoreDirector != null) {
backingScoreDirector.beforeVariableChanged(variableDescriptor, entity);
}
}
@Override
public void afterVariableChanged(VariableDescriptor<Solution_> variableDescriptor, Object entity) {
if (backingScoreDirector != null) {
backingScoreDirector.afterVariableChanged(variableDescriptor, entity);
}
}
@Override
public void beforeListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor, Object entity, int fromIndex,
int toIndex) {
// List is fromIndex, fromIndex, since the undo action for afterListVariableChange will clear the affected list
if (cache != null) {
cache.put(entity, fromIndex);
}
var list = variableDescriptor.getValue(entity);
variableChanges.add(new ListVariableBeforeChangeAction<>(entity,
List.copyOf(list.subList(fromIndex, toIndex)), fromIndex, toIndex,
variableDescriptor));
if (backingScoreDirector != null) {
backingScoreDirector.beforeListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
}
}
@Override
public void afterListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor, Object entity, int fromIndex,
int toIndex) {
if (cache != null) {
Integer requiredFromIndex = cache.remove(entity);
if (requiredFromIndex != fromIndex) {
throw new IllegalArgumentException(
"""
The fromIndex of afterListVariableChanged (%d) must match the fromIndex of its beforeListVariableChanged counterpart (%d).
Maybe check implementation of your %s."""
.formatted(fromIndex, requiredFromIndex, AbstractMove.class.getSimpleName()));
}
}
variableChanges.add(new ListVariableAfterChangeAction<>(entity, fromIndex, toIndex, variableDescriptor));
if (backingScoreDirector != null) {
backingScoreDirector.afterListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
}
}
@Override
public void beforeListVariableElementAssigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element) {
variableChanges.add(new ListVariableBeforeAssignmentAction<>(element, variableDescriptor));
if (backingScoreDirector != null) {
backingScoreDirector.beforeListVariableElementAssigned(variableDescriptor, element);
}
}
@Override
public void afterListVariableElementAssigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element) {
variableChanges.add(new ListVariableAfterAssignmentAction<>(element, variableDescriptor));
if (backingScoreDirector != null) {
backingScoreDirector.afterListVariableElementAssigned(variableDescriptor, element);
}
}
@Override
public void beforeListVariableElementUnassigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element) {
variableChanges.add(new ListVariableBeforeUnassignmentAction<>(element, variableDescriptor));
if (backingScoreDirector != null) {
backingScoreDirector.beforeListVariableElementUnassigned(variableDescriptor, element);
}
}
@Override
public void afterListVariableElementUnassigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element) {
variableChanges.add(new ListVariableAfterUnassignmentAction<>(element, variableDescriptor));
if (backingScoreDirector != null) {
backingScoreDirector.afterListVariableElementUnassigned(variableDescriptor, element);
}
}
// For other operations, call the delegate's method.
@Override
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return Objects.requireNonNull(backingScoreDirector).getSolutionDescriptor();
}
@Override
public ValueRangeManager<Solution_> getValueRangeManager() {
return getBacking().getValueRangeManager();
}
/**
* Returns the score director to which events are delegated.
*/
public InnerScoreDirector<Solution_, Score_> getBacking() {
return backingScoreDirector;
}
/**
* The {@code VariableChangeRecordingScoreDirector} score director includes two main tasks:
* tracking any variable change and firing events to a delegated score director.
* This method returns a copy of the score director
* that only tracks variable changes without firing any delegated score director events.
*/
public VariableChangeRecordingScoreDirector<Solution_, Score_> getNonDelegating() {
return new VariableChangeRecordingScoreDirector<>(null, variableChanges, cache);
}
@Override
public Solution_ getWorkingSolution() {
return Objects.requireNonNull(backingScoreDirector).getWorkingSolution();
}
@Override
public VariableDescriptorCache<Solution_> getVariableDescriptorCache() {
return Objects.requireNonNull(backingScoreDirector).getVariableDescriptorCache();
}
@Override
public void triggerVariableListeners() {
variableChanges.add(new TriggerVariableListenersAction<>());
if (backingScoreDirector != null) {
backingScoreDirector.triggerVariableListeners();
}
}
@Override
public <E> E lookUpWorkingObject(E externalObject) {
return Objects.requireNonNull(backingScoreDirector).lookUpWorkingObject(externalObject);
}
@Override
public <E> E lookUpWorkingObjectOrReturnNull(E externalObject) {
return Objects.requireNonNull(backingScoreDirector).lookUpWorkingObjectOrReturnNull(externalObject);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/DefaultBiFromBiMoveStream.java | package ai.timefold.solver.core.impl.move.streams;
import java.util.Objects;
import ai.timefold.solver.core.impl.move.streams.dataset.bi.BiDataset;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiMoveConstructor;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiMoveStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveProducer;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class DefaultBiFromBiMoveStream<Solution_, A, B> implements BiMoveStream<Solution_, A, B> {
private final BiDataset<Solution_, A, B> dataset;
public DefaultBiFromBiMoveStream(BiDataset<Solution_, A, B> dataset) {
this.dataset = Objects.requireNonNull(dataset);
}
@Override
public MoveProducer<Solution_> asMove(BiMoveConstructor<Solution_, A, B> moveConstructor) {
return new FromBiUniMoveProducer<>(dataset, Objects.requireNonNull(moveConstructor));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/DefaultBiFromUnisMoveStream.java | package ai.timefold.solver.core.impl.move.streams;
import java.util.Objects;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.UniDataset;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiMoveConstructor;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiMoveStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveProducer;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class DefaultBiFromUnisMoveStream<Solution_, A, B> implements BiMoveStream<Solution_, A, B> {
private final UniDataset<Solution_, A> leftDataset;
private final UniDataset<Solution_, B> rightDataset;
private final BiPredicate<A, B> filter;
public DefaultBiFromUnisMoveStream(UniDataset<Solution_, A> leftDataset, UniDataset<Solution_, B> rightDataset,
BiPredicate<A, B> filter) {
this.leftDataset = Objects.requireNonNull(leftDataset);
this.rightDataset = Objects.requireNonNull(rightDataset);
this.filter = Objects.requireNonNull(filter);
}
@Override
public MoveProducer<Solution_> asMove(BiMoveConstructor<Solution_, A, B> moveConstructor) {
return new FromUniBiMoveProducer<>(leftDataset, rightDataset, filter, Objects.requireNonNull(moveConstructor));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/DefaultMoveStreamFactory.java | package ai.timefold.solver.core.impl.move.streams;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.DatasetSessionFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.bi.AbstractBiDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.AbstractUniDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.DataJoiners;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiMoveStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveStreamFactory;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.UniDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.UniMoveStream;
import ai.timefold.solver.core.impl.score.director.SessionContext;
import ai.timefold.solver.core.preview.api.domain.metamodel.GenuineVariableMetaModel;
import ai.timefold.solver.core.preview.api.domain.metamodel.PlanningListVariableMetaModel;
import ai.timefold.solver.core.preview.api.domain.metamodel.PlanningVariableMetaModel;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class DefaultMoveStreamFactory<Solution_>
implements MoveStreamFactory<Solution_> {
private final DataStreamFactory<Solution_> dataStreamFactory;
private final DatasetSessionFactory<Solution_> datasetSessionFactory;
public DefaultMoveStreamFactory(SolutionDescriptor<Solution_> solutionDescriptor, EnvironmentMode environmentMode) {
this.dataStreamFactory = new DataStreamFactory<>(solutionDescriptor, environmentMode);
this.datasetSessionFactory = new DatasetSessionFactory<>(dataStreamFactory);
}
public DefaultMoveStreamSession<Solution_> createSession(SessionContext<Solution_> context) {
var session = datasetSessionFactory.buildSession(context);
return new DefaultMoveStreamSession<>(session, context.solutionView());
}
@Override
public <A> UniDataStream<Solution_, A> enumerate(Class<A> sourceClass, boolean includeNull) {
var entityDescriptor = getSolutionDescriptor().findEntityDescriptor(sourceClass);
if (entityDescriptor == null) { // Not an entity, can't be pinned.
return dataStreamFactory.forEachNonDiscriminating(sourceClass, includeNull);
}
if (entityDescriptor.isGenuine()) { // Genuine entity can be pinned.
return dataStreamFactory.forEachExcludingPinned(sourceClass, includeNull);
}
// From now on, we are testing a shadow entity.
var listVariableDescriptor = getSolutionDescriptor().getListVariableDescriptor();
if (listVariableDescriptor == null) { // Can't be pinned when there are only basic variables.
return dataStreamFactory.forEachNonDiscriminating(sourceClass, includeNull);
}
if (!listVariableDescriptor.supportsPinning()) { // The genuine entity does not support pinning.
return dataStreamFactory.forEachNonDiscriminating(sourceClass, includeNull);
}
if (!listVariableDescriptor.acceptsValueType(sourceClass)) { // Can't be used as an element.
return dataStreamFactory.forEachNonDiscriminating(sourceClass, includeNull);
}
// Finally a valid pin-supporting type.
return dataStreamFactory.forEachExcludingPinned(sourceClass, includeNull);
}
@Override
public <A> UniDataStream<Solution_, A> enumerateIncludingPinned(Class<A> sourceClass, boolean includeNull) {
return dataStreamFactory.forEachNonDiscriminating(sourceClass, includeNull);
}
@Override
public <Entity_, Value_> BiDataStream<Solution_, Entity_, Value_> enumerateEntityValuePairs(
GenuineVariableMetaModel<Solution_, Entity_, Value_> variableMetaModel,
UniDataStream<Solution_, Entity_> entityDataStream) {
var includeNull =
variableMetaModel instanceof PlanningVariableMetaModel<Solution_, Entity_, Value_> planningVariableMetaModel
? planningVariableMetaModel.allowsUnassigned()
: variableMetaModel instanceof PlanningListVariableMetaModel<Solution_, Entity_, Value_> planningListVariableMetaModel
&& planningListVariableMetaModel.allowsUnassignedValues();
var stream = dataStreamFactory.forEachExcludingPinned(variableMetaModel.type(), includeNull);
return entityDataStream.join(stream, DataJoiners.<Solution_, Entity_, Value_> filtering(
(solutionView, entity, value) -> solutionView.isValueInRange(variableMetaModel, entity, value)));
}
@Override
public <A> UniMoveStream<Solution_, A> pick(UniDataStream<Solution_, A> dataStream) {
return new DefaultUniMoveStream<>(this,
((AbstractUniDataStream<Solution_, A>) dataStream).createDataset());
}
@Override
public <A, B> BiMoveStream<Solution_, A, B> pick(BiDataStream<Solution_, A, B> dataStream) {
return new DefaultBiFromBiMoveStream<>(((AbstractBiDataStream<Solution_, A, B>) dataStream).createDataset());
}
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return dataStreamFactory.getSolutionDescriptor();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/DefaultMoveStreamSession.java | package ai.timefold.solver.core.impl.move.streams;
import java.util.Objects;
import ai.timefold.solver.core.impl.move.streams.dataset.DatasetSession;
import ai.timefold.solver.core.impl.move.streams.dataset.bi.BiDataset;
import ai.timefold.solver.core.impl.move.streams.dataset.bi.BiDatasetInstance;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.UniDataset;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.UniDatasetInstance;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveStreamSession;
import ai.timefold.solver.core.preview.api.move.SolutionView;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class DefaultMoveStreamSession<Solution_>
implements MoveStreamSession<Solution_> {
private final DatasetSession<Solution_> datasetSession;
private final SolutionView<Solution_> solutionView;
public DefaultMoveStreamSession(DatasetSession<Solution_> datasetSession, SolutionView<Solution_> solutionView) {
this.datasetSession = Objects.requireNonNull(datasetSession);
this.solutionView = Objects.requireNonNull(solutionView);
}
public <A> UniDatasetInstance<Solution_, A> getDatasetInstance(UniDataset<Solution_, A> dataset) {
return (UniDatasetInstance<Solution_, A>) datasetSession.getInstance(dataset);
}
public <A, B> BiDatasetInstance<Solution_, A, B> getDatasetInstance(BiDataset<Solution_, A, B> dataset) {
return (BiDatasetInstance<Solution_, A, B>) datasetSession.getInstance(dataset);
}
public void insert(Object fact) {
datasetSession.insert(fact);
}
public void update(Object fact) {
datasetSession.update(fact);
}
public void retract(Object fact) {
datasetSession.retract(fact);
}
public void settle() {
datasetSession.settle();
}
public SolutionView<Solution_> getSolutionView() {
return solutionView;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/DefaultUniMoveStream.java | package ai.timefold.solver.core.impl.move.streams;
import java.util.Objects;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.AbstractUniDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.UniDataset;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiMoveStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.UniDataStream;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class DefaultUniMoveStream<Solution_, A> implements InnerUniMoveStream<Solution_, A> {
private final DefaultMoveStreamFactory<Solution_> moveStreamFactory;
private final UniDataset<Solution_, A> dataset;
public DefaultUniMoveStream(DefaultMoveStreamFactory<Solution_> moveStreamFactory, UniDataset<Solution_, A> dataset) {
this.moveStreamFactory = Objects.requireNonNull(moveStreamFactory);
this.dataset = Objects.requireNonNull(dataset);
}
@Override
public <B> BiMoveStream<Solution_, A, B> pick(UniDataStream<Solution_, B> uniDataStream, BiPredicate<A, B> filter) {
return new DefaultBiFromUnisMoveStream<>(dataset, ((AbstractUniDataStream<Solution_, B>) uniDataStream).createDataset(),
filter);
}
@Override
public UniDataset<Solution_, A> getDataset() {
return dataset;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/FromBiUniMoveProducer.java | package ai.timefold.solver.core.impl.move.streams;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Random;
import java.util.Set;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.bi.BiDataset;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiMoveConstructor;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveStreamSession;
import ai.timefold.solver.core.preview.api.move.Move;
import ai.timefold.solver.core.preview.api.move.SolutionView;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public final class FromBiUniMoveProducer<Solution_, A, B> implements InnerMoveProducer<Solution_> {
private final BiDataset<Solution_, A, B> aDataset;
private final BiMoveConstructor<Solution_, A, B> moveConstructor;
public FromBiUniMoveProducer(BiDataset<Solution_, A, B> aDataset, BiMoveConstructor<Solution_, A, B> moveConstructor) {
this.aDataset = Objects.requireNonNull(aDataset);
this.moveConstructor = Objects.requireNonNull(moveConstructor);
}
@Override
public MoveIterable<Solution_> getMoveIterable(MoveStreamSession<Solution_> moveStreamSession) {
return new InnerMoveIterable((DefaultMoveStreamSession<Solution_>) moveStreamSession);
}
@Override
public void collectActiveDataStreams(Set<AbstractDataStream<Solution_>> activeDataStreamSet) {
aDataset.collectActiveDataStreams(activeDataStreamSet);
}
@NullMarked
private final class InnerMoveIterator implements Iterator<Move<Solution_>> {
private final IteratorSupplier<A, B> iteratorSupplier;
private final SolutionView<Solution_> solutionView;
// Fields required for iteration.
private @Nullable Move<Solution_> nextMove;
private @Nullable Iterator<BiTuple<A, B>> iterator;
public InnerMoveIterator(DefaultMoveStreamSession<Solution_> moveStreamSession) {
var aInstance = moveStreamSession.getDatasetInstance(aDataset);
this.iteratorSupplier = aInstance::iterator;
this.solutionView = moveStreamSession.getSolutionView();
}
public InnerMoveIterator(DefaultMoveStreamSession<Solution_> moveStreamSession, Random random) {
var aInstance = moveStreamSession.getDatasetInstance(aDataset);
this.iteratorSupplier = () -> aInstance.iterator(random);
this.solutionView = moveStreamSession.getSolutionView();
}
@Override
public boolean hasNext() {
// If we already found the next move, return true.
if (nextMove != null) {
return true;
}
// Initialize iterator if needed.
if (iterator == null) {
iterator = iteratorSupplier.get();
}
// If iterator is empty, there's no next move.
if (!iterator.hasNext()) {
return false;
}
var tuple = iterator.next();
nextMove = moveConstructor.apply(solutionView, tuple.factA, tuple.factB);
return true;
}
@Override
public Move<Solution_> next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
var result = nextMove;
nextMove = null;
return result;
}
@FunctionalInterface
private interface IteratorSupplier<A, B> extends Supplier<Iterator<BiTuple<A, B>>> {
}
}
@NullMarked
private final class InnerMoveIterable implements MoveIterable<Solution_> {
private final DefaultMoveStreamSession<Solution_> moveStreamSession;
public InnerMoveIterable(DefaultMoveStreamSession<Solution_> moveStreamSession) {
this.moveStreamSession = Objects.requireNonNull(moveStreamSession);
}
@Override
public Iterator<Move<Solution_>> iterator() {
return new InnerMoveIterator(moveStreamSession);
}
@Override
public Iterator<Move<Solution_>> iterator(Random random) {
return new InnerMoveIterator(moveStreamSession, random);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/FromUniBiMoveProducer.java | package ai.timefold.solver.core.impl.move.streams;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Random;
import java.util.Set;
import java.util.function.BiPredicate;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.UniDataset;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiMoveConstructor;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveStreamSession;
import ai.timefold.solver.core.preview.api.move.Move;
import ai.timefold.solver.core.preview.api.move.SolutionView;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public final class FromUniBiMoveProducer<Solution_, A, B> implements InnerMoveProducer<Solution_> {
private final UniDataset<Solution_, A> aDataset;
private final UniDataset<Solution_, B> bDataset;
private final BiMoveConstructor<Solution_, A, B> moveConstructor;
private final BiPredicate<A, B> filter;
public FromUniBiMoveProducer(UniDataset<Solution_, A> aDataset, UniDataset<Solution_, B> bDataset, BiPredicate<A, B> filter,
BiMoveConstructor<Solution_, A, B> moveConstructor) {
this.aDataset = Objects.requireNonNull(aDataset);
this.bDataset = Objects.requireNonNull(bDataset);
this.filter = Objects.requireNonNull(filter);
this.moveConstructor = Objects.requireNonNull(moveConstructor);
}
@Override
public MoveIterable<Solution_> getMoveIterable(MoveStreamSession<Solution_> moveStreamSession) {
return new BiMoveIterable((DefaultMoveStreamSession<Solution_>) moveStreamSession);
}
@Override
public void collectActiveDataStreams(Set<AbstractDataStream<Solution_>> activeDataStreamSet) {
aDataset.collectActiveDataStreams(activeDataStreamSet);
bDataset.collectActiveDataStreams(activeDataStreamSet);
}
private final class BiMoveIterator implements Iterator<Move<Solution_>> {
private final IteratorSupplier<A> aIteratorSupplier;
private final IteratorSupplier<B> bIteratorSupplier;
private final SolutionView<Solution_> solutionView;
// Fields required for iteration.
private @Nullable Move<Solution_> nextMove;
private @Nullable Iterator<UniTuple<A>> aIterator;
private @Nullable Iterator<UniTuple<B>> bIterator;
private @Nullable A currentA;
public BiMoveIterator(DefaultMoveStreamSession<Solution_> moveStreamSession) {
var aInstance = moveStreamSession.getDatasetInstance(aDataset);
this.aIteratorSupplier = aInstance::iterator;
var bInstance = moveStreamSession.getDatasetInstance(bDataset);
this.bIteratorSupplier = bInstance::iterator;
this.solutionView = moveStreamSession.getSolutionView();
}
public BiMoveIterator(DefaultMoveStreamSession<Solution_> moveStreamSession, Random random) {
var aInstance = moveStreamSession.getDatasetInstance(aDataset);
this.aIteratorSupplier = () -> aInstance.iterator(random);
var bInstance = moveStreamSession.getDatasetInstance(bDataset);
this.bIteratorSupplier = () -> bInstance.iterator(random);
this.solutionView = moveStreamSession.getSolutionView();
}
@Override
public boolean hasNext() {
// If we already found the next move, return true.
if (nextMove != null) {
return true;
}
// Initialize iterators if needed.
if (aIterator == null) {
aIterator = aIteratorSupplier.get();
// If first iterator is empty, there's no next move.
if (!aIterator.hasNext()) {
return false;
}
currentA = aIterator.next().factA;
bIterator = bIteratorSupplier.get();
}
// Try to find the next valid move.
while (true) {
// If inner iterator has more elements...
while (bIterator.hasNext()) {
var bTuple = bIterator.next();
var currentB = bTuple.factA;
// Check if this pair passes the filter...
if (filter.test(currentA, currentB)) {
// ... and create the next move.
nextMove = moveConstructor.apply(solutionView, currentA, currentB);
return true;
}
}
// Inner iterator exhausted, move to next outer element.
if (aIterator.hasNext()) {
currentA = aIterator.next().factA;
// Reset inner iterator for new outer element.
bIterator = bIteratorSupplier.get();
} else {
// Both iterators exhausted.
return false;
}
}
}
@Override
public Move<Solution_> next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
var result = nextMove;
nextMove = null;
return result;
}
@FunctionalInterface
private interface IteratorSupplier<A> extends Supplier<Iterator<UniTuple<A>>> {
}
}
private final class BiMoveIterable implements MoveIterable<Solution_> {
private final DefaultMoveStreamSession<Solution_> moveStreamSession;
public BiMoveIterable(DefaultMoveStreamSession<Solution_> moveStreamSession) {
this.moveStreamSession = Objects.requireNonNull(moveStreamSession);
}
@Override
public Iterator<Move<Solution_>> iterator() {
return new BiMoveIterator(moveStreamSession);
}
@Override
public Iterator<Move<Solution_>> iterator(Random random) {
return new BiMoveIterator(moveStreamSession, random);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/InnerMoveProducer.java | package ai.timefold.solver.core.impl.move.streams;
import java.util.Set;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveProducer;
import org.jspecify.annotations.NullMarked;
@NullMarked
public interface InnerMoveProducer<Solution_> extends MoveProducer<Solution_> {
void collectActiveDataStreams(Set<AbstractDataStream<Solution_>> activeDataStreamSet);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/InnerMoveStream.java | package ai.timefold.solver.core.impl.move.streams;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataset;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.MoveStream;
import org.jspecify.annotations.NullMarked;
@NullMarked
public interface InnerMoveStream<Solution_, Out_ extends AbstractTuple> extends MoveStream<Solution_> {
AbstractDataset<Solution_, Out_> getDataset();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/InnerUniMoveStream.java | package ai.timefold.solver.core.impl.move.streams;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.UniDataset;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.UniMoveStream;
import org.jspecify.annotations.NullMarked;
@NullMarked
public interface InnerUniMoveStream<Solution_, A>
extends InnerMoveStream<Solution_, UniTuple<A>>, UniMoveStream<Solution_, A> {
@Override
UniDataset<Solution_, A> getDataset();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/MoveIterable.java | package ai.timefold.solver.core.impl.move.streams;
import java.util.Iterator;
import java.util.Random;
import ai.timefold.solver.core.preview.api.move.Move;
public interface MoveIterable<Solution_> extends Iterable<Move<Solution_>> {
Iterator<Move<Solution_>> iterator(Random random);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/package-info.java | /**
* This package contains a work-in-progress implementation of a major new feature, codenamed "Move Streams".
* Nothing in this package is considered stable, and it will change on a regular basis.
* As the feature matures, the package structure will be refactored,
* classes and interfaces moved to other packages,
* and the public API will be stabilized.
* <p>
* For all intents and purposes, nothing in this package exists;
* no stable solver code should depend on any of this.
* As the feature matures, more and more of it will be integrated into the stable solver,
* when sufficiently stable and tested.
* At that point, the feature will be publicly announced and treated as a standard preview feature.
* <p>
* Typically, this work would be done on a separate branch.
* Unfortunately, the solver moves forward at a fast pace,
* and the branch would require frequent and significant conflict resolution.
* Therefore we are doing this work in the main development branch,
* but entirely separately from the stable solver.
*/
package ai.timefold.solver.core.impl.move.streams; |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/DataStreamFactory.java | package ai.timefold.solver.core.impl.move.streams.dataset;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataset;
import ai.timefold.solver.core.impl.move.streams.dataset.common.TerminalDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.AbstractUniDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.ForEachIncludingPinnedDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.DataJoiners;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.UniDataStream;
import ai.timefold.solver.core.impl.score.director.SessionContext;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class DataStreamFactory<Solution_> {
private final SolutionDescriptor<Solution_> solutionDescriptor;
private final EnvironmentMode environmentMode;
private final Map<AbstractDataStream<Solution_>, AbstractDataStream<Solution_>> sharingStreamMap = new HashMap<>(256);
public DataStreamFactory(SolutionDescriptor<Solution_> solutionDescriptor, EnvironmentMode environmentMode) {
this.solutionDescriptor = Objects.requireNonNull(solutionDescriptor);
this.environmentMode = Objects.requireNonNull(environmentMode);
}
public <A> UniDataStream<Solution_, A> forEachNonDiscriminating(Class<A> sourceClass, boolean includeNull) {
assertValidForEachType(sourceClass);
return share(new ForEachIncludingPinnedDataStream<>(this, sourceClass, includeNull));
}
@SuppressWarnings("unchecked")
public <A> UniDataStream<Solution_, A> forEachExcludingPinned(Class<A> sourceClass, boolean includeNull) {
assertValidForEachType(sourceClass);
if (!solutionDescriptor.getMetaModel().hasEntity(sourceClass)) {
// The sourceClass is not a planning entity, therefore it cannot be pinned.
return forEachNonDiscriminating(sourceClass, includeNull);
}
var listVariableDescriptor = solutionDescriptor.getListVariableDescriptor();
// We have a basic variable, or the sourceClass is not a valid type for a list variable value.
// In that case, we use the standard exclusion logic.
if (listVariableDescriptor == null || !listVariableDescriptor.acceptsValueType(sourceClass)) {
var entityDescriptor = solutionDescriptor.findEntityDescriptorOrFail(sourceClass);
// The predicate is cached to allow for node-sharing, which expects identical lambdas.
return share((AbstractUniDataStream<Solution_, A>) forEachNonDiscriminating(sourceClass, includeNull)
.filter(entityDescriptor.getEntityMovablePredicate()));
}
// The sourceClass is a list variable value, therefore we need to specialize the exclusion logic.
var parentEntityDescriptor = listVariableDescriptor.getEntityDescriptor();
if (!parentEntityDescriptor.supportsPinning()) { // Should have been eliminated earlier.
throw new UnsupportedOperationException("Impossible state: the list variable (%s) does not support pinning."
.formatted(listVariableDescriptor.getVariableName()));
}
// The predicate is cached to allow for node-sharing, which expects identical lambdas.
var stream = forEachNonDiscriminating(sourceClass, includeNull)
.ifNotExists(parentEntityDescriptor.getEntityClass(),
DataJoiners.filtering(listVariableDescriptor.getEntityContainsPinnedValuePredicate()));
return share((AbstractUniDataStream<Solution_, A>) stream);
}
public <A> void assertValidForEachType(Class<A> fromType) {
var problemFactOrEntityClassSet = solutionDescriptor.getProblemFactOrEntityClassSet();
/*
* Need to support the following situations:
* 1/ FactType == FromType; querying for the declared type.
* 2/ FromType extends/implements FactType; querying for impl type where declared type is its interface.
* 3/ FromType super FactType; querying for interface where declared type is its implementation.
*/
var hasMatchingType = problemFactOrEntityClassSet.stream()
.anyMatch(factType -> fromType.isAssignableFrom(factType) || factType.isAssignableFrom(fromType));
if (!hasMatchingType) {
var canonicalClassNameList = problemFactOrEntityClassSet.stream()
.map(Class::getCanonicalName)
.sorted()
.toList();
throw new IllegalArgumentException("""
Cannot use class (%s) in a data stream as it is neither the same as, \
nor a superclass or superinterface of one of planning entities or problem facts.
Ensure that all forEach(), join(), ifExists() and ifNotExists() building blocks only reference classes \
assignable from planning entities or problem facts (%s) annotated on the planning solution (%s)."""
.formatted(fromType.getCanonicalName(), canonicalClassNameList,
solutionDescriptor.getSolutionClass().getCanonicalName()));
}
}
public <Stream_ extends AbstractDataStream<Solution_>> Stream_ share(Stream_ stream) {
return share(stream, t -> {
});
}
/**
* Enables node sharing.
* If a stream already exists in this factory, it replaces it with the old copy.
* {@link AbstractDataStream} implement equals/hashcode ignoring child streams.
* <p>
* {@link DatasetSessionFactory#buildSession(SessionContext)} needs this to happen for all streams.
* <p>
* This must be called before the stream receives child streams.
*
* @param stream never null
* @param consumer never null
* @param <Stream_> the {@link AbstractDataStream} subclass
* @return never null
*/
@SuppressWarnings("unchecked")
public <Stream_ extends AbstractDataStream<Solution_>> Stream_ share(Stream_ stream, Consumer<Stream_> consumer) {
return (Stream_) sharingStreamMap.computeIfAbsent(stream, k -> {
consumer.accept(stream);
return stream;
});
}
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return solutionDescriptor;
}
public EnvironmentMode getEnvironmentMode() {
return environmentMode;
}
@SuppressWarnings("unchecked")
public List<AbstractDataset<Solution_, ?>> getDatasets() {
return sharingStreamMap.values().stream()
.flatMap(s -> {
if (s instanceof TerminalDataStream<?, ?, ?> terminalStream) {
return Stream.of((AbstractDataset<Solution_, ?>) terminalStream.getDataset());
}
return Stream.empty();
})
.collect(Collectors.toList());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/DatasetSession.java | package ai.timefold.solver.core.impl.move.streams.dataset;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.AbstractSession;
import ai.timefold.solver.core.impl.bavet.NodeNetwork;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataset;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDatasetInstance;
public final class DatasetSession<Solution_> extends AbstractSession {
private final Map<AbstractDataset<Solution_, ?>, AbstractDatasetInstance<Solution_, ?>> datasetInstanceMap =
new IdentityHashMap<>();
DatasetSession(NodeNetwork nodeNetwork) {
super(nodeNetwork);
}
public void registerDatasetInstance(AbstractDataset<Solution_, ?> dataset,
AbstractDatasetInstance<Solution_, ?> datasetInstance) {
var oldDatasetInstance = datasetInstanceMap.put(dataset, datasetInstance);
if (oldDatasetInstance != null) {
throw new IllegalStateException("The dataset (%s) has already been registered with session (%s)."
.formatted(dataset, this));
}
}
@SuppressWarnings("unchecked")
public <Out_ extends AbstractTuple> AbstractDatasetInstance<Solution_, Out_>
getInstance(AbstractDataset<Solution_, Out_> dataset) {
return (AbstractDatasetInstance<Solution_, Out_>) Objects.requireNonNull(datasetInstanceMap.get(dataset));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/DatasetSessionFactory.java | package ai.timefold.solver.core.impl.move.streams.dataset;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
import ai.timefold.solver.core.impl.bavet.NodeNetwork;
import ai.timefold.solver.core.impl.bavet.common.AbstractNodeBuildHelper;
import ai.timefold.solver.core.impl.bavet.uni.AbstractForEachUniNode;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.score.director.SessionContext;
public final class DatasetSessionFactory<Solution_> {
private final DataStreamFactory<Solution_> dataStreamFactory;
public DatasetSessionFactory(DataStreamFactory<Solution_> dataStreamFactory) {
this.dataStreamFactory = dataStreamFactory;
}
public DatasetSession<Solution_> buildSession(SessionContext<Solution_> context) {
var activeDataStreamSet = new LinkedHashSet<AbstractDataStream<Solution_>>();
var datasets = dataStreamFactory.getDatasets();
for (var dataset : datasets) {
dataset.collectActiveDataStreams(activeDataStreamSet);
}
var buildHelper = new DataNodeBuildHelper<>(context, activeDataStreamSet);
var session = new DatasetSession<Solution_>(buildNodeNetwork(activeDataStreamSet, buildHelper, null));
for (var datasetInstance : buildHelper.getDatasetInstanceList()) {
session.registerDatasetInstance(datasetInstance.getParent(), datasetInstance);
}
return session;
}
private NodeNetwork buildNodeNetwork(Set<AbstractDataStream<Solution_>> dataStreamSet,
DataNodeBuildHelper<Solution_> buildHelper, Consumer<String> nodeNetworkVisualizationConsumer) {
var declaredClassToNodeMap = new LinkedHashMap<Class<?>, List<AbstractForEachUniNode<?>>>();
var nodeList = buildHelper.buildNodeList(dataStreamSet, buildHelper,
AbstractDataStream::buildNode, node -> {
if (!(node instanceof AbstractForEachUniNode<?> forEachUniNode)) {
return;
}
var forEachClass = forEachUniNode.getForEachClass();
var forEachUniNodeList =
declaredClassToNodeMap.computeIfAbsent(forEachClass, k -> new ArrayList<>(2));
if (forEachUniNodeList.size() == 2) {
// Each class can have at most two forEach nodes: one including null vars, the other excluding them.
throw new IllegalStateException(
"Impossible state: For class (%s) there are already 2 nodes (%s), not adding another (%s)."
.formatted(forEachClass, forEachUniNodeList, forEachUniNode));
}
forEachUniNodeList.add(forEachUniNode);
});
if (nodeNetworkVisualizationConsumer != null) {
// TODO implement node network visualization
throw new UnsupportedOperationException("Not implemented yet");
}
return AbstractNodeBuildHelper.buildNodeNetwork(nodeList, declaredClassToNodeMap);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/AbstractBiDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import java.util.function.BiFunction;
import ai.timefold.solver.core.impl.bavet.bi.Group2Mapping0CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.bridge.AftBridgeBiDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.bridge.AftBridgeUniDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataFilter;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataMapper;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.BiDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.UniDataStream;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public abstract class AbstractBiDataStream<Solution_, A, B> extends AbstractDataStream<Solution_>
implements BiDataStream<Solution_, A, B> {
protected AbstractBiDataStream(DataStreamFactory<Solution_> dataStreamFactory) {
super(dataStreamFactory, null);
}
protected AbstractBiDataStream(DataStreamFactory<Solution_> dataStreamFactory,
@Nullable AbstractDataStream<Solution_> parent) {
super(dataStreamFactory, parent);
}
@Override
public final BiDataStream<Solution_, A, B> filter(BiDataFilter<Solution_, A, B> filter) {
return shareAndAddChild(new FilterBiDataStream<>(dataStreamFactory, this, filter));
}
protected <GroupKeyA_, GroupKeyB_> AbstractBiDataStream<Solution_, GroupKeyA_, GroupKeyB_>
groupBy(BiFunction<A, B, GroupKeyA_> groupKeyAMapping, BiFunction<A, B, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
GroupNodeConstructor.twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, Group2Mapping0CollectorBiNode::new);
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> AbstractBiDataStream<Solution_, NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
var stream = shareAndAddChild(new BiGroupBiDataStream<>(dataStreamFactory, this, nodeConstructor));
return dataStreamFactory.share(new AftBridgeBiDataStream<>(dataStreamFactory, stream), stream::setAftBridge);
}
@Override
public <ResultA_> UniDataStream<Solution_, ResultA_> map(BiDataMapper<Solution_, A, B, ResultA_> mapping) {
var stream = shareAndAddChild(new UniMapBiDataStream<>(dataStreamFactory, this, mapping));
return dataStreamFactory.share(new AftBridgeUniDataStream<>(dataStreamFactory, stream), stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_> BiDataStream<Solution_, ResultA_, ResultB_>
map(BiDataMapper<Solution_, A, B, ResultA_> mappingA, BiDataMapper<Solution_, A, B, ResultB_> mappingB) {
var stream = shareAndAddChild(new BiMapBiDataStream<>(dataStreamFactory, this, mappingA, mappingB));
return dataStreamFactory.share(new AftBridgeBiDataStream<>(dataStreamFactory, stream), stream::setAftBridge);
}
@Override
public AbstractBiDataStream<Solution_, A, B> distinct() {
if (guaranteesDistinct()) {
return this; // Already distinct, no need to create a new stream.
}
return groupBy(ConstantLambdaUtils.biPickFirst(), ConstantLambdaUtils.biPickSecond());
}
public BiDataset<Solution_, A, B> createDataset() {
var stream = shareAndAddChild(new TerminalBiDataStream<>(dataStreamFactory, this));
return stream.getDataset();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/BiDataset.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataset;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class BiDataset<Solution_, A, B> extends AbstractDataset<Solution_, BiTuple<A, B>> {
public BiDataset(DataStreamFactory<Solution_> dataStreamFactory, AbstractBiDataStream<Solution_, A, B> parent) {
super(dataStreamFactory, parent);
}
@Override
public BiDatasetInstance<Solution_, A, B> instantiate(int storeIndex) {
return new BiDatasetInstance<>(this, storeIndex);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/BiDatasetInstance.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Random;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataset;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDatasetInstance;
import ai.timefold.solver.core.impl.util.CollectionUtils;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public final class BiDatasetInstance<Solution_, A, B>
extends AbstractDatasetInstance<Solution_, BiTuple<A, B>> {
private final Map<A, ElementAwareList<BiTuple<A, B>>> tupleListMap = new LinkedHashMap<>();
public BiDatasetInstance(AbstractDataset<Solution_, BiTuple<A, B>> parent, int inputStoreIndex) {
super(parent, inputStoreIndex);
}
@Override
public void insert(BiTuple<A, B> tuple) {
var tupleList = tupleListMap.computeIfAbsent(tuple.factA, key -> new ElementAwareList<>());
var entry = tupleList.add(tuple);
tuple.setStore(inputStoreIndex, entry);
}
@Override
public void update(BiTuple<A, B> tuple) {
var actualTupleList = tuple.getStore(inputStoreIndex);
if (actualTupleList == null) { // The tuple was not inserted yet.
insert(tuple);
return;
}
var expectedTupleList = tupleListMap.get(tuple.factA);
if (actualTupleList == expectedTupleList) {
return; // Changing the tuple did not change the key.
}
retract(tuple);
insert(tuple);
}
@Override
public void retract(BiTuple<A, B> tuple) {
ElementAwareListEntry<BiTuple<A, B>> entry = tuple.removeStore(inputStoreIndex);
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
if (entry != null) {
var tupleList = entry.getList();
entry.remove();
if (tupleList.size() == 0) {
tupleListMap.remove(tuple.factA);
}
}
}
public Iterator<BiTuple<A, B>> iterator() {
return new OriginalTupleMapIterator<>(tupleListMap);
}
public Iterator<BiTuple<A, B>> iterator(Random workingRandom) {
return new RandomTupleMapIterator<>(tupleListMap, workingRandom);
}
@NullMarked
private static final class OriginalTupleMapIterator<A, B> implements Iterator<BiTuple<A, B>> {
private final Iterator<ElementAwareList<BiTuple<A, B>>> listIterator;
private @Nullable Iterator<BiTuple<A, B>> currentIterator = null;
public OriginalTupleMapIterator(Map<A, ElementAwareList<BiTuple<A, B>>> tupleListMap) {
this.listIterator = tupleListMap.values().iterator();
}
@Override
public boolean hasNext() {
while ((currentIterator == null || !currentIterator.hasNext()) && listIterator.hasNext()) {
currentIterator = listIterator.next().iterator();
}
return currentIterator != null && currentIterator.hasNext();
}
@Override
public BiTuple<A, B> next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return currentIterator.next();
}
}
@NullMarked
private static final class RandomTupleMapIterator<A, B> implements Iterator<BiTuple<A, B>> {
private final Random workingRandom;
private final Map<A, ElementAwareList<BiTuple<A, B>>> allTuplesMap;
private final List<A> keyList;
private final Map<A, List<BiTuple<A, B>>> unvisitedTuplesMap;
private @Nullable BiTuple<A, B> selection;
public RandomTupleMapIterator(Map<A, ElementAwareList<BiTuple<A, B>>> allTuplesMap, Random workingRandom) {
this.workingRandom = workingRandom;
this.allTuplesMap = allTuplesMap;
this.keyList = new ArrayList<>(allTuplesMap.keySet());
this.unvisitedTuplesMap = CollectionUtils.newHashMap(allTuplesMap.size());
}
@Override
public boolean hasNext() {
if (selection != null) {
// If we already have a selection, return true.
return true;
} else if (keyList.isEmpty()) {
// All keys were removed. This means all tuples from all lists were removed.
return false;
}
// At least one key is available, meaning at least one list contains at least one unvisited tuple.
var randomKeyIndex = workingRandom.nextInt(keyList.size());
var randomKey = keyList.get(randomKeyIndex);
var randomAccessList = unvisitedTuplesMap.get(randomKey);
if (randomAccessList == null) {
// The key exists, but the random access list is empty.
// This means that the list needs to be filled from the original tuple list,
// as all its items are now available for random access.
// This is done on-demand to avoid unnecessary computation and memory use.
var tupleList = allTuplesMap.get(randomKey);
randomAccessList = new ArrayList<>(tupleList.size());
tupleList.forEach(randomAccessList::add);
unvisitedTuplesMap.put(randomKey, randomAccessList);
}
selection = randomAccessList.remove(workingRandom.nextInt(randomAccessList.size()));
if (randomAccessList.isEmpty()) {
// The random access list is now empty, so we remove the key from the unvisited map.
// This will make the key unavailable for future iterations.
unvisitedTuplesMap.remove(randomKey);
keyList.remove(randomKeyIndex);
}
return true;
}
@Override
public BiTuple<A, B> next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
var result = selection;
selection = null;
return result;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/BiGroupBiDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.move.streams.dataset.common.bridge.AftBridgeBiDataStream;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
final class BiGroupBiDataStream<Solution_, A, B, NewA, NewB>
extends AbstractBiDataStream<Solution_, A, B> {
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
private @Nullable AftBridgeBiDataStream<Solution_, NewA, NewB> aftStream;
public BiGroupBiDataStream(DataStreamFactory<Solution_> dataStreamFactory, AbstractBiDataStream<Solution_, A, B> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(dataStreamFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(AftBridgeBiDataStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
dataStreamFactory.getEnvironmentMode());
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BiGroupBiDataStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "BiGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/BiMapBiDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.bi.MapBiToBiNode;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.move.streams.dataset.common.bridge.AftBridgeBiDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataMapper;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
final class BiMapBiDataStream<Solution_, A, B, NewA, NewB>
extends AbstractBiDataStream<Solution_, NewA, NewB> {
private final BiDataMapper<Solution_, A, B, NewA> mappingFunctionA;
private final BiDataMapper<Solution_, A, B, NewB> mappingFunctionB;
private @Nullable AftBridgeBiDataStream<Solution_, NewA, NewB> aftStream;
public BiMapBiDataStream(DataStreamFactory<Solution_> dataStreamFactory, AbstractBiDataStream<Solution_, A, B> parent,
BiDataMapper<Solution_, A, B, NewA> mappingFunctionA, BiDataMapper<Solution_, A, B, NewB> mappingFunctionB) {
super(dataStreamFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
}
public void setAftBridge(AftBridgeBiDataStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapBiToBiNode<>(inputStoreIndex,
mappingFunctionA.toBiFunction(buildHelper.getSessionContext().solutionView()),
mappingFunctionB.toBiFunction(buildHelper.getSessionContext().solutionView()),
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BiMapBiDataStream<?, ?, ?, ?, ?> that = (BiMapBiDataStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) &&
Objects.equals(mappingFunctionA, that.mappingFunctionA) &&
Objects.equals(mappingFunctionB, that.mappingFunctionB);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB);
}
@Override
public String toString() {
return "BiMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/FilterBiDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataFilter;
import org.jspecify.annotations.NullMarked;
@NullMarked
final class FilterBiDataStream<Solution_, A, B>
extends AbstractBiDataStream<Solution_, A, B> {
private final BiDataFilter<Solution_, A, B> filter;
public FilterBiDataStream(DataStreamFactory<Solution_> dataStreamFactory, AbstractBiDataStream<Solution_, A, B> parent,
BiDataFilter<Solution_, A, B> filter) {
super(dataStreamFactory, parent);
this.filter = Objects.requireNonNull(filter, "The filter cannot be null.");
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
var predicate = filter.toBiPredicate(buildHelper.getSessionContext().solutionView());
buildHelper.<BiTuple<A, B>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> TupleLifecycle.conditionally(tupleLifecycle, predicate));
}
@Override
public int hashCode() {
return Objects.hash(parent, filter);
}
@Override
public boolean equals(Object o) {
return o instanceof FilterBiDataStream<?, ?, ?> other
&& parent == other.parent
&& filter == other.filter;
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/JoinBiDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.impl.bavet.bi.IndexedJoinBiNode;
import ai.timefold.solver.core.impl.bavet.bi.UnindexedJoinBiNode;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.move.streams.dataset.common.JoinDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.bridge.ForeBridgeUniDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.joiner.DefaultBiDataJoiner;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataFilter;
public final class JoinBiDataStream<Solution_, A, B> extends AbstractBiDataStream<Solution_, A, B>
implements JoinDataStream<Solution_> {
private final ForeBridgeUniDataStream<Solution_, A> leftParent;
private final ForeBridgeUniDataStream<Solution_, B> rightParent;
private final DefaultBiDataJoiner<A, B> joiner;
private final BiDataFilter<Solution_, A, B> filtering;
public JoinBiDataStream(DataStreamFactory<Solution_> dataStreamFactory,
ForeBridgeUniDataStream<Solution_, A> leftParent, ForeBridgeUniDataStream<Solution_, B> rightParent,
DefaultBiDataJoiner<A, B> joiner, BiDataFilter<Solution_, A, B> filtering) {
super(dataStreamFactory);
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public void collectActiveDataStreams(Set<AbstractDataStream<Solution_>> dataStreamSet) {
leftParent.collectActiveDataStreams(dataStreamSet);
rightParent.collectActiveDataStreams(dataStreamSet);
dataStreamSet.add(this);
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
var solutionView = buildHelper.getSessionContext().solutionView();
var filteringDataJoiner = this.filtering == null ? null : this.filtering.toBiPredicate(solutionView);
var outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
var indexerFactory = new IndexerFactory<>(joiner.toBiJoiner());
var node = indexerFactory.hasJoiners()
? new IndexedJoinBiNode<>(indexerFactory,
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filteringDataJoiner,
outputStoreSize + 2, outputStoreSize, outputStoreSize + 1)
: new UnindexedJoinBiNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filteringDataJoiner,
outputStoreSize + 2, outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, this, leftParent, rightParent);
}
@Override
public boolean equals(Object o) {
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this join node comes from.
*/
return o instanceof JoinBiDataStream<?, ?, ?> other
&& Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent())
&& Objects.equals(joiner, other.joiner)
&& Objects.equals(filtering, other.filtering);
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent(), joiner, filtering);
}
@Override
public String toString() {
return "BiJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public AbstractDataStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public AbstractDataStream<Solution_> getRightParent() {
return rightParent;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/TerminalBiDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.move.streams.dataset.common.TerminalDataStream;
import org.jspecify.annotations.NullMarked;
@NullMarked
final class TerminalBiDataStream<Solution_, A, B>
extends AbstractBiDataStream<Solution_, A, B>
implements TerminalDataStream<Solution_, BiTuple<A, B>, BiDataset<Solution_, A, B>> {
private final BiDataset<Solution_, A, B> dataset;
public TerminalBiDataStream(DataStreamFactory<Solution_> dataStreamFactory, AbstractBiDataStream<Solution_, A, B> parent) {
super(dataStreamFactory, parent);
this.dataset = new BiDataset<>(dataStreamFactory, this);
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
assertEmptyChildStreamList();
var inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
buildHelper.putInsertUpdateRetract(this, dataset.instantiate(inputStoreIndex));
}
@Override
public BiDataset<Solution_, A, B> getDataset() {
return dataset;
}
@Override
public String toString() {
return "Terminal node";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/bi/UniMapBiDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.bi;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.bi.MapBiToUniNode;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.move.streams.dataset.common.bridge.AftBridgeUniDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.AbstractUniDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataMapper;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
final class UniMapBiDataStream<Solution_, A, B, NewA>
extends AbstractUniDataStream<Solution_, NewA> {
private final BiDataMapper<Solution_, A, B, NewA> mappingFunction;
private @Nullable AftBridgeUniDataStream<Solution_, NewA> aftStream;
public UniMapBiDataStream(DataStreamFactory<Solution_> dataStreamFactory, AbstractBiDataStream<Solution_, A, B> parent,
BiDataMapper<Solution_, A, B, NewA> mappingFunction) {
super(dataStreamFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(AftBridgeUniDataStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapBiToUniNode<>(inputStoreIndex,
mappingFunction.toBiFunction(buildHelper.getSessionContext().solutionView()),
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
UniMapBiDataStream<?, ?, ?, ?> that = (UniMapBiDataStream<?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) &&
Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
@Override
public String toString() {
return "UniMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/AbstractDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.common;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.core.impl.bavet.common.BavetStream;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public abstract class AbstractDataStream<Solution_>
implements BavetStream {
protected final DataStreamFactory<Solution_> dataStreamFactory;
protected final @Nullable AbstractDataStream<Solution_> parent;
protected final List<AbstractDataStream<Solution_>> childStreamList = new ArrayList<>(2);
protected AbstractDataStream(DataStreamFactory<Solution_> dataStreamFactory,
@Nullable AbstractDataStream<Solution_> parent) {
this.dataStreamFactory = dataStreamFactory;
this.parent = parent;
}
public final <Stream_ extends AbstractDataStream<Solution_>> Stream_ shareAndAddChild(Stream_ stream) {
return dataStreamFactory.share(stream, childStreamList::add);
}
protected boolean guaranteesDistinct() {
if (parent != null) {
// It is generally safe to take this from the parent; if the stream disagrees, it may override.
return parent.guaranteesDistinct();
} else { // Streams need to explicitly opt-in by overriding this method.
return false;
}
}
// ************************************************************************
// Node creation
// ************************************************************************
public void collectActiveDataStreams(Set<AbstractDataStream<Solution_>> dataStreamSet) {
if (parent == null) { // Maybe a join/ifExists/forEach forgot to override this?
throw new IllegalStateException("Impossible state: the stream (%s) does not have a parent."
.formatted(this));
}
parent.collectActiveDataStreams(dataStreamSet);
dataStreamSet.add(this);
}
/**
* Returns the stream which first produced the tuple that this stream operates on.
* If a stream does not have a single parent nor is it a source, it is expected to override this method.
*
* @return this if {@link TupleSource}, otherwise parent's tuple source.
*/
public AbstractDataStream<Solution_> getTupleSource() {
if (this instanceof TupleSource) {
return this;
} else if (parent == null) { // Maybe some stream forgot to override this?
throw new IllegalStateException("Impossible state: the stream (" + this + ") does not have a parent.");
}
return parent.getTupleSource();
}
public abstract void buildNode(DataNodeBuildHelper<Solution_> buildHelper);
protected void assertEmptyChildStreamList() {
if (!childStreamList.isEmpty()) {
throw new IllegalStateException(
"Impossible state: the stream (" + this + ") has a non-empty childStreamList (" + childStreamList + ").");
}
}
@Override
public final @Nullable AbstractDataStream<Solution_> getParent() {
return parent;
}
public final List<AbstractDataStream<Solution_>> getChildStreamList() {
return childStreamList;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/AbstractDataset.java | package ai.timefold.solver.core.impl.move.streams.dataset.common;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import org.jspecify.annotations.NullMarked;
@NullMarked
public abstract class AbstractDataset<Solution_, Tuple_ extends AbstractTuple> {
private final DataStreamFactory<Solution_> dataStreamFactory;
private final AbstractDataStream<Solution_> parent;
protected AbstractDataset(DataStreamFactory<Solution_> dataStreamFactory, AbstractDataStream<Solution_> parent) {
this.dataStreamFactory = Objects.requireNonNull(dataStreamFactory);
this.parent = Objects.requireNonNull(parent);
}
public void collectActiveDataStreams(Set<AbstractDataStream<Solution_>> dataStreamSet) {
parent.collectActiveDataStreams(dataStreamSet);
}
public abstract AbstractDatasetInstance<Solution_, Tuple_> instantiate(int storeIndex);
public DataStreamFactory<Solution_> getDataStreamFactory() {
return dataStreamFactory;
}
@Override
public boolean equals(Object entity) {
if (!(entity instanceof AbstractDataset<?, ?> dataset)) {
return false;
}
return Objects.equals(dataStreamFactory, dataset.dataStreamFactory) && Objects.equals(parent, dataset.parent);
}
@Override
public int hashCode() {
return Objects.hash(dataStreamFactory, parent);
}
@Override
public String toString() {
return "%s for %s".formatted(getClass().getSimpleName(), parent);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/AbstractDatasetInstance.java | package ai.timefold.solver.core.impl.move.streams.dataset.common;
import java.util.Iterator;
import java.util.Objects;
import java.util.Random;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import org.jspecify.annotations.NullMarked;
@NullMarked
public abstract class AbstractDatasetInstance<Solution_, Tuple_ extends AbstractTuple>
implements TupleLifecycle<Tuple_> {
private final AbstractDataset<Solution_, Tuple_> parent;
protected final int inputStoreIndex;
public AbstractDatasetInstance(AbstractDataset<Solution_, Tuple_> parent, int inputStoreIndex) {
this.parent = Objects.requireNonNull(parent);
this.inputStoreIndex = inputStoreIndex;
}
public AbstractDataset<Solution_, Tuple_> getParent() {
return parent;
}
public abstract Iterator<Tuple_> iterator();
public abstract Iterator<Tuple_> iterator(Random workingRandom);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/DataNodeBuildHelper.java | package ai.timefold.solver.core.impl.move.streams.dataset.common;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.impl.bavet.common.AbstractNodeBuildHelper;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.score.director.SessionContext;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class DataNodeBuildHelper<Solution_> extends AbstractNodeBuildHelper<AbstractDataStream<Solution_>> {
private final SessionContext<Solution_> sessionContext;
private final List<AbstractDatasetInstance<Solution_, ?>> datasetInstanceList = new ArrayList<>();
public DataNodeBuildHelper(SessionContext<Solution_> sessionContext, Set<AbstractDataStream<Solution_>> activeStreamSet) {
super(activeStreamSet);
this.sessionContext = Objects.requireNonNull(sessionContext);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public <Tuple_ extends AbstractTuple> void putInsertUpdateRetract(AbstractDataStream<Solution_> stream,
TupleLifecycle<Tuple_> tupleLifecycle) {
super.putInsertUpdateRetract(stream, tupleLifecycle);
if (tupleLifecycle instanceof AbstractDatasetInstance datasetInstance) {
datasetInstanceList.add(datasetInstance);
}
}
public SessionContext<Solution_> getSessionContext() {
return sessionContext;
}
public List<AbstractDatasetInstance<Solution_, ?>> getDatasetInstanceList() {
return Collections.unmodifiableList(datasetInstanceList);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/DataStreamBinaryOperation.java | package ai.timefold.solver.core.impl.move.streams.dataset.common;
import ai.timefold.solver.core.impl.bavet.common.BavetStreamBinaryOperation;
import org.jspecify.annotations.NullMarked;
@NullMarked
public sealed interface DataStreamBinaryOperation<Solution_>
extends BavetStreamBinaryOperation<AbstractDataStream<Solution_>>
permits IfExistsDataStream, JoinDataStream {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/IfExistsDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.common;
import org.jspecify.annotations.NullMarked;
@NullMarked
public non-sealed interface IfExistsDataStream<Solution_> extends DataStreamBinaryOperation<Solution_> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/JoinDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.common;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import org.jspecify.annotations.NullMarked;
@NullMarked
public non-sealed interface JoinDataStream<Solution_>
extends DataStreamBinaryOperation<Solution_>, TupleSource {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/TerminalDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import org.jspecify.annotations.NullMarked;
@NullMarked
public interface TerminalDataStream<Solution_, Tuple_ extends AbstractTuple, Dataset_ extends AbstractDataset<Solution_, Tuple_>> {
Dataset_ getDataset();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/bridge/AftBridgeBiDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.common.bridge;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.bi.AbstractBiDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class AftBridgeBiDataStream<Solution_, A, B>
extends AbstractBiDataStream<Solution_, A, B>
implements TupleSource {
public AftBridgeBiDataStream(DataStreamFactory<Solution_> dataStreamFactory, AbstractDataStream<Solution_> parent) {
super(dataStreamFactory, parent);
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
@Override
public boolean equals(Object o) {
return o instanceof AftBridgeBiDataStream<?, ?, ?> that && Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return Objects.requireNonNull(parent).hashCode();
}
@Override
public String toString() {
return "Bridge from " + parent + " with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/bridge/AftBridgeUniDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.common.bridge;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.AbstractUniDataStream;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class AftBridgeUniDataStream<Solution_, A>
extends AbstractUniDataStream<Solution_, A>
implements TupleSource {
public AftBridgeUniDataStream(DataStreamFactory<Solution_> dataStreamFactory, AbstractDataStream<Solution_> parent) {
super(dataStreamFactory, parent);
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
@Override
public boolean equals(Object o) {
return o instanceof AftBridgeUniDataStream<?, ?> that && Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return Objects.requireNonNull(parent).hashCode();
}
@Override
public String toString() {
return "Bridge from " + parent + " with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/bridge/ForeBridgeUniDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.common.bridge;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import ai.timefold.solver.core.impl.move.streams.dataset.uni.AbstractUniDataStream;
import ai.timefold.solver.core.impl.move.streams.maybeapi.stream.UniDataStream;
import org.jspecify.annotations.NullMarked;
@NullMarked
public final class ForeBridgeUniDataStream<Solution_, A>
extends AbstractUniDataStream<Solution_, A>
implements UniDataStream<Solution_, A> {
public ForeBridgeUniDataStream(DataStreamFactory<Solution_> dataStreamFactory, AbstractDataStream<Solution_> parent) {
super(dataStreamFactory, parent);
}
@Override
public void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
// Do nothing. The child stream builds everything.
}
@Override
public String toString() {
return "Generic bridge";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/common/bridge/package-info.java | /**
* Data streams that serve as bridges.
* Fore bridges go before the stream they bridge,
* while aft bridges go after.
* <p>
* Aft bridges are node-shared,
* therefore their {@link java.lang.Object#equals(Object)} and {@link java.lang.Object#hashCode()} (java.lang.Object)}
* methods are overridden to reference the bridged stream,
* which carries all the equality data.
* <p>
* Fore bridges are node-shared through their child stream
* and therefore the equality logic can reside there entirely.
*/
package ai.timefold.solver.core.impl.move.streams.dataset.common.bridge; |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/joiner/AbstractDataJoiner.java | package ai.timefold.solver.core.impl.move.streams.dataset.joiner;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.joiner.JoinerType;
import org.jspecify.annotations.NullMarked;
@NullMarked
public abstract class AbstractDataJoiner<Right_> {
protected final Function<Right_, Object>[] rightMappings;
protected final JoinerType[] joinerTypes;
protected <Property_> AbstractDataJoiner(Function<Right_, Property_> rightMapping, JoinerType joinerType) {
this(new Function[] { rightMapping }, new JoinerType[] { joinerType });
}
protected <Property_> AbstractDataJoiner(Function<Right_, Property_>[] rightMappings, JoinerType[] joinerTypes) {
this.rightMappings = (Function<Right_, Object>[]) Objects.requireNonNull(rightMappings);
this.joinerTypes = Objects.requireNonNull(joinerTypes);
}
public final Function<Right_, Object> getRightMapping(int index) {
return rightMappings[index];
}
public final int getJoinerCount() {
return joinerTypes.length;
}
public final JoinerType getJoinerType(int index) {
return joinerTypes[index];
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/joiner/BiDataJoinerComber.java | package ai.timefold.solver.core.impl.move.streams.dataset.joiner;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataFilter;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataJoiner;
import ai.timefold.solver.core.preview.api.move.SolutionView;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
/**
* Combs an array of {@link BiDataJoiner} instances into a mergedJoiner and a mergedFiltering.
*
* @param <A>
* @param <B>
*/
@NullMarked
public record BiDataJoinerComber<Solution_, A, B>(DefaultBiDataJoiner<A, B> mergedJoiner,
@Nullable BiDataFilter<Solution_, A, B> mergedFiltering) {
public static <Solution_, A, B> BiDataJoinerComber<Solution_, A, B> comb(BiDataJoiner<A, B>[] joiners) {
List<DefaultBiDataJoiner<A, B>> defaultJoinerList = new ArrayList<>(joiners.length);
List<BiDataFilter<Solution_, A, B>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
BiDataJoiner<A, B> joiner = joiners[i];
if (joiner instanceof FilteringBiDataJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringBiDataJoiner<Solution_, A, B>) joiner).filter());
} else if (joiner instanceof DefaultBiDataJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("""
Indexing joiner (%s) must not follow a filtering joiner (%s).
Maybe reorder the joiners such that filtering() joiners are later in the parameter list."""
.formatted(joiner, joiners[indexOfFirstFilter]));
}
defaultJoinerList.add((DefaultBiDataJoiner<A, B>) joiner);
} else {
throw new IllegalArgumentException(
"The joiner class (%s) is not supported.".formatted(joiner.getClass().getSimpleName()));
}
}
DefaultBiDataJoiner<A, B> mergedJoiner = DefaultBiDataJoiner.merge(defaultJoinerList);
BiDataFilter<Solution_, A, B> mergedFiltering = mergeFiltering(filteringList);
return new BiDataJoinerComber<>(mergedJoiner, mergedFiltering);
}
private static <Solution_, A, B> @Nullable BiDataFilter<Solution_, A, B>
mergeFiltering(List<BiDataFilter<Solution_, A, B>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
return switch (filteringList.size()) {
case 1 -> filteringList.get(0);
case 2 -> filteringList.get(0).and(filteringList.get(1));
default ->
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
(SolutionView<Solution_> solutionView, A a, B b) -> {
for (BiDataFilter<Solution_, A, B> predicate : filteringList) {
if (!predicate.test(solutionView, a, b)) {
return false;
}
}
return true;
};
};
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/joiner/DefaultBiDataJoiner.java | package ai.timefold.solver.core.impl.move.streams.dataset.joiner;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.bi.joiner.DefaultBiJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.AbstractJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.JoinerType;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataJoiner;
import org.jspecify.annotations.NullMarked;
@SuppressWarnings({ "unchecked", "rawtypes" })
@NullMarked
public final class DefaultBiDataJoiner<A, B> extends AbstractDataJoiner<B> implements BiDataJoiner<A, B> {
private static final DefaultBiDataJoiner NONE =
new DefaultBiDataJoiner(new Function[0], new JoinerType[0], new Function[0]);
private final Function<A, Object>[] leftMappings;
public <Property_> DefaultBiDataJoiner(Function<A, Property_> leftMapping, JoinerType joinerType,
Function<B, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new Function[] { leftMapping };
}
private <Property_> DefaultBiDataJoiner(Function<A, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<B, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = (Function<A, Object>[]) leftMappings;
}
public static <A, B> DefaultBiDataJoiner<A, B> merge(List<DefaultBiDataJoiner<A, B>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultBiDataJoiner::and);
}
public AbstractJoiner<B> toBiJoiner() {
return new DefaultBiJoiner<>(leftMappings, joinerTypes, rightMappings);
}
@Override
public DefaultBiDataJoiner<A, B> and(BiDataJoiner<A, B> otherJoiner) {
var castJoiner = (DefaultBiDataJoiner<A, B>) otherJoiner;
var joinerCount = getJoinerCount();
var castJoinerCount = castJoiner.getJoinerCount();
var newJoinerCount = joinerCount + castJoinerCount;
var newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
Function[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (var i = 0; i < castJoinerCount; i++) {
var newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultBiDataJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public Function<A, Object> getLeftMapping(int index) {
return leftMappings[index];
}
public boolean matches(A a, B b) {
var joinerCount = getJoinerCount();
for (var i = 0; i < joinerCount; i++) {
var joinerType = getJoinerType(i);
var leftMapping = getLeftMapping(i).apply(a);
var rightMapping = getRightMapping(i).apply(b);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
return o instanceof DefaultBiDataJoiner<?, ?> other
&& Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/joiner/FilteringBiDataJoiner.java | package ai.timefold.solver.core.impl.move.streams.dataset.joiner;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataFilter;
import ai.timefold.solver.core.impl.move.streams.maybeapi.BiDataJoiner;
import org.jspecify.annotations.NullMarked;
@NullMarked
public record FilteringBiDataJoiner<Solution_, A, B>(BiDataFilter<Solution_, A, B> filter) implements BiDataJoiner<A, B> {
@Override
public FilteringBiDataJoiner<Solution_, A, B> and(BiDataJoiner<A, B> otherJoiner) {
FilteringBiDataJoiner<Solution_, A, B> castJoiner = (FilteringBiDataJoiner<Solution_, A, B>) otherJoiner;
return new FilteringBiDataJoiner<>(filter.and(castJoiner.filter()));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/move/streams/dataset/uni/AbstractForEachDataStream.java | package ai.timefold.solver.core.impl.move.streams.dataset.uni;
import static ai.timefold.solver.core.impl.bavet.uni.AbstractForEachUniNode.LifecycleOperation;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.bavet.uni.ForEachUnfilteredUniNode;
import ai.timefold.solver.core.impl.move.streams.dataset.DataStreamFactory;
import ai.timefold.solver.core.impl.move.streams.dataset.common.AbstractDataStream;
import ai.timefold.solver.core.impl.move.streams.dataset.common.DataNodeBuildHelper;
import org.jspecify.annotations.NullMarked;
@NullMarked
abstract sealed class AbstractForEachDataStream<Solution_, A>
extends AbstractUniDataStream<Solution_, A>
implements TupleSource
permits ForEachIncludingPinnedDataStream {
protected final Class<A> forEachClass;
final boolean shouldIncludeNull;
protected AbstractForEachDataStream(DataStreamFactory<Solution_> dataStreamFactory, Class<A> forEachClass,
boolean includeNull) {
super(dataStreamFactory, null);
this.forEachClass = Objects.requireNonNull(forEachClass);
this.shouldIncludeNull = includeNull;
}
@Override
public final void collectActiveDataStreams(Set<AbstractDataStream<Solution_>> dataStreamSet) {
dataStreamSet.add(this);
}
@Override
public final void buildNode(DataNodeBuildHelper<Solution_> buildHelper) {
TupleLifecycle<UniTuple<A>> tupleLifecycle = buildHelper.getAggregatedTupleLifecycle(childStreamList);
var outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = new ForEachUnfilteredUniNode<>(forEachClass, tupleLifecycle, outputStoreSize);
if (shouldIncludeNull && node.supports(LifecycleOperation.INSERT)) {
node.insert(null);
}
buildHelper.addNode(node, this, null);
}
@Override
public abstract boolean equals(Object o);
@Override
public abstract int hashCode();
@Override
public abstract String toString();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.